Commit | Line | Data |
---|---|---|
ba8251e8 GS |
1 | =head1 NAME |
2 | ||
688005af | 3 | perl56delta - what's new for perl v5.6.0 |
ba8251e8 GS |
4 | |
5 | =head1 DESCRIPTION | |
6 | ||
85b33dce JH |
7 | This document describes differences between the 5.005 release and the 5.6.0 |
8 | release. | |
ba8251e8 | 9 | |
7a95317d | 10 | =head1 Core Enhancements |
ba8251e8 | 11 | |
7a95317d | 12 | =head2 Interpreter cloning, threads, and concurrency |
e02fdbd2 | 13 | |
8593bda5 | 14 | Perl 5.6.0 introduces the beginnings of support for running multiple |
7a95317d GS |
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 | |
18 | piece of code once in an interpreter, clone that interpreter | |
19 | one or more times, and run all the resulting interpreters in distinct | |
20 | threads. | |
a5222a85 | 21 | |
7a95317d GS |
22 | On the Windows platform, this feature is used to emulate fork() at the |
23 | interpreter level. See L<perlfork> for details about that. | |
e02fdbd2 | 24 | |
7a95317d GS |
25 | This feature is still in evolution. It is eventually meant to be used |
26 | to selectively clone a subroutine and data reachable from that | |
27 | subroutine in a separate interpreter and run the cloned subroutine | |
28 | in a separate thread. Since there is no shared data between the | |
29 | interpreters, little or no locking will be needed (unless parts of | |
30 | the symbol table are explicitly shared). This is obviously intended | |
31 | to be an easy-to-use replacement for the existing threads support. | |
757edf6f | 32 | |
7a95317d GS |
33 | Support for cloning interpreters and interpreter concurrency can be |
34 | enabled using the -Dusethreads Configure option (see win32/Makefile for | |
35 | how to enable it on Windows.) The resulting perl executable will be | |
36 | functionally identical to one that was built with -Dmultiplicity, but | |
37 | the perl_clone() API call will only be available in the former. | |
4f25aa18 | 38 | |
7a95317d GS |
39 | -Dusethreads enables the cpp macro USE_ITHREADS by default, which in turn |
40 | enables Perl source code changes that provide a clear separation between | |
41 | the op tree and the data it operates with. The former is immutable, and | |
42 | can therefore be shared between an interpreter and all of its clones, | |
43 | while the latter is considered local to each interpreter, and is therefore | |
44 | copied for each clone. | |
4f25aa18 | 45 | |
7a95317d GS |
46 | Note that building Perl with the -Dusemultiplicity Configure option |
47 | is adequate if you wish to run multiple B<independent> interpreters | |
48 | concurrently in different threads. -Dusethreads only provides the | |
49 | additional functionality of the perl_clone() API call and other | |
50 | support for running B<cloned> interpreters concurrently. | |
08cd8952 | 51 | |
7a95317d GS |
52 | NOTE: This is an experimental feature. Implementation details are |
53 | subject to change. | |
08cd8952 | 54 | |
7a95317d | 55 | =head2 Lexically scoped warning categories |
08cd8952 | 56 | |
7a95317d GS |
57 | You can now control the granularity of warnings emitted by perl at a finer |
58 | level using the C<use warnings> pragma. L<warnings> and L<perllexwarn> | |
59 | have copious documentation on this feature. | |
08cd8952 | 60 | |
7a95317d | 61 | =head2 Unicode and UTF-8 support |
08cd8952 | 62 | |
7a95317d GS |
63 | Perl now uses UTF-8 as its internal representation for character |
64 | strings. The C<utf8> and C<bytes> pragmas are used to control this support | |
65 | in the current lexical scope. See L<perlunicode>, L<utf8> and L<bytes> for | |
66 | more information. | |
08cd8952 | 67 | |
7a95317d GS |
68 | This feature is expected to evolve quickly to support some form of I/O |
69 | disciplines that can be used to specify the kind of input and output data | |
70 | (bytes or characters). Until that happens, additional modules from CPAN | |
71 | will be needed to complete the toolkit for dealing with Unicode. | |
08cd8952 | 72 | |
7a95317d GS |
73 | NOTE: This should be considered an experimental feature. Implementation |
74 | details are subject to change. | |
75 | ||
76 | =head2 Support for interpolating named characters | |
77 | ||
78 | The new C<\N> escape interpolates named characters within strings. | |
79 | For example, C<"Hi! \N{WHITE SMILING FACE}"> evaluates to a string | |
80 | with a unicode smiley face at the end. | |
81 | ||
82 | =head2 "our" declarations | |
83 | ||
84 | An "our" declaration introduces a value that can be best understood | |
85 | as a lexically scoped symbolic alias to a global variable in the | |
86 | package that was current where the variable was declared. This is | |
87 | mostly useful as an alternative to the C<vars> pragma, but also provides | |
88 | the opportunity to introduce typing and other attributes for such | |
89 | variables. See L<perlfunc/our>. | |
90 | ||
91 | =head2 Support for strings represented as a vector of ordinals | |
92 | ||
93 | Literals of the form C<v1.2.3.4> are now parsed as a string composed | |
94 | of characters with the specified ordinals. This is an alternative, more | |
95 | readable way to construct (possibly unicode) strings instead of | |
96 | interpolating characters, as in C<"\x{1}\x{2}\x{3}\x{4}">. The leading | |
97 | C<v> may be omitted if there are more than two ordinals, so C<1.2.3> is | |
98 | parsed the same as C<v1.2.3>. | |
99 | ||
100 | Strings written in this form are also useful to represent version "numbers". | |
101 | It is easy to compare such version "numbers" (which are really just plain | |
102 | strings) using any of the usual string comparison operators C<eq>, C<ne>, | |
103 | C<lt>, C<gt>, etc., or perform bitwise string operations on them using C<|>, | |
104 | C<&>, etc. | |
105 | ||
106 | In conjunction with the new C<$^V> magic variable (which contains | |
107 | the perl version as a string), such literals can be used as a readable way | |
108 | to check if you're running a particular version of Perl: | |
109 | ||
110 | # this will parse in older versions of Perl also | |
111 | if ($^V and $^V gt v5.6.0) { | |
112 | # new features supported | |
113 | } | |
114 | ||
3b825e41 RK |
115 | C<require> and C<use> also have some special magic to support such |
116 | literals, but this particular usage should be avoided because it leads to | |
117 | misleading error messages under versions of Perl which don't support vector | |
118 | strings. Using a true version number will ensure correct behavior in all | |
119 | versions of Perl: | |
120 | ||
121 | require 5.006; # run time check for v5.6 | |
122 | use 5.006_001; # compile time check for v5.6.1 | |
7a95317d GS |
123 | |
124 | Also, C<sprintf> and C<printf> support the Perl-specific format flag C<%v> | |
125 | to print ordinals of characters in arbitrary strings: | |
126 | ||
127 | printf "v%vd", $^V; # prints current version, such as "v5.5.650" | |
128 | printf "%*vX", ":", $addr; # formats IPv6 address | |
129 | printf "%*vb", " ", $bits; # displays bitstring | |
130 | ||
131 | See L<perldata/"Scalar value constructors"> for additional information. | |
08cd8952 | 132 | |
7a95317d | 133 | =head2 Improved Perl version numbering system |
44dcb63b | 134 | |
063663a9 | 135 | Beginning with Perl version 5.6.0, the version number convention has been |
44dcb63b GS |
136 | changed to a "dotted integer" scheme that is more commonly found in open |
137 | source projects. | |
138 | ||
139 | Maintenance versions of v5.6.0 will be released as v5.6.1, v5.6.2 etc. | |
063663a9 | 140 | The next development series following v5.6.0 will be numbered v5.7.x, |
44dcb63b | 141 | beginning with v5.7.0, and the next major production release following |
063663a9 | 142 | v5.6.0 will be v5.8.0. |
44dcb63b GS |
143 | |
144 | The English module now sets $PERL_VERSION to $^V (a string value) rather | |
145 | than C<$]> (a numeric value). (This is a potential incompatibility. | |
146 | Send us a report via perlbug if you are affected by this.) | |
147 | ||
148 | The v1.2.3 syntax is also now legal in Perl. | |
5e21a9a9 | 149 | See L</Support for strings represented as a vector of ordinals> for more on that. |
44dcb63b GS |
150 | |
151 | To cope with the new versioning system's use of at least three significant | |
152 | digits for each version component, the method used for incrementing the | |
153 | subversion number has also changed slightly. We assume that versions older | |
063663a9 | 154 | than v5.6.0 have been incrementing the subversion component in multiples of |
44dcb63b | 155 | 10. Versions after v5.6.0 will increment them by 1. Thus, using the new |
063663a9 GS |
156 | notation, 5.005_03 is the "same" as v5.5.30, and the first maintenance |
157 | version following v5.6.0 will be v5.6.1 (which should be read as being | |
158 | equivalent to a floating point value of 5.006_001 in the older format, | |
159 | stored in C<$]>). | |
44dcb63b | 160 | |
7a95317d | 161 | =head2 New syntax for declaring subroutine attributes |
dd629d5b | 162 | |
7a95317d GS |
163 | Formerly, if you wanted to mark a subroutine as being a method call or |
164 | as requiring an automatic lock() when it is entered, you had to declare | |
165 | that with a C<use attrs> pragma in the body of the subroutine. | |
166 | That can now be accomplished with declaration syntax, like this: | |
dd629d5b | 167 | |
4358a253 | 168 | sub mymethod : locked method; |
7a95317d GS |
169 | ... |
170 | sub mymethod : locked method { | |
171 | ... | |
172 | } | |
dd629d5b | 173 | |
4358a253 | 174 | sub othermethod :locked :method; |
7a95317d GS |
175 | ... |
176 | sub othermethod :locked :method { | |
177 | ... | |
178 | } | |
dd629d5b | 179 | |
757edf6f | 180 | |
7a95317d GS |
181 | (Note how only the first C<:> is mandatory, and whitespace surrounding |
182 | the C<:> is optional.) | |
757edf6f | 183 | |
7a95317d GS |
184 | F<AutoSplit.pm> and F<SelfLoader.pm> have been updated to keep the attributes |
185 | with the stubs they provide. See L<attributes>. | |
a5222a85 | 186 | |
7a95317d | 187 | =head2 File and directory handles can be autovivified |
a5222a85 | 188 | |
7a95317d GS |
189 | Similar to how constructs such as C<< $x->[0] >> autovivify a reference, |
190 | handle constructors (open(), opendir(), pipe(), socketpair(), sysopen(), | |
191 | socket(), and accept()) now autovivify a file or directory handle | |
192 | if the handle passed to them is an uninitialized scalar variable. This | |
193 | allows the constructs such as C<open(my $fh, ...)> and C<open(local $fh,...)> | |
194 | to be used to create filehandles that will conveniently be closed | |
195 | automatically when the scope ends, provided there are no other references | |
196 | to them. This largely eliminates the need for typeglobs when opening | |
197 | filehandles that must be passed around, as in the following example: | |
a5222a85 | 198 | |
7a95317d GS |
199 | sub myopen { |
200 | open my $fh, "@_" | |
201 | or die "Can't open '@_': $!"; | |
202 | return $fh; | |
203 | } | |
a5222a85 | 204 | |
7a95317d GS |
205 | { |
206 | my $f = myopen("</etc/motd"); | |
207 | print <$f>; | |
208 | # $f implicitly closed here | |
209 | } | |
a5222a85 | 210 | |
7a95317d | 211 | =head2 open() with more than two arguments |
a5222a85 | 212 | |
7a95317d GS |
213 | If open() is passed three arguments instead of two, the second argument |
214 | is used as the mode and the third argument is taken to be the file name. | |
215 | This is primarily useful for protecting against unintended magic behavior | |
216 | of the traditional two-argument form. See L<perlfunc/open>. | |
a5222a85 | 217 | |
7a95317d | 218 | =head2 64-bit support |
a5222a85 | 219 | |
7a95317d | 220 | Any platform that has 64-bit integers either |
a5222a85 | 221 | |
7a95317d GS |
222 | (1) natively as longs or ints |
223 | (2) via special compiler flags | |
224 | (3) using long long or int64_t | |
a5222a85 | 225 | |
7a95317d | 226 | is able to use "quads" (64-bit integers) as follows: |
a5222a85 | 227 | |
7a95317d | 228 | =over 4 |
a5222a85 | 229 | |
7a95317d | 230 | =item * |
a5222a85 | 231 | |
7a95317d | 232 | constants (decimal, hexadecimal, octal, binary) in the code |
a5222a85 | 233 | |
7a95317d | 234 | =item * |
a5222a85 | 235 | |
7a95317d | 236 | arguments to oct() and hex() |
a5222a85 | 237 | |
7a95317d | 238 | =item * |
a5222a85 | 239 | |
7a95317d | 240 | arguments to print(), printf() and sprintf() (flag prefixes ll, L, q) |
a5222a85 | 241 | |
7a95317d | 242 | =item * |
39429b3b | 243 | |
7a95317d | 244 | printed as such |
39429b3b | 245 | |
7a95317d | 246 | =item * |
39429b3b | 247 | |
7a95317d | 248 | pack() and unpack() "q" and "Q" formats |
39429b3b | 249 | |
7a95317d | 250 | =item * |
39429b3b | 251 | |
7a95317d GS |
252 | in basic arithmetics: + - * / % (NOTE: operating close to the limits |
253 | of the integer values may produce surprising results) | |
39429b3b | 254 | |
7a95317d | 255 | =item * |
39429b3b | 256 | |
7a95317d GS |
257 | in bit arithmetics: & | ^ ~ << >> (NOTE: these used to be forced |
258 | to be 32 bits wide but now operate on the full native width.) | |
39429b3b | 259 | |
7a95317d | 260 | =item * |
39429b3b | 261 | |
7a95317d | 262 | vec() |
cceca5ed GS |
263 | |
264 | =back | |
265 | ||
7a95317d GS |
266 | Note that unless you have the case (a) you will have to configure |
267 | and compile Perl using the -Duse64bitint Configure flag. | |
67d3893f | 268 | |
7a95317d GS |
269 | NOTE: The Configure flags -Duselonglong and -Duse64bits have been |
270 | deprecated. Use -Duse64bitint instead. | |
67d3893f | 271 | |
7a95317d GS |
272 | There are actually two modes of 64-bitness: the first one is achieved |
273 | using Configure -Duse64bitint and the second one using Configure | |
274 | -Duse64bitall. The difference is that the first one is minimal and | |
275 | the second one maximal. The first works in more places than the second. | |
67d3893f | 276 | |
7a95317d GS |
277 | The C<use64bitint> does only as much as is required to get 64-bit |
278 | integers into Perl (this may mean, for example, using "long longs") | |
279 | while your memory may still be limited to 2 gigabytes (because your | |
280 | pointers could still be 32-bit). Note that the name C<64bitint> does | |
281 | not imply that your C compiler will be using 64-bit C<int>s (it might, | |
282 | but it doesn't have to): the C<use64bitint> means that you will be | |
283 | able to have 64 bits wide scalar values. | |
67d3893f | 284 | |
7a95317d GS |
285 | The C<use64bitall> goes all the way by attempting to switch also |
286 | integers (if it can), longs (and pointers) to being 64-bit. This may | |
287 | create an even more binary incompatible Perl than -Duse64bitint: the | |
288 | resulting executable may not run at all in a 32-bit box, or you may | |
289 | have to reboot/reconfigure/rebuild your operating system to be 64-bit | |
290 | aware. | |
67d3893f | 291 | |
7a95317d GS |
292 | Natively 64-bit systems like Alpha and Cray need neither -Duse64bitint |
293 | nor -Duse64bitall. | |
67d3893f | 294 | |
7a95317d GS |
295 | Last but not least: note that due to Perl's habit of always using |
296 | floating point numbers, the quads are still not true integers. | |
297 | When quads overflow their limits (0...18_446_744_073_709_551_615 unsigned, | |
298 | -9_223_372_036_854_775_808...9_223_372_036_854_775_807 signed), they | |
299 | are silently promoted to floating point numbers, after which they will | |
300 | start losing precision (in their lower digits). | |
67d3893f | 301 | |
7a95317d GS |
302 | NOTE: 64-bit support is still experimental on most platforms. |
303 | Existing support only covers the LP64 data model. In particular, the | |
304 | LLP64 data model is not yet supported. 64-bit libraries and system | |
305 | APIs on many platforms have not stabilized--your mileage may vary. | |
642f9deb | 306 | |
7a95317d | 307 | =head2 Large file support |
a5222a85 | 308 | |
7a95317d GS |
309 | If you have filesystems that support "large files" (files larger than |
310 | 2 gigabytes), you may now also be able to create and access them from | |
311 | Perl. | |
a5222a85 | 312 | |
7a95317d GS |
313 | NOTE: The default action is to enable large file support, if |
314 | available on the platform. | |
a5222a85 | 315 | |
7a95317d GS |
316 | If the large file support is on, and you have a Fcntl constant |
317 | O_LARGEFILE, the O_LARGEFILE is automatically added to the flags | |
318 | of sysopen(). | |
a5222a85 | 319 | |
7a95317d GS |
320 | Beware that unless your filesystem also supports "sparse files" seeking |
321 | to umpteen petabytes may be inadvisable. | |
642f9deb | 322 | |
7a95317d GS |
323 | Note that in addition to requiring a proper file system to do large |
324 | files you may also need to adjust your per-process (or your | |
325 | per-system, or per-process-group, or per-user-group) maximum filesize | |
326 | limits before running Perl scripts that try to handle large files, | |
327 | especially if you intend to write such files. | |
a5222a85 | 328 | |
7a95317d GS |
329 | Finally, in addition to your process/process group maximum filesize |
330 | limits, you may have quota limits on your filesystems that stop you | |
331 | (your user id or your user group id) from using large files. | |
a5222a85 | 332 | |
7a95317d GS |
333 | Adjusting your process/user/group/file system/operating system limits |
334 | is outside the scope of Perl core language. For process limits, you | |
335 | may try increasing the limits using your shell's limits/limit/ulimit | |
336 | command before running Perl. The BSD::Resource extension (not | |
337 | included with the standard Perl distribution) may also be of use, it | |
338 | offers the getrlimit/setrlimit interface that can be used to adjust | |
339 | process resource usage limits, including the maximum filesize limit. | |
a5222a85 | 340 | |
7a95317d | 341 | =head2 Long doubles |
67d3893f | 342 | |
7a95317d GS |
343 | In some systems you may be able to use long doubles to enhance the |
344 | range and precision of your double precision floating point numbers | |
345 | (that is, Perl's numbers). Use Configure -Duselongdouble to enable | |
346 | this support (if it is available). | |
49c10eea | 347 | |
7a95317d | 348 | =head2 "more bits" |
67d3893f | 349 | |
7a95317d GS |
350 | You can "Configure -Dusemorebits" to turn on both the 64-bit support |
351 | and the long double support. | |
ba8251e8 | 352 | |
7a95317d | 353 | =head2 Enhanced support for sort() subroutines |
9d73390d | 354 | |
7a95317d GS |
355 | Perl subroutines with a prototype of C<($$)>, and XSUBs in general, can |
356 | now be used as sort subroutines. In either case, the two elements to | |
357 | be compared are passed as normal parameters in @_. See L<perlfunc/sort>. | |
21bad921 | 358 | |
7a95317d GS |
359 | For unprototyped sort subroutines, the historical behavior of passing |
360 | the elements to be compared as the global variables $a and $b remains | |
361 | unchanged. | |
9d73390d | 362 | |
7a95317d | 363 | =head2 C<sort $coderef @foo> allowed |
af365420 | 364 | |
7a95317d GS |
365 | sort() did not accept a subroutine reference as the comparison |
366 | function in earlier versions. This is now permitted. | |
af365420 | 367 | |
7a95317d | 368 | =head2 File globbing implemented internally |
af365420 | 369 | |
7a95317d GS |
370 | Perl now uses the File::Glob implementation of the glob() operator |
371 | automatically. This avoids using an external csh process and the | |
372 | problems associated with it. | |
af365420 | 373 | |
7a95317d GS |
374 | NOTE: This is currently an experimental feature. Interfaces and |
375 | implementation are subject to change. | |
af365420 | 376 | |
8593bda5 | 377 | =head2 Support for CHECK blocks |
af365420 | 378 | |
7a95317d GS |
379 | In addition to C<BEGIN>, C<INIT>, C<END>, C<DESTROY> and C<AUTOLOAD>, |
380 | subroutines named C<CHECK> are now special. These are queued up during | |
381 | compilation and behave similar to END blocks, except they are called at | |
382 | the end of compilation rather than at the end of execution. They cannot | |
383 | be called directly. | |
af365420 | 384 | |
7a95317d | 385 | =head2 POSIX character class syntax [: :] supported |
af365420 | 386 | |
7a95317d GS |
387 | For example to match alphabetic characters use /[[:alpha:]]/. |
388 | See L<perlre> for details. | |
9d73390d | 389 | |
8593bda5 | 390 | =head2 Better pseudo-random number generator |
9d73390d | 391 | |
7a95317d GS |
392 | In 5.005_0x and earlier, perl's rand() function used the C library |
393 | rand(3) function. As of 5.005_52, Configure tests for drand48(), | |
394 | random(), and rand() (in that order) and picks the first one it finds. | |
a5222a85 | 395 | |
7a95317d | 396 | These changes should result in better random numbers from rand(). |
a5222a85 | 397 | |
7a95317d | 398 | =head2 Improved C<qw//> operator |
a5222a85 | 399 | |
7a95317d GS |
400 | The C<qw//> operator is now evaluated at compile time into a true list |
401 | instead of being replaced with a run time call to C<split()>. This | |
402 | removes the confusing misbehaviour of C<qw//> in scalar context, which | |
403 | had inherited that behaviour from split(). | |
a5222a85 | 404 | |
7a95317d | 405 | Thus: |
16070b82 | 406 | |
7a95317d | 407 | $foo = ($bar) = qw(a b c); print "$foo|$bar\n"; |
16070b82 | 408 | |
7a95317d | 409 | now correctly prints "3|a", instead of "2|a". |
16070b82 | 410 | |
8593bda5 | 411 | =head2 Better worst-case behavior of hashes |
16070b82 | 412 | |
7a95317d GS |
413 | Small changes in the hashing algorithm have been implemented in |
414 | order to improve the distribution of lower order bits in the | |
415 | hashed value. This is expected to yield better performance on | |
416 | keys that are repeated sequences. | |
16070b82 | 417 | |
7a95317d | 418 | =head2 pack() format 'Z' supported |
16070b82 | 419 | |
7a95317d GS |
420 | The new format type 'Z' is useful for packing and unpacking null-terminated |
421 | strings. See L<perlfunc/"pack">. | |
16070b82 | 422 | |
7a95317d | 423 | =head2 pack() format modifier '!' supported |
a5222a85 | 424 | |
7a95317d GS |
425 | The new format type modifier '!' is useful for packing and unpacking |
426 | native shorts, ints, and longs. See L<perlfunc/"pack">. | |
dd629d5b | 427 | |
7a95317d | 428 | =head2 pack() and unpack() support counted strings |
dd629d5b | 429 | |
7a95317d GS |
430 | The template character '/' can be used to specify a counted string |
431 | type to be packed or unpacked. See L<perlfunc/"pack">. | |
1761cee5 | 432 | |
7a95317d | 433 | =head2 Comments in pack() templates |
1761cee5 | 434 | |
7a95317d GS |
435 | The '#' character in a template introduces a comment up to |
436 | end of the line. This facilitates documentation of pack() | |
437 | templates. | |
44dcb63b | 438 | |
a5222a85 GS |
439 | =head2 Weak references |
440 | ||
d4629d6a GS |
441 | In previous versions of Perl, you couldn't cache objects so as |
442 | to allow them to be deleted if the last reference from outside | |
443 | the cache is deleted. The reference in the cache would hold a | |
444 | reference count on the object and the objects would never be | |
445 | destroyed. | |
446 | ||
447 | Another familiar problem is with circular references. When an | |
448 | object references itself, its reference count would never go | |
449 | down to zero, and it would not get destroyed until the program | |
450 | is about to exit. | |
451 | ||
452 | Weak references solve this by allowing you to "weaken" any | |
453 | reference, that is, make it not count towards the reference count. | |
454 | When the last non-weak reference to an object is deleted, the object | |
455 | is destroyed and all the weak references to the object are | |
456 | automatically undef-ed. | |
a5222a85 | 457 | |
1bb10054 | 458 | To use this feature, you need the Devel::WeakRef package from CPAN, which |
d4629d6a GS |
459 | contains additional documentation. |
460 | ||
7a95317d | 461 | NOTE: This is an experimental feature. Details are subject to change. |
becf2bd3 | 462 | |
5fdc711f GS |
463 | =head2 Binary numbers supported |
464 | ||
4f19785b WSI |
465 | Binary numbers are now supported as literals, in s?printf formats, and |
466 | C<oct()>: | |
467 | ||
14218588 GS |
468 | $answer = 0b101010; |
469 | printf "The answer is: %b\n", oct("0b101010"); | |
4f19785b | 470 | |
7a95317d GS |
471 | =head2 Lvalue subroutines |
472 | ||
473 | Subroutines can now return modifiable lvalues. | |
474 | See L<perlsub/"Lvalue subroutines">. | |
475 | ||
476 | NOTE: This is an experimental feature. Details are subject to change. | |
477 | ||
a5222a85 GS |
478 | =head2 Some arrows may be omitted in calls through references |
479 | ||
480 | Perl now allows the arrow to be omitted in many constructs | |
481 | involving subroutine calls through references. For example, | |
c47ff5f1 | 482 | C<< $foo[10]->('foo') >> may now be written C<$foo[10]('foo')>. |
a5222a85 | 483 | This is rather similar to how the arrow may be omitted from |
c47ff5f1 GS |
484 | C<< $foo[10]->{'foo'} >>. Note however, that the arrow is still |
485 | required for C<< foo(10)->('bar') >>. | |
a5222a85 | 486 | |
7a95317d GS |
487 | =head2 Boolean assignment operators are legal lvalues |
488 | ||
489 | Constructs such as C<($a ||= 2) += 1> are now allowed. | |
490 | ||
afebc493 GS |
491 | =head2 exists() is supported on subroutine names |
492 | ||
493 | The exists() builtin now works on subroutine names. A subroutine | |
494 | is considered to exist if it has been declared (even if implicitly). | |
495 | See L<perlfunc/exists> for examples. | |
496 | ||
01020589 GS |
497 | =head2 exists() and delete() are supported on array elements |
498 | ||
499 | The exists() and delete() builtins now work on simple arrays as well. | |
500 | The behavior is similar to that on hash elements. | |
501 | ||
8ea97a1e | 502 | exists() can be used to check whether an array element has been |
8216c1fd GS |
503 | initialized. This avoids autovivifying array elements that don't exist. |
504 | If the array is tied, the EXISTS() method in the corresponding tied | |
505 | package will be invoked. | |
8ea97a1e GS |
506 | |
507 | delete() may be used to remove an element from the array and return | |
4375e838 | 508 | it. The array element at that position returns to its uninitialized |
8ea97a1e GS |
509 | state, so that testing for the same element with exists() will return |
510 | false. If the element happens to be the one at the end, the size of | |
8216c1fd GS |
511 | the array also shrinks up to the highest element that tests true for |
512 | exists(), or 0 if none such is found. If the array is tied, the DELETE() | |
513 | method in the corresponding tied package will be invoked. | |
01020589 GS |
514 | |
515 | See L<perlfunc/exists> and L<perlfunc/delete> for examples. | |
516 | ||
7a95317d | 517 | =head2 Pseudo-hashes work better |
9c107f78 | 518 | |
7a95317d GS |
519 | Dereferencing some types of reference values in a pseudo-hash, |
520 | such as C<< $ph->{foo}[1] >>, was accidentally disallowed. This has | |
521 | been corrected. | |
4bca7e4f | 522 | |
7a95317d GS |
523 | When applied to a pseudo-hash element, exists() now reports whether |
524 | the specified value exists, not merely if the key is valid. | |
9c107f78 | 525 | |
7a95317d GS |
526 | delete() now works on pseudo-hashes. When given a pseudo-hash element |
527 | or slice it deletes the values corresponding to the keys (but not the keys | |
528 | themselves). See L<perlref/"Pseudo-hashes: Using an array as a hash">. | |
a5222a85 | 529 | |
7a95317d GS |
530 | Pseudo-hash slices with constant keys are now optimized to array lookups |
531 | at compile-time. | |
a5222a85 | 532 | |
7a95317d | 533 | List assignments to pseudo-hash slices are now supported. |
9c107f78 | 534 | |
7a95317d GS |
535 | The C<fields> pragma now provides ways to create pseudo-hashes, via |
536 | fields::new() and fields::phash(). See L<fields>. | |
9c107f78 | 537 | |
7a95317d GS |
538 | NOTE: The pseudo-hash data type continues to be experimental. |
539 | Limiting oneself to the interface elements provided by the | |
540 | fields pragma will provide protection from any future changes. | |
a5222a85 | 541 | |
7a95317d | 542 | =head2 Automatic flushing of output buffers |
a5222a85 | 543 | |
7a95317d GS |
544 | fork(), exec(), system(), qx//, and pipe open()s now flush buffers |
545 | of all files opened for output when the operation was attempted. This | |
546 | mostly eliminates confusing buffering mishaps suffered by users unaware | |
547 | of how Perl internally handles I/O. | |
9c107f78 | 548 | |
7a95317d GS |
549 | This is not supported on some platforms like Solaris where a suitably |
550 | correct implementation of fflush(NULL) isn't available. | |
9c107f78 | 551 | |
7a95317d | 552 | =head2 Better diagnostics on meaningless filehandle operations |
a5222a85 | 553 | |
7a95317d GS |
554 | Constructs such as C<< open(<FH>) >> and C<< close(<FH>) >> |
555 | are compile time errors. Attempting to read from filehandles that | |
556 | were opened only for writing will now produce warnings (just as | |
557 | writing to read-only filehandles does). | |
a5222a85 | 558 | |
7a95317d | 559 | =head2 Where possible, buffered data discarded from duped input filehandle |
a5222a85 | 560 | |
7a95317d GS |
561 | C<< open(NEW, "<&OLD") >> now attempts to discard any data that |
562 | was previously read and buffered in C<OLD> before duping the handle. | |
563 | On platforms where doing this is allowed, the next read operation | |
564 | on C<NEW> will return the same data as the corresponding operation | |
565 | on C<OLD>. Formerly, it would have returned the data from the start | |
566 | of the following disk block instead. | |
a5222a85 | 567 | |
7a95317d | 568 | =head2 eof() has the same old magic as <> |
1fad5d67 | 569 | |
7a95317d GS |
570 | C<eof()> would return true if no attempt to read from C<< <> >> had |
571 | yet been made. C<eof()> has been changed to have a little magic of its | |
572 | own, it now opens the C<< <> >> files. | |
972b05a9 | 573 | |
7a95317d | 574 | =head2 binmode() can be used to set :crlf and :raw modes |
972b05a9 | 575 | |
7a95317d GS |
576 | binmode() now accepts a second argument that specifies a discipline |
577 | for the handle in question. The two pseudo-disciplines ":raw" and | |
578 | ":crlf" are currently supported on DOS-derivative platforms. | |
579 | See L<perlfunc/"binmode"> and L<open>. | |
9c107f78 | 580 | |
7a95317d | 581 | =head2 C<-T> filetest recognizes UTF-8 encoded files as "text" |
9c107f78 | 582 | |
7a95317d GS |
583 | The algorithm used for the C<-T> filetest has been enhanced to |
584 | correctly identify UTF-8 content as "text". | |
9c107f78 | 585 | |
7a95317d | 586 | =head2 system(), backticks and pipe open now reflect exec() failure |
55f6b6ec | 587 | |
7a95317d GS |
588 | On Unix and similar platforms, system(), qx() and open(FOO, "cmd |") |
589 | etc., are implemented via fork() and exec(). When the underlying | |
590 | exec() fails, earlier versions did not report the error properly, | |
591 | since the exec() happened to be in a different process. | |
55f6b6ec | 592 | |
7a95317d GS |
593 | The child process now communicates with the parent about the |
594 | error in launching the external command, which allows these | |
595 | constructs to return with their usual error value and set $!. | |
49c10eea | 596 | |
7a95317d | 597 | =head2 Improved diagnostics |
49c10eea | 598 | |
7a95317d GS |
599 | Line numbers are no longer suppressed (under most likely circumstances) |
600 | during the global destruction phase. | |
2d4389e4 | 601 | |
7a95317d GS |
602 | Diagnostics emitted from code running in threads other than the main |
603 | thread are now accompanied by the thread ID. | |
2d4389e4 | 604 | |
7a95317d GS |
605 | Embedded null characters in diagnostics now actually show up. They |
606 | used to truncate the message in prior versions. | |
55f6b6ec | 607 | |
7a95317d GS |
608 | $foo::a and $foo::b are now exempt from "possible typo" warnings only |
609 | if sort() is encountered in package C<foo>. | |
55f6b6ec | 610 | |
7a95317d GS |
611 | Unrecognized alphabetic escapes encountered when parsing quote |
612 | constructs now generate a warning, since they may take on new | |
613 | semantics in later versions of Perl. | |
2d4389e4 | 614 | |
7a95317d GS |
615 | Many diagnostics now report the internal operation in which the warning |
616 | was provoked, like so: | |
eed7fde4 | 617 | |
7a95317d GS |
618 | Use of uninitialized value in concatenation (.) at (eval 1) line 1. |
619 | Use of uninitialized value in print at (eval 1) line 1. | |
eed7fde4 | 620 | |
7a95317d GS |
621 | Diagnostics that occur within eval may also report the file and line |
622 | number where the eval is located, in addition to the eval sequence | |
623 | number and the line number within the evaluated text itself. For | |
624 | example: | |
475d79b5 | 625 | |
7a95317d | 626 | Not enough arguments for scalar at (eval 4)[newlib/perl5db.pl:1411] line 2, at EOF |
aa855319 | 627 | |
7a95317d | 628 | =head2 Diagnostics follow STDERR |
aa855319 | 629 | |
7a95317d GS |
630 | Diagnostic output now goes to whichever file the C<STDERR> handle |
631 | is pointing at, instead of always going to the underlying C runtime | |
632 | library's C<stderr>. | |
aa855319 | 633 | |
8593bda5 | 634 | =head2 More consistent close-on-exec behavior |
09bef843 | 635 | |
7a95317d GS |
636 | On systems that support a close-on-exec flag on filehandles, the |
637 | flag is now set for any handles created by pipe(), socketpair(), | |
638 | socket(), and accept(), if that is warranted by the value of $^F | |
639 | that may be in effect. Earlier versions neglected to set the flag | |
640 | for handles created with these operators. See L<perlfunc/pipe>, | |
641 | L<perlfunc/socketpair>, L<perlfunc/socket>, L<perlfunc/accept>, | |
642 | and L<perlvar/$^F>. | |
43481408 | 643 | |
7a95317d | 644 | =head2 syswrite() ease-of-use |
43481408 | 645 | |
7a95317d | 646 | The length argument of C<syswrite()> has become optional. |
43481408 | 647 | |
62c18ce2 GS |
648 | =head2 Better syntax checks on parenthesized unary operators |
649 | ||
650 | Expressions such as: | |
651 | ||
14218588 GS |
652 | print defined(&foo,&bar,&baz); |
653 | print uc("foo","bar","baz"); | |
654 | undef($foo,&bar); | |
62c18ce2 | 655 | |
7711098a | 656 | used to be accidentally allowed in earlier versions, and produced |
14218588 GS |
657 | unpredictable behaviour. Some produced ancillary warnings |
658 | when used in this way; others silently did the wrong thing. | |
62c18ce2 GS |
659 | |
660 | The parenthesized forms of most unary operators that expect a single | |
14218588 GS |
661 | argument now ensure that they are not called with more than one |
662 | argument, making the cases shown above syntax errors. The usual | |
663 | behaviour of: | |
62c18ce2 | 664 | |
14218588 GS |
665 | print defined &foo, &bar, &baz; |
666 | print uc "foo", "bar", "baz"; | |
667 | undef $foo, &bar; | |
62c18ce2 GS |
668 | |
669 | remains unchanged. See L<perlop>. | |
670 | ||
7a95317d | 671 | =head2 Bit operators support full native integer width |
26ef7447 | 672 | |
7a95317d GS |
673 | The bit operators (& | ^ ~ << >>) now operate on the full native |
674 | integral width (the exact size of which is available in $Config{ivsize}). | |
675 | For example, if your platform is either natively 64-bit or if Perl | |
676 | has been configured to use 64-bit integers, these operations apply | |
677 | to 8 bytes (as opposed to 4 bytes on 32-bit platforms). | |
678 | For portability, be sure to mask off the excess bits in the result of | |
679 | unary C<~>, e.g., C<~$x & 0xffffffff>. | |
26ef7447 | 680 | |
7a95317d | 681 | =head2 Improved security features |
8127e0e3 | 682 | |
7a95317d GS |
683 | More potentially unsafe operations taint their results for improved |
684 | security. | |
5a929a98 | 685 | |
7a95317d GS |
686 | The C<passwd> and C<shell> fields returned by the getpwent(), getpwnam(), |
687 | and getpwuid() are now tainted, because the user can affect their own | |
688 | encrypted password and login shell. | |
5a929a98 | 689 | |
7a95317d GS |
690 | The variable modified by shmread(), and messages returned by msgrcv() |
691 | (and its object-oriented interface IPC::SysV::Msg::rcv) are also tainted, | |
692 | because other untrusted processes can modify messages and shared memory | |
693 | segments for their own nefarious purposes. | |
ee3907e2 | 694 | |
8593bda5 | 695 | =head2 More functional bareword prototype (*) |
ee3907e2 | 696 | |
7a95317d GS |
697 | Bareword prototypes have been rationalized to enable them to be used |
698 | to override builtins that accept barewords and interpret them in | |
699 | a special way, such as C<require> or C<do>. | |
f29c64d6 | 700 | |
7a95317d GS |
701 | Arguments prototyped as C<*> will now be visible within the subroutine |
702 | as either a simple scalar or as a reference to a typeglob. | |
703 | See L<perlsub/Prototypes>. | |
f29c64d6 | 704 | |
7a95317d | 705 | =head2 C<require> and C<do> may be overridden |
a5222a85 | 706 | |
7a95317d GS |
707 | C<require> and C<do 'file'> operations may be overridden locally |
708 | by importing subroutines of the same name into the current package | |
709 | (or globally by importing them into the CORE::GLOBAL:: namespace). | |
710 | Overriding C<require> will also affect C<use>, provided the override | |
711 | is visible at compile-time. | |
712 | See L<perlsub/"Overriding Built-in Functions">. | |
a5222a85 | 713 | |
2b92dfce GS |
714 | =head2 $^X variables may now have names longer than one character |
715 | ||
716 | Formerly, $^X was synonymous with ${"\cX"}, but $^XY was a syntax | |
717 | error. Now variable names that begin with a control character may be | |
718 | arbitrarily long. However, for compatibility reasons, these variables | |
719 | I<must> be written with explicit braces, as C<${^XY}> for example. | |
14218588 | 720 | C<${^XYZ}> is synonymous with ${"\cXYZ"}. Variable names with more |
2b92dfce GS |
721 | than one control character, such as C<${^XY^Z}>, are illegal. |
722 | ||
14218588 GS |
723 | The old syntax has not changed. As before, `^X' may be either a |
724 | literal control-X character or the two-character sequence `caret' plus | |
725 | `X'. When braces are omitted, the variable name stops after the | |
2b92dfce | 726 | control character. Thus C<"$^XYZ"> continues to be synonymous with |
7711098a | 727 | C<$^X . "YZ"> as before. |
2b92dfce GS |
728 | |
729 | As before, lexical variables may not have names beginning with control | |
730 | characters. As before, variables whose names begin with a control | |
14218588 GS |
731 | character are always forced to be in package `main'. All such variables |
732 | are reserved for future extensions, except those that begin with | |
09bef843 | 733 | C<^_>, which may be used by user programs and are guaranteed not to |
14218588 | 734 | acquire special meaning in any future version of Perl. |
2b92dfce | 735 | |
a5222a85 GS |
736 | =head2 New variable $^C reflects C<-c> switch |
737 | ||
08cd8952 | 738 | C<$^C> has a boolean value that reflects whether perl is being run |
a5222a85 GS |
739 | in compile-only mode (i.e. via the C<-c> switch). Since |
740 | BEGIN blocks are executed under such conditions, this variable | |
741 | enables perl code to determine whether actions that make sense | |
742 | only during normal running are warranted. See L<perlvar>. | |
743 | ||
063663a9 | 744 | =head2 New variable $^V contains Perl version as a string |
16070b82 | 745 | |
da2094fd | 746 | C<$^V> contains the Perl version number as a string composed of |
642f9deb | 747 | characters whose ordinals match the version numbers, i.e. v5.6.0. |
063663a9 | 748 | This may be used in string comparisons. |
44dcb63b GS |
749 | |
750 | See C<Support for strings represented as a vector of ordinals> for an | |
751 | example. | |
16070b82 | 752 | |
a5222a85 GS |
753 | =head2 Optional Y2K warnings |
754 | ||
755 | If Perl is built with the cpp macro C<PERL_Y2KWARN> defined, | |
756 | it emits optional warnings when concatenating the number 19 | |
757 | with another number. | |
758 | ||
759 | This behavior must be specifically enabled when running Configure. | |
b4bc034f | 760 | See F<INSTALL> and F<README.Y2K>. |
a5222a85 | 761 | |
8593bda5 GS |
762 | =head2 Arrays now always interpolate into double-quoted strings |
763 | ||
764 | In double-quoted strings, arrays now interpolate, no matter what. The | |
765 | behavior in earlier versions of perl 5 was that arrays would interpolate | |
766 | into strings if the array had been mentioned before the string was | |
767 | compiled, and otherwise Perl would raise a fatal compile-time error. | |
768 | In versions 5.000 through 5.003, the error was | |
769 | ||
770 | Literal @example now requires backslash | |
771 | ||
772 | In versions 5.004_01 through 5.6.0, the error was | |
773 | ||
774 | In string, @example now must be written as \@example | |
775 | ||
776 | The idea here was to get people into the habit of writing | |
777 | C<"fred\@example.com"> when they wanted a literal C<@> sign, just as | |
778 | they have always written C<"Give me back my \$5"> when they wanted a | |
779 | literal C<$> sign. | |
780 | ||
781 | Starting with 5.6.1, when Perl now sees an C<@> sign in a | |
782 | double-quoted string, it I<always> attempts to interpolate an array, | |
783 | regardless of whether or not the array has been used or declared | |
784 | already. The fatal error has been downgraded to an optional warning: | |
785 | ||
786 | Possible unintended interpolation of @example in string | |
13a2d996 | 787 | |
8593bda5 GS |
788 | This warns you that C<"fred@example.com"> is going to turn into |
789 | C<fred.com> if you don't backslash the C<@>. | |
08d7a6b2 | 790 | See http://perl.plover.com/at-error.html for more details |
b3b6085d | 791 | about the history here. |
8593bda5 | 792 | |
3e4c7cf0 YST |
793 | =head2 @- and @+ provide starting/ending offsets of regex matches |
794 | ||
795 | The new magic variables @- and @+ provide the starting and ending | |
796 | offsets, respectively, of $&, $1, $2, etc. See L<perlvar> for | |
797 | details. | |
798 | ||
7a95317d | 799 | =head1 Modules and Pragmata |
fbad3eb5 | 800 | |
7a95317d | 801 | =head2 Modules |
0244c3a4 | 802 | |
7a95317d | 803 | =over 4 |
0244c3a4 | 804 | |
7a95317d | 805 | =item attributes |
0244c3a4 | 806 | |
7a95317d GS |
807 | While used internally by Perl as a pragma, this module also |
808 | provides a way to fetch subroutine and variable attributes. | |
809 | See L<attributes>. | |
0244c3a4 | 810 | |
7a95317d | 811 | =item B |
a5222a85 | 812 | |
7a95317d | 813 | The Perl Compiler suite has been extensively reworked for this |
353c6505 | 814 | release. More of the standard Perl test suite passes when run |
7a95317d GS |
815 | under the Compiler, but there is still a significant way to |
816 | go to achieve production quality compiled executables. | |
a5222a85 | 817 | |
7a95317d | 818 | NOTE: The Compiler suite remains highly experimental. The |
4375e838 | 819 | generated code may not be correct, even when it manages to execute |
7a95317d | 820 | without errors. |
a5222a85 | 821 | |
7a95317d | 822 | =item Benchmark |
45bc9206 | 823 | |
7a95317d GS |
824 | Overall, Benchmark results exhibit lower average error and better timing |
825 | accuracy. | |
45bc9206 | 826 | |
7a95317d GS |
827 | You can now run tests for I<n> seconds instead of guessing the right |
828 | number of tests to run: e.g., timethese(-5, ...) will run each | |
829 | code for at least 5 CPU seconds. Zero as the "number of repetitions" | |
830 | means "for at least 3 CPU seconds". The output format has also | |
831 | changed. For example: | |
023ceb80 | 832 | |
7a95317d | 833 | use Benchmark;$x=3;timethese(-5,{a=>sub{$x*$x},b=>sub{$x**2}}) |
af8c498a | 834 | |
7a95317d | 835 | will now output something like this: |
af8c498a | 836 | |
7a95317d GS |
837 | Benchmark: running a, b, each for at least 5 CPU seconds... |
838 | a: 5 wallclock secs ( 5.77 usr + 0.00 sys = 5.77 CPU) @ 200551.91/s (n=1156516) | |
839 | b: 4 wallclock secs ( 5.00 usr + 0.02 sys = 5.02 CPU) @ 159605.18/s (n=800686) | |
a5222a85 | 840 | |
7a95317d GS |
841 | New features: "each for at least N CPU seconds...", "wallclock secs", |
842 | and the "@ operations/CPU second (n=operations)". | |
a5222a85 | 843 | |
7a95317d GS |
844 | timethese() now returns a reference to a hash of Benchmark objects containing |
845 | the test results, keyed on the names of the tests. | |
820475bd | 846 | |
7a95317d GS |
847 | timethis() now returns the iterations field in the Benchmark result object |
848 | instead of 0. | |
820475bd | 849 | |
7a95317d GS |
850 | timethese(), timethis(), and the new cmpthese() (see below) can also take |
851 | a format specifier of 'none' to suppress output. | |
a5222a85 | 852 | |
7a95317d GS |
853 | A new function countit() is just like timeit() except that it takes a |
854 | TIME instead of a COUNT. | |
a5222a85 | 855 | |
7a95317d GS |
856 | A new function cmpthese() prints a chart comparing the results of each test |
857 | returned from a timethese() call. For each possible pair of tests, the | |
858 | percentage speed difference (iters/sec or seconds/iter) is shown. | |
a5222a85 | 859 | |
7a95317d | 860 | For other details, see L<Benchmark>. |
a5222a85 | 861 | |
7a95317d | 862 | =item ByteLoader |
a5222a85 | 863 | |
7a95317d GS |
864 | The ByteLoader is a dedicated extension to generate and run |
865 | Perl bytecode. See L<ByteLoader>. | |
a5222a85 | 866 | |
7a95317d | 867 | =item constant |
a5222a85 | 868 | |
7a95317d | 869 | References can now be used. |
a5222a85 | 870 | |
7a95317d GS |
871 | The new version also allows a leading underscore in constant names, but |
872 | disallows a double leading underscore (as in "__LINE__"). Some other names | |
873 | are disallowed or warned against, including BEGIN, END, etc. Some names | |
874 | which were forced into main:: used to fail silently in some cases; now they're | |
875 | fatal (outside of main::) and an optional warning (inside of main::). | |
876 | The ability to detect whether a constant had been set with a given name has | |
877 | been added. | |
4bca7e4f | 878 | |
7a95317d | 879 | See L<constant>. |
a5222a85 | 880 | |
7a95317d | 881 | =item charnames |
a5222a85 | 882 | |
7a95317d | 883 | This pragma implements the C<\N> string escape. See L<charnames>. |
01020589 | 884 | |
7a95317d | 885 | =item Data::Dumper |
479ba383 | 886 | |
7a95317d GS |
887 | A C<Maxdepth> setting can be specified to avoid venturing |
888 | too deeply into deep data structures. See L<Data::Dumper>. | |
479ba383 | 889 | |
7a95317d GS |
890 | The XSUB implementation of Dump() is now automatically called if the |
891 | C<Useqq> setting is not in use. | |
a5222a85 | 892 | |
7a95317d | 893 | Dumping C<qr//> objects works correctly. |
a5222a85 | 894 | |
7a95317d | 895 | =item DB |
a5222a85 | 896 | |
7a95317d GS |
897 | C<DB> is an experimental module that exposes a clean abstraction |
898 | to Perl's debugging API. | |
a5222a85 | 899 | |
7a95317d | 900 | =item DB_File |
a5222a85 | 901 | |
7a95317d GS |
902 | DB_File can now be built with Berkeley DB versions 1, 2 or 3. |
903 | See C<ext/DB_File/Changes>. | |
a5222a85 | 904 | |
7a95317d | 905 | =item Devel::DProf |
a5222a85 | 906 | |
7a95317d GS |
907 | Devel::DProf, a Perl source code profiler has been added. See |
908 | L<Devel::DProf> and L<dprofpp>. | |
a5222a85 | 909 | |
7a95317d | 910 | =item Devel::Peek |
a5222a85 | 911 | |
7a95317d GS |
912 | The Devel::Peek module provides access to the internal representation |
913 | of Perl variables and data. It is a data debugging tool for the XS programmer. | |
a5222a85 | 914 | |
7a95317d | 915 | =item Dumpvalue |
54195c32 | 916 | |
7a95317d | 917 | The Dumpvalue module provides screen dumps of Perl data. |
67d3893f | 918 | |
7a95317d | 919 | =item DynaLoader |
54195c32 | 920 | |
7a95317d GS |
921 | DynaLoader now supports a dl_unload_file() function on platforms that |
922 | support unloading shared objects using dlclose(). | |
a5222a85 | 923 | |
7a95317d GS |
924 | Perl can also optionally arrange to unload all extension shared objects |
925 | loaded by Perl. To enable this, build Perl with the Configure option | |
926 | C<-Accflags=-DDL_UNLOAD_ALL_AT_EXIT>. (This maybe useful if you are | |
927 | using Apache with mod_perl.) | |
a5222a85 | 928 | |
7a95317d | 929 | =item English |
a5222a85 | 930 | |
7a95317d GS |
931 | $PERL_VERSION now stands for C<$^V> (a string value) rather than for C<$]> |
932 | (a numeric value). | |
a5222a85 | 933 | |
7a95317d | 934 | =item Env |
a5222a85 | 935 | |
7a95317d GS |
936 | Env now supports accessing environment variables like PATH as array |
937 | variables. | |
a5222a85 | 938 | |
7a95317d | 939 | =item Fcntl |
a5222a85 | 940 | |
7a95317d GS |
941 | More Fcntl constants added: F_SETLK64, F_SETLKW64, O_LARGEFILE for |
942 | large file (more than 4GB) access (NOTE: the O_LARGEFILE is | |
943 | automatically added to sysopen() flags if large file support has been | |
944 | configured, as is the default), Free/Net/OpenBSD locking behaviour | |
945 | flags F_FLOCK, F_POSIX, Linux F_SHLCK, and O_ACCMODE: the combined | |
946 | mask of O_RDONLY, O_WRONLY, and O_RDWR. The seek()/sysseek() | |
947 | constants SEEK_SET, SEEK_CUR, and SEEK_END are available via the | |
948 | C<:seek> tag. The chmod()/stat() S_IF* constants and S_IS* functions | |
949 | are available via the C<:mode> tag. | |
a5222a85 | 950 | |
7a95317d | 951 | =item File::Compare |
a5222a85 | 952 | |
7a95317d GS |
953 | A compare_text() function has been added, which allows custom |
954 | comparison functions. See L<File::Compare>. | |
a5222a85 | 955 | |
7a95317d | 956 | =item File::Find |
a5222a85 | 957 | |
7a95317d GS |
958 | File::Find now works correctly when the wanted() function is either |
959 | autoloaded or is a symbolic reference. | |
a5222a85 | 960 | |
7a95317d GS |
961 | A bug that caused File::Find to lose track of the working directory |
962 | when pruning top-level directories has been fixed. | |
a5222a85 | 963 | |
7a95317d GS |
964 | File::Find now also supports several other options to control its |
965 | behavior. It can follow symbolic links if the C<follow> option is | |
966 | specified. Enabling the C<no_chdir> option will make File::Find skip | |
967 | changing the current directory when walking directories. The C<untaint> | |
968 | flag can be useful when running with taint checks enabled. | |
a5222a85 | 969 | |
7a95317d | 970 | See L<File::Find>. |
a5222a85 | 971 | |
7a95317d | 972 | =item File::Glob |
a5222a85 | 973 | |
7a95317d GS |
974 | This extension implements BSD-style file globbing. By default, |
975 | it will also be used for the internal implementation of the glob() | |
976 | operator. See L<File::Glob>. | |
a5222a85 | 977 | |
7a95317d | 978 | =item File::Spec |
a5222a85 | 979 | |
7a95317d GS |
980 | New methods have been added to the File::Spec module: devnull() returns |
981 | the name of the null device (/dev/null on Unix) and tmpdir() the name of | |
982 | the temp directory (normally /tmp on Unix). There are now also methods | |
983 | to convert between absolute and relative filenames: abs2rel() and | |
984 | rel2abs(). For compatibility with operating systems that specify volume | |
985 | names in file paths, the splitpath(), splitdir(), and catdir() methods | |
986 | have been added. | |
a5222a85 | 987 | |
7a95317d | 988 | =item File::Spec::Functions |
a5222a85 | 989 | |
7a95317d GS |
990 | The new File::Spec::Functions modules provides a function interface |
991 | to the File::Spec module. Allows shorthand | |
a5222a85 | 992 | |
7a95317d | 993 | $fullname = catfile($dir1, $dir2, $file); |
a5222a85 | 994 | |
7a95317d | 995 | instead of |
a398b1cd | 996 | |
7a95317d | 997 | $fullname = File::Spec->catfile($dir1, $dir2, $file); |
a398b1cd | 998 | |
7a95317d | 999 | =item Getopt::Long |
a398b1cd | 1000 | |
7a95317d GS |
1001 | Getopt::Long licensing has changed to allow the Perl Artistic License |
1002 | as well as the GPL. It used to be GPL only, which got in the way of | |
1003 | non-GPL applications that wanted to use Getopt::Long. | |
a398b1cd | 1004 | |
7a95317d GS |
1005 | Getopt::Long encourages the use of Pod::Usage to produce help |
1006 | messages. For example: | |
a5222a85 | 1007 | |
7a95317d GS |
1008 | use Getopt::Long; |
1009 | use Pod::Usage; | |
1010 | my $man = 0; | |
1011 | my $help = 0; | |
1012 | GetOptions('help|?' => \$help, man => \$man) or pod2usage(2); | |
1013 | pod2usage(1) if $help; | |
1014 | pod2usage(-exitstatus => 0, -verbose => 2) if $man; | |
1015 | ||
1016 | __END__ | |
a5222a85 | 1017 | |
7a95317d | 1018 | =head1 NAME |
a5222a85 | 1019 | |
fe854a6f | 1020 | sample - Using Getopt::Long and Pod::Usage |
a5222a85 | 1021 | |
7a95317d | 1022 | =head1 SYNOPSIS |
a5222a85 | 1023 | |
7a95317d | 1024 | sample [options] [file ...] |
a5222a85 | 1025 | |
7a95317d GS |
1026 | Options: |
1027 | -help brief help message | |
1028 | -man full documentation | |
a5222a85 | 1029 | |
7a95317d | 1030 | =head1 OPTIONS |
a5222a85 | 1031 | |
7a95317d | 1032 | =over 8 |
ba8251e8 | 1033 | |
7a95317d | 1034 | =item B<-help> |
5fdc711f | 1035 | |
7a95317d | 1036 | Print a brief help message and exits. |
5fdc711f | 1037 | |
7a95317d | 1038 | =item B<-man> |
6c67e1bb | 1039 | |
7a95317d | 1040 | Prints the manual page and exits. |
5fdc711f | 1041 | |
7a95317d | 1042 | =back |
ee3907e2 | 1043 | |
7a95317d | 1044 | =head1 DESCRIPTION |
ee3907e2 | 1045 | |
4375e838 | 1046 | B<This program> will read the given input file(s) and do something |
7a95317d | 1047 | useful with the contents thereof. |
6c67e1bb | 1048 | |
7a95317d | 1049 | =cut |
5fdc711f | 1050 | |
7a95317d | 1051 | See L<Pod::Usage> for details. |
6c67e1bb | 1052 | |
7a95317d GS |
1053 | A bug that prevented the non-option call-back <> from being |
1054 | specified as the first argument has been fixed. | |
00ad96e1 | 1055 | |
7a95317d GS |
1056 | To specify the characters < and > as option starters, use ><. Note, |
1057 | however, that changing option starters is strongly deprecated. | |
00ad96e1 | 1058 | |
7a95317d | 1059 | =item IO |
27806c82 | 1060 | |
7a95317d GS |
1061 | write() and syswrite() will now accept a single-argument |
1062 | form of the call, for consistency with Perl's syswrite(). | |
27806c82 | 1063 | |
7a95317d GS |
1064 | You can now create a TCP-based IO::Socket::INET without forcing |
1065 | a connect attempt. This allows you to configure its options | |
1066 | (like making it non-blocking) and then call connect() manually. | |
5fdc711f | 1067 | |
7a95317d GS |
1068 | A bug that prevented the IO::Socket::protocol() accessor |
1069 | from ever returning the correct value has been corrected. | |
a5222a85 | 1070 | |
7a95317d GS |
1071 | IO::Socket::connect now uses non-blocking IO instead of alarm() |
1072 | to do connect timeouts. | |
d524f05e | 1073 | |
7a95317d GS |
1074 | IO::Socket::accept now uses select() instead of alarm() for doing |
1075 | timeouts. | |
d524f05e | 1076 | |
7a95317d | 1077 | IO::Socket::INET->new now sets $! correctly on failure. $@ is |
4375e838 | 1078 | still set for backwards compatibility. |
d524f05e | 1079 | |
7a95317d | 1080 | =item JPL |
d524f05e | 1081 | |
7a95317d GS |
1082 | Java Perl Lingo is now distributed with Perl. See jpl/README |
1083 | for more information. | |
d524f05e | 1084 | |
7a95317d | 1085 | =item lib |
d524f05e | 1086 | |
7a95317d GS |
1087 | C<use lib> now weeds out any trailing duplicate entries. |
1088 | C<no lib> removes all named entries. | |
d524f05e | 1089 | |
7a95317d | 1090 | =item Math::BigInt |
d524f05e | 1091 | |
7a95317d GS |
1092 | The bitwise operations C<<< << >>>, C<<< >> >>>, C<&>, C<|>, |
1093 | and C<~> are now supported on bigints. | |
d524f05e | 1094 | |
7a95317d | 1095 | =item Math::Complex |
a5222a85 | 1096 | |
7a95317d GS |
1097 | The accessor methods Re, Im, arg, abs, rho, and theta can now also |
1098 | act as mutators (accessor $z->Re(), mutator $z->Re(3)). | |
063663a9 | 1099 | |
7a95317d GS |
1100 | The class method C<display_format> and the corresponding object method |
1101 | C<display_format>, in addition to accepting just one argument, now can | |
1102 | also accept a parameter hash. Recognized keys of a parameter hash are | |
1103 | C<"style">, which corresponds to the old one parameter case, and two | |
1104 | new parameters: C<"format">, which is a printf()-style format string | |
1105 | (defaults usually to C<"%.15g">, you can revert to the default by | |
1106 | setting the format string to C<undef>) used for both parts of a | |
1107 | complex number, and C<"polar_pretty_print"> (defaults to true), | |
1108 | which controls whether an attempt is made to try to recognize small | |
1109 | multiples and rationals of pi (2pi, pi/2) at the argument (angle) of a | |
1110 | polar complex number. | |
063663a9 | 1111 | |
7a95317d GS |
1112 | The potentially disruptive change is that in list context both methods |
1113 | now I<return the parameter hash>, instead of only the value of the | |
1114 | C<"style"> parameter. | |
063663a9 | 1115 | |
7a95317d | 1116 | =item Math::Trig |
a5222a85 | 1117 | |
7a95317d GS |
1118 | A little bit of radial trigonometry (cylindrical and spherical), |
1119 | radial coordinate conversions, and the great circle distance were added. | |
c93fa817 | 1120 | |
7a95317d | 1121 | =item Pod::Parser, Pod::InputObjects |
c93fa817 | 1122 | |
7a95317d GS |
1123 | Pod::Parser is a base class for parsing and selecting sections of |
1124 | pod documentation from an input stream. This module takes care of | |
1125 | identifying pod paragraphs and commands in the input and hands off the | |
1126 | parsed paragraphs and commands to user-defined methods which are free | |
1127 | to interpret or translate them as they see fit. | |
c93fa817 | 1128 | |
7a95317d GS |
1129 | Pod::InputObjects defines some input objects needed by Pod::Parser, and |
1130 | for advanced users of Pod::Parser that need more about a command besides | |
1131 | its name and text. | |
c93fa817 | 1132 | |
7a95317d GS |
1133 | As of release 5.6.0 of Perl, Pod::Parser is now the officially sanctioned |
1134 | "base parser code" recommended for use by all pod2xxx translators. | |
1135 | Pod::Text (pod2text) and Pod::Man (pod2man) have already been converted | |
1136 | to use Pod::Parser and efforts to convert Pod::HTML (pod2html) are already | |
1137 | underway. For any questions or comments about pod parsing and translating | |
1138 | issues and utilities, please use the pod-people@perl.org mailing list. | |
c93fa817 | 1139 | |
7a95317d | 1140 | For further information, please see L<Pod::Parser> and L<Pod::InputObjects>. |
c93fa817 | 1141 | |
7a95317d | 1142 | =item Pod::Checker, podchecker |
c93fa817 | 1143 | |
7a95317d GS |
1144 | This utility checks pod files for correct syntax, according to |
1145 | L<perlpod>. Obvious errors are flagged as such, while warnings are | |
1146 | printed for mistakes that can be handled gracefully. The checklist is | |
1147 | not complete yet. See L<Pod::Checker>. | |
c93fa817 | 1148 | |
7a95317d | 1149 | =item Pod::ParseUtils, Pod::Find |
c93fa817 | 1150 | |
7a95317d GS |
1151 | These modules provide a set of gizmos that are useful mainly for pod |
1152 | translators. L<Pod::Find|Pod::Find> traverses directory structures and | |
1153 | returns found pod files, along with their canonical names (like | |
1154 | C<File::Spec::Unix>). L<Pod::ParseUtils|Pod::ParseUtils> contains | |
1155 | B<Pod::List> (useful for storing pod list information), B<Pod::Hyperlink> | |
1156 | (for parsing the contents of C<LE<lt>E<gt>> sequences) and B<Pod::Cache> | |
1157 | (for caching information about pod files, e.g., link nodes). | |
a5222a85 | 1158 | |
7a95317d | 1159 | =item Pod::Select, podselect |
a5222a85 | 1160 | |
7a95317d GS |
1161 | Pod::Select is a subclass of Pod::Parser which provides a function |
1162 | named "podselect()" to filter out user-specified sections of raw pod | |
1163 | documentation from an input stream. podselect is a script that provides | |
1164 | access to Pod::Select from other scripts to be used as a filter. | |
1165 | See L<Pod::Select>. | |
a5222a85 | 1166 | |
7a95317d | 1167 | =item Pod::Usage, pod2usage |
a5222a85 | 1168 | |
7a95317d GS |
1169 | Pod::Usage provides the function "pod2usage()" to print usage messages for |
1170 | a Perl script based on its embedded pod documentation. The pod2usage() | |
1171 | function is generally useful to all script authors since it lets them | |
1172 | write and maintain a single source (the pods) for documentation, thus | |
1173 | removing the need to create and maintain redundant usage message text | |
1174 | consisting of information already in the pods. | |
a5222a85 | 1175 | |
7a95317d GS |
1176 | There is also a pod2usage script which can be used from other kinds of |
1177 | scripts to print usage messages from pods (even for non-Perl scripts | |
1178 | with pods embedded in comments). | |
a5222a85 | 1179 | |
7a95317d | 1180 | For details and examples, please see L<Pod::Usage>. |
a5222a85 | 1181 | |
7a95317d | 1182 | =item Pod::Text and Pod::Man |
a5222a85 | 1183 | |
7a95317d GS |
1184 | Pod::Text has been rewritten to use Pod::Parser. While pod2text() is |
1185 | still available for backwards compatibility, the module now has a new | |
1186 | preferred interface. See L<Pod::Text> for the details. The new Pod::Text | |
1187 | module is easily subclassed for tweaks to the output, and two such | |
1188 | subclasses (Pod::Text::Termcap for man-page-style bold and underlining | |
1189 | using termcap information, and Pod::Text::Color for markup with ANSI color | |
1190 | sequences) are now standard. | |
a5222a85 | 1191 | |
7a95317d GS |
1192 | pod2man has been turned into a module, Pod::Man, which also uses |
1193 | Pod::Parser. In the process, several outstanding bugs related to quotes | |
1194 | in section headers, quoting of code escapes, and nested lists have been | |
1195 | fixed. pod2man is now a wrapper script around this module. | |
42b8b86c | 1196 | |
7a95317d | 1197 | =item SDBM_File |
a5222a85 | 1198 | |
7a95317d GS |
1199 | An EXISTS method has been added to this module (and sdbm_exists() has |
1200 | been added to the underlying sdbm library), so one can now call exists | |
1201 | on an SDBM_File tied hash and get the correct result, rather than a | |
1202 | runtime error. | |
883d36a6 | 1203 | |
7a95317d GS |
1204 | A bug that may have caused data loss when more than one disk block |
1205 | happens to be read from the database in a single FETCH() has been | |
1206 | fixed. | |
c39cd008 | 1207 | |
7a95317d | 1208 | =item Sys::Syslog |
16070b82 | 1209 | |
7a95317d GS |
1210 | Sys::Syslog now uses XSUBs to access facilities from syslog.h so it |
1211 | no longer requires syslog.ph to exist. | |
6c67e1bb | 1212 | |
7a95317d | 1213 | =item Sys::Hostname |
6c67e1bb | 1214 | |
7a95317d GS |
1215 | Sys::Hostname now uses XSUBs to call the C library's gethostname() or |
1216 | uname() if they exist. | |
09bef843 | 1217 | |
7a95317d | 1218 | =item Term::ANSIColor |
09bef843 | 1219 | |
7a95317d GS |
1220 | Term::ANSIColor is a very simple module to provide easy and readable |
1221 | access to the ANSI color and highlighting escape sequences, supported by | |
1222 | most ANSI terminal emulators. It is now included standard. | |
2675e62c | 1223 | |
7a95317d | 1224 | =item Time::Local |
2675e62c | 1225 | |
7a95317d GS |
1226 | The timelocal() and timegm() functions used to silently return bogus |
1227 | results when the date fell outside the machine's integer range. They | |
1228 | now consistently croak() if the date falls in an unsupported range. | |
2675e62c | 1229 | |
7a95317d | 1230 | =item Win32 |
2675e62c | 1231 | |
7a95317d GS |
1232 | The error return value in list context has been changed for all functions |
1233 | that return a list of values. Previously these functions returned a list | |
1234 | with a single element C<undef> if an error occurred. Now these functions | |
1235 | return the empty list in these situations. This applies to the following | |
1236 | functions: | |
6c67e1bb | 1237 | |
7a95317d GS |
1238 | Win32::FsType |
1239 | Win32::GetOSVersion | |
14218588 | 1240 | |
7a95317d GS |
1241 | The remaining functions are unchanged and continue to return C<undef> on |
1242 | error even in list context. | |
6c67e1bb | 1243 | |
7a95317d GS |
1244 | The Win32::SetLastError(ERROR) function has been added as a complement |
1245 | to the Win32::GetLastError() function. | |
6c67e1bb | 1246 | |
7a95317d GS |
1247 | The new Win32::GetFullPathName(FILENAME) returns the full absolute |
1248 | pathname for FILENAME in scalar context. In list context it returns | |
1249 | a two-element list containing the fully qualified directory name and | |
1250 | the filename. See L<Win32>. | |
6c67e1bb | 1251 | |
7a95317d | 1252 | =item XSLoader |
6c67e1bb | 1253 | |
7a95317d GS |
1254 | The XSLoader extension is a simpler alternative to DynaLoader. |
1255 | See L<XSLoader>. | |
6c67e1bb | 1256 | |
7a95317d | 1257 | =item DBM Filters |
6c67e1bb | 1258 | |
7a95317d GS |
1259 | A new feature called "DBM Filters" has been added to all the |
1260 | DBM modules--DB_File, GDBM_File, NDBM_File, ODBM_File, and SDBM_File. | |
1261 | DBM Filters add four new methods to each DBM module: | |
6c67e1bb | 1262 | |
7a95317d GS |
1263 | filter_store_key |
1264 | filter_store_value | |
1265 | filter_fetch_key | |
1266 | filter_fetch_value | |
6c67e1bb | 1267 | |
7a95317d GS |
1268 | These can be used to filter key-value pairs before the pairs are |
1269 | written to the database or just after they are read from the database. | |
1270 | See L<perldbmfilter> for further information. | |
09bef843 | 1271 | |
7a95317d | 1272 | =back |
09bef843 | 1273 | |
7a95317d | 1274 | =head2 Pragmata |
6c67e1bb | 1275 | |
7a95317d GS |
1276 | C<use attrs> is now obsolete, and is only provided for |
1277 | backward-compatibility. It's been replaced by the C<sub : attributes> | |
1278 | syntax. See L<perlsub/"Subroutine Attributes"> and L<attributes>. | |
6c67e1bb | 1279 | |
7a95317d GS |
1280 | Lexical warnings pragma, C<use warnings;>, to control optional warnings. |
1281 | See L<perllexwarn>. | |
6c67e1bb | 1282 | |
7a95317d GS |
1283 | C<use filetest> to control the behaviour of filetests (C<-r> C<-w> |
1284 | ...). Currently only one subpragma implemented, "use filetest | |
1285 | 'access';", that uses access(2) or equivalent to check permissions | |
1286 | instead of using stat(2) as usual. This matters in filesystems | |
1287 | where there are ACLs (access control lists): the stat(2) might lie, | |
1288 | but access(2) knows better. | |
6c67e1bb | 1289 | |
7a95317d GS |
1290 | The C<open> pragma can be used to specify default disciplines for |
1291 | handle constructors (e.g. open()) and for qx//. The two | |
1292 | pseudo-disciplines C<:raw> and C<:crlf> are currently supported on | |
1293 | DOS-derivative platforms (i.e. where binmode is not a no-op). | |
1294 | See also L</"binmode() can be used to set :crlf and :raw modes">. | |
afebc493 | 1295 | |
7a95317d | 1296 | =head1 Utility Changes |
afebc493 | 1297 | |
7a95317d | 1298 | =head2 dprofpp |
e02fdbd2 | 1299 | |
7a95317d GS |
1300 | C<dprofpp> is used to display profile data generated using C<Devel::DProf>. |
1301 | See L<dprofpp>. | |
ba8251e8 | 1302 | |
7a95317d | 1303 | =head2 find2perl |
3e8c4fa0 | 1304 | |
7a95317d GS |
1305 | The C<find2perl> utility now uses the enhanced features of the File::Find |
1306 | module. The -depth and -follow options are supported. Pod documentation | |
1307 | is also included in the script. | |
b7d8191e | 1308 | |
7a95317d | 1309 | =head2 h2xs |
09bef843 | 1310 | |
7a95317d GS |
1311 | The C<h2xs> tool can now work in conjunction with C<C::Scan> (available |
1312 | from CPAN) to automatically parse real-life header files. The C<-M>, | |
1313 | C<-a>, C<-k>, and C<-o> options are new. | |
09bef843 | 1314 | |
7a95317d | 1315 | =head2 perlcc |
a5222a85 | 1316 | |
7a95317d GS |
1317 | C<perlcc> now supports the C and Bytecode backends. By default, |
1318 | it generates output from the simple C backend rather than the | |
1319 | optimized C backend. | |
501fbaef | 1320 | |
7a95317d | 1321 | Support for non-Unix platforms has been improved. |
a5222a85 | 1322 | |
7a95317d | 1323 | =head2 perldoc |
f29c64d6 | 1324 | |
7a95317d GS |
1325 | C<perldoc> has been reworked to avoid possible security holes. |
1326 | It will not by default let itself be run as the superuser, but you | |
1327 | may still use the B<-U> switch to try to make it drop privileges | |
1328 | first. | |
f29c64d6 | 1329 | |
7a95317d | 1330 | =head2 The Perl Debugger |
a5222a85 | 1331 | |
7a95317d GS |
1332 | Many bug fixes and enhancements were added to F<perl5db.pl>, the |
1333 | Perl debugger. The help documentation was rearranged. New commands | |
1334 | include C<< < ? >>, C<< > ? >>, and C<< { ? >> to list out current | |
1335 | actions, C<man I<docpage>> to run your doc viewer on some perl | |
1336 | docset, and support for quoted options. The help information was | |
1337 | rearranged, and should be viewable once again if you're using B<less> | |
1338 | as your pager. A serious security hole was plugged--you should | |
1339 | immediately remove all older versions of the Perl debugger as | |
1340 | installed in previous releases, all the way back to perl3, from | |
1341 | your system to avoid being bitten by this. | |
83763826 | 1342 | |
7a95317d | 1343 | =head1 Improved Documentation |
83763826 | 1344 | |
7a95317d GS |
1345 | Many of the platform-specific README files are now part of the perl |
1346 | installation. See L<perl> for the complete list. | |
a5222a85 | 1347 | |
7a95317d | 1348 | =over 4 |
a5222a85 | 1349 | |
7a95317d | 1350 | =item perlapi.pod |
a5222a85 | 1351 | |
7a95317d | 1352 | The official list of public Perl API functions. |
a5222a85 | 1353 | |
7a95317d | 1354 | =item perlboot.pod |
a5222a85 | 1355 | |
7a95317d | 1356 | A tutorial for beginners on object-oriented Perl. |
0f1923bd | 1357 | |
7a95317d | 1358 | =item perlcompile.pod |
a5222a85 | 1359 | |
7a95317d | 1360 | An introduction to using the Perl Compiler suite. |
a5222a85 | 1361 | |
7a95317d | 1362 | =item perldbmfilter.pod |
a5222a85 | 1363 | |
7a95317d | 1364 | A howto document on using the DBM filter facility. |
a5222a85 | 1365 | |
7a95317d | 1366 | =item perldebug.pod |
a5222a85 | 1367 | |
7a95317d GS |
1368 | All material unrelated to running the Perl debugger, plus all |
1369 | low-level guts-like details that risked crushing the casual user | |
1370 | of the debugger, have been relocated from the old manpage to the | |
1371 | next entry below. | |
f29c64d6 | 1372 | |
7a95317d | 1373 | =item perldebguts.pod |
f29c64d6 | 1374 | |
7a95317d GS |
1375 | This new manpage contains excessively low-level material not related |
1376 | to the Perl debugger, but slightly related to debugging Perl itself. | |
1377 | It also contains some arcane internal details of how the debugging | |
1378 | process works that may only be of interest to developers of Perl | |
1379 | debuggers. | |
b7d8191e | 1380 | |
7a95317d | 1381 | =item perlfork.pod |
b7d8191e | 1382 | |
7a95317d | 1383 | Notes on the fork() emulation currently available for the Windows platform. |
23d2500b | 1384 | |
7a95317d | 1385 | =item perlfilter.pod |
23d2500b | 1386 | |
7a95317d | 1387 | An introduction to writing Perl source filters. |
23d2500b | 1388 | |
7a95317d | 1389 | =item perlhack.pod |
b7d8191e | 1390 | |
7a95317d | 1391 | Some guidelines for hacking the Perl source code. |
54e82ce5 | 1392 | |
7a95317d | 1393 | =item perlintern.pod |
155776c0 | 1394 | |
7a95317d GS |
1395 | A list of internal functions in the Perl source code. |
1396 | (List is currently empty.) | |
155776c0 | 1397 | |
7a95317d | 1398 | =item perllexwarn.pod |
155776c0 | 1399 | |
7a95317d GS |
1400 | Introduction and reference information about lexically scoped |
1401 | warning categories. | |
155776c0 | 1402 | |
7a95317d | 1403 | =item perlnumber.pod |
b7d8191e | 1404 | |
7a95317d | 1405 | Detailed information about numbers as they are represented in Perl. |
54e82ce5 | 1406 | |
7a95317d | 1407 | =item perlopentut.pod |
54e82ce5 | 1408 | |
7a95317d | 1409 | A tutorial on using open() effectively. |
54e82ce5 | 1410 | |
7a95317d | 1411 | =item perlreftut.pod |
54e82ce5 | 1412 | |
7a95317d | 1413 | A tutorial that introduces the essentials of references. |
54e82ce5 | 1414 | |
7a95317d | 1415 | =item perltootc.pod |
a5222a85 | 1416 | |
7a95317d | 1417 | A tutorial on managing class data for object modules. |
f505c983 | 1418 | |
7a95317d | 1419 | =item perltodo.pod |
f505c983 | 1420 | |
7a95317d GS |
1421 | Discussion of the most often wanted features that may someday be |
1422 | supported in Perl. | |
44dcb63b | 1423 | |
7a95317d | 1424 | =item perlunicode.pod |
44dcb63b | 1425 | |
7a95317d | 1426 | An introduction to Unicode support features in Perl. |
2675e62c | 1427 | |
7a95317d | 1428 | =back |
2675e62c | 1429 | |
7a95317d | 1430 | =head1 Performance enhancements |
b7d8191e | 1431 | |
7a95317d | 1432 | =head2 Simple sort() using { $a <=> $b } and the like are optimized |
b7d8191e | 1433 | |
7a95317d GS |
1434 | Many common sort() operations using a simple inlined block are now |
1435 | optimized for faster performance. | |
a5222a85 | 1436 | |
7a95317d | 1437 | =head2 Optimized assignments to lexical variables |
a5222a85 | 1438 | |
7a95317d GS |
1439 | Certain operations in the RHS of assignment statements have been |
1440 | optimized to directly set the lexical variable on the LHS, | |
1441 | eliminating redundant copying overheads. | |
a5222a85 | 1442 | |
7a95317d | 1443 | =head2 Faster subroutine calls |
a5222a85 | 1444 | |
7a95317d GS |
1445 | Minor changes in how subroutine calls are handled internally |
1446 | provide marginal improvements in performance. | |
a5222a85 | 1447 | |
8593bda5 | 1448 | =head2 delete(), each(), values() and hash iteration are faster |
81793b90 | 1449 | |
7a95317d GS |
1450 | The hash values returned by delete(), each(), values() and hashes in a |
1451 | list context are the actual values in the hash, instead of copies. | |
1452 | This results in significantly better performance, because it eliminates | |
1453 | needless copying in most situations. | |
81793b90 | 1454 | |
7a95317d | 1455 | =head1 Installation and Configuration Improvements |
becf2bd3 | 1456 | |
7a95317d | 1457 | =head2 -Dusethreads means something different |
becf2bd3 | 1458 | |
7a95317d GS |
1459 | The -Dusethreads flag now enables the experimental interpreter-based thread |
1460 | support by default. To get the flavor of experimental threads that was in | |
1461 | 5.005 instead, you need to run Configure with "-Dusethreads -Duse5005threads". | |
f505c983 | 1462 | |
7a95317d GS |
1463 | As of v5.6.0, interpreter-threads support is still lacking a way to |
1464 | create new threads from Perl (i.e., C<use Thread;> will not work with | |
1465 | interpreter threads). C<use Thread;> continues to be available when you | |
1466 | specify the -Duse5005threads option to Configure, bugs and all. | |
f505c983 | 1467 | |
7a95317d GS |
1468 | NOTE: Support for threads continues to be an experimental feature. |
1469 | Interfaces and implementation are subject to sudden and drastic changes. | |
f505c983 | 1470 | |
7a95317d | 1471 | =head2 New Configure flags |
f505c983 | 1472 | |
7a95317d GS |
1473 | The following new flags may be enabled on the Configure command line |
1474 | by running Configure with C<-Dflag>. | |
f505c983 | 1475 | |
7a95317d GS |
1476 | usemultiplicity |
1477 | usethreads useithreads (new interpreter threads: no Perl API yet) | |
1478 | usethreads use5005threads (threads as they were in 5.005) | |
f505c983 | 1479 | |
7a95317d GS |
1480 | use64bitint (equal to now deprecated 'use64bits') |
1481 | use64bitall | |
f505c983 | 1482 | |
7a95317d GS |
1483 | uselongdouble |
1484 | usemorebits | |
1485 | uselargefiles | |
1486 | usesocks (only SOCKS v5 supported) | |
a5222a85 | 1487 | |
7a95317d | 1488 | =head2 Threadedness and 64-bitness now more daring |
c6edd1b7 | 1489 | |
7a95317d GS |
1490 | The Configure options enabling the use of threads and the use of |
1491 | 64-bitness are now more daring in the sense that they no more have an | |
1492 | explicit list of operating systems of known threads/64-bit | |
1493 | capabilities. In other words: if your operating system has the | |
1494 | necessary APIs and datatypes, you should be able just to go ahead and | |
1495 | use them, for threads by Configure -Dusethreads, and for 64 bits | |
1496 | either explicitly by Configure -Duse64bitint or implicitly if your | |
5e21a9a9 | 1497 | system has 64-bit wide datatypes. See also L</"64-bit support">. |
c6edd1b7 | 1498 | |
7a95317d | 1499 | =head2 Long Doubles |
c6edd1b7 | 1500 | |
7a95317d GS |
1501 | Some platforms have "long doubles", floating point numbers of even |
1502 | larger range than ordinary "doubles". To enable using long doubles for | |
1503 | Perl's scalars, use -Duselongdouble. | |
c6edd1b7 | 1504 | |
7a95317d | 1505 | =head2 -Dusemorebits |
c6edd1b7 | 1506 | |
7a95317d | 1507 | You can enable both -Duse64bitint and -Duselongdouble with -Dusemorebits. |
5e21a9a9 | 1508 | See also L</"64-bit support">. |
c6edd1b7 | 1509 | |
7a95317d | 1510 | =head2 -Duselargefiles |
c6edd1b7 | 1511 | |
7a95317d GS |
1512 | Some platforms support system APIs that are capable of handling large files |
1513 | (typically, files larger than two gigabytes). Perl will try to use these | |
1514 | APIs if you ask for -Duselargefiles. | |
c6edd1b7 | 1515 | |
5e21a9a9 | 1516 | See L</"Large file support"> for more information. |
c6edd1b7 | 1517 | |
7a95317d | 1518 | =head2 installusrbinperl |
c6edd1b7 | 1519 | |
7a95317d GS |
1520 | You can use "Configure -Uinstallusrbinperl" which causes installperl |
1521 | to skip installing perl also as /usr/bin/perl. This is useful if you | |
1522 | prefer not to modify /usr/bin for some reason or another but harmful | |
1523 | because many scripts assume to find Perl in /usr/bin/perl. | |
c6edd1b7 | 1524 | |
7a95317d | 1525 | =head2 SOCKS support |
c6edd1b7 | 1526 | |
7a95317d GS |
1527 | You can use "Configure -Dusesocks" which causes Perl to probe |
1528 | for the SOCKS proxy protocol library (v5, not v4). For more information | |
1529 | on SOCKS, see: | |
c6edd1b7 | 1530 | |
7a95317d | 1531 | http://www.socks.nec.com/ |
c6edd1b7 | 1532 | |
7a95317d | 1533 | =head2 C<-A> flag |
c6edd1b7 | 1534 | |
7a95317d GS |
1535 | You can "post-edit" the Configure variables using the Configure C<-A> |
1536 | switch. The editing happens immediately after the platform specific | |
1537 | hints files have been processed but before the actual configuration | |
1538 | process starts. Run C<Configure -h> to find out the full C<-A> syntax. | |
c6edd1b7 | 1539 | |
7a95317d | 1540 | =head2 Enhanced Installation Directories |
c6edd1b7 | 1541 | |
7a95317d GS |
1542 | The installation structure has been enriched to improve the support |
1543 | for maintaining multiple versions of perl, to provide locations for | |
1544 | vendor-supplied modules, scripts, and manpages, and to ease maintenance | |
1545 | of locally-added modules, scripts, and manpages. See the section on | |
1546 | Installation Directories in the INSTALL file for complete details. | |
1547 | For most users building and installing from source, the defaults should | |
1548 | be fine. | |
c6edd1b7 | 1549 | |
7a95317d GS |
1550 | If you previously used C<Configure -Dsitelib> or C<-Dsitearch> to set |
1551 | special values for library directories, you might wish to consider using | |
1552 | the new C<-Dsiteprefix> setting instead. Also, if you wish to re-use a | |
1553 | config.sh file from an earlier version of perl, you should be sure to | |
1554 | check that Configure makes sensible choices for the new directories. | |
1555 | See INSTALL for complete details. | |
c6edd1b7 | 1556 | |
7a95317d | 1557 | =head1 Platform specific changes |
c6edd1b7 | 1558 | |
7a95317d | 1559 | =head2 Supported platforms |
c6edd1b7 | 1560 | |
7a95317d | 1561 | =over 4 |
a5222a85 | 1562 | |
7a95317d | 1563 | =item * |
a5222a85 | 1564 | |
7a95317d GS |
1565 | The Mach CThreads (NEXTSTEP, OPENSTEP) are now supported by the Thread |
1566 | extension. | |
36f31b50 | 1567 | |
7a95317d | 1568 | =item * |
36f31b50 | 1569 | |
7a95317d | 1570 | GNU/Hurd is now supported. |
a5222a85 | 1571 | |
7a95317d | 1572 | =item * |
a5222a85 | 1573 | |
7a95317d | 1574 | Rhapsody/Darwin is now supported. |
883d36a6 | 1575 | |
7a95317d | 1576 | =item * |
883d36a6 | 1577 | |
106325ad | 1578 | EPOC is now supported (on Psion 5). |
e16b8f49 | 1579 | |
7a95317d | 1580 | =item * |
e16b8f49 | 1581 | |
7a95317d | 1582 | The cygwin port (formerly cygwin32) has been greatly improved. |
7711098a | 1583 | |
7a95317d | 1584 | =back |
b7d8191e | 1585 | |
7a95317d | 1586 | =head2 DOS |
16357284 | 1587 | |
7a95317d | 1588 | =over 4 |
16357284 | 1589 | |
7a95317d | 1590 | =item * |
b7d8191e | 1591 | |
7a95317d | 1592 | Perl now works with djgpp 2.02 (and 2.03 alpha). |
b7d8191e | 1593 | |
7a95317d | 1594 | =item * |
d4629d6a | 1595 | |
7a95317d | 1596 | Environment variable names are not converted to uppercase any more. |
d4629d6a | 1597 | |
7a95317d | 1598 | =item * |
d4629d6a | 1599 | |
7a95317d | 1600 | Incorrect exit codes from backticks have been fixed. |
d4629d6a | 1601 | |
7a95317d | 1602 | =item * |
d4629d6a | 1603 | |
7a95317d | 1604 | This port continues to use its own builtin globbing (not File::Glob). |
d4629d6a | 1605 | |
7a95317d | 1606 | =back |
d4629d6a | 1607 | |
7a95317d | 1608 | =head2 OS390 (OpenEdition MVS) |
d4629d6a | 1609 | |
7a95317d GS |
1610 | Support for this EBCDIC platform has not been renewed in this release. |
1611 | There are difficulties in reconciling Perl's standardization on UTF-8 | |
1612 | as its internal representation for characters with the EBCDIC character | |
1613 | set, because the two are incompatible. | |
d4629d6a | 1614 | |
7a95317d GS |
1615 | It is unclear whether future versions will renew support for this |
1616 | platform, but the possibility exists. | |
d4629d6a | 1617 | |
7a95317d | 1618 | =head2 VMS |
d4629d6a | 1619 | |
7a95317d | 1620 | Numerous revisions and extensions to configuration, build, testing, and |
4375e838 | 1621 | installation process to accommodate core changes and VMS-specific options. |
d4629d6a | 1622 | |
7a95317d GS |
1623 | Expand %ENV-handling code to allow runtime mapping to logical names, |
1624 | CLI symbols, and CRTL environ array. | |
d4629d6a | 1625 | |
7a95317d GS |
1626 | Extension of subprocess invocation code to accept filespecs as command |
1627 | "verbs". | |
a5222a85 | 1628 | |
7a95317d GS |
1629 | Add to Perl command line processing the ability to use default file types and |
1630 | to recognize Unix-style C<2E<gt>&1>. | |
a5222a85 | 1631 | |
7a95317d | 1632 | Expansion of File::Spec::VMS routines, and integration into ExtUtils::MM_VMS. |
a5222a85 | 1633 | |
7a95317d GS |
1634 | Extension of ExtUtils::MM_VMS to handle complex extensions more flexibly. |
1635 | ||
1636 | Barewords at start of Unix-syntax paths may be treated as text rather than | |
1637 | only as logical names. | |
1638 | ||
1639 | Optional secure translation of several logical names used internally by Perl. | |
1640 | ||
1641 | Miscellaneous bugfixing and porting of new core code to VMS. | |
e3e5e1ea | 1642 | |
7a95317d GS |
1643 | Thanks are gladly extended to the many people who have contributed VMS |
1644 | patches, testing, and ideas. | |
a5222a85 | 1645 | |
7a95317d | 1646 | =head2 Win32 |
f4b9d880 | 1647 | |
7a95317d GS |
1648 | Perl can now emulate fork() internally, using multiple interpreters running |
1649 | in different concurrent threads. This support must be enabled at build | |
1650 | time. See L<perlfork> for detailed information. | |
f4b9d880 | 1651 | |
7a95317d GS |
1652 | When given a pathname that consists only of a drivename, such as C<A:>, |
1653 | opendir() and stat() now use the current working directory for the drive | |
1654 | rather than the drive root. | |
a5222a85 | 1655 | |
7a95317d GS |
1656 | The builtin XSUB functions in the Win32:: namespace are documented. See |
1657 | L<Win32>. | |
8ce86de8 | 1658 | |
7a95317d | 1659 | $^X now contains the full path name of the running executable. |
8ce86de8 | 1660 | |
7a95317d GS |
1661 | A Win32::GetLongPathName() function is provided to complement |
1662 | Win32::GetFullPathName() and Win32::GetShortPathName(). See L<Win32>. | |
f91101c9 | 1663 | |
7a95317d | 1664 | POSIX::uname() is supported. |
f91101c9 | 1665 | |
7a95317d GS |
1666 | system(1,...) now returns true process IDs rather than process |
1667 | handles. kill() accepts any real process id, rather than strictly | |
1668 | return values from system(1,...). | |
e3e5e1ea | 1669 | |
7a95317d GS |
1670 | For better compatibility with Unix, C<kill(0, $pid)> can now be used to |
1671 | test whether a process exists. | |
e3e5e1ea | 1672 | |
7a95317d | 1673 | The C<Shell> module is supported. |
06ef4121 | 1674 | |
7a95317d GS |
1675 | Better support for building Perl under command.com in Windows 95 |
1676 | has been added. | |
06ef4121 | 1677 | |
7a95317d GS |
1678 | Scripts are read in binary mode by default to allow ByteLoader (and |
1679 | the filter mechanism in general) to work properly. For compatibility, | |
1680 | the DATA filehandle will be set to text mode if a carriage return is | |
1681 | detected at the end of the line containing the __END__ or __DATA__ | |
1682 | token; if not, the DATA filehandle will be left open in binary mode. | |
1683 | Earlier versions always opened the DATA filehandle in text mode. | |
8fe0a5c4 | 1684 | |
7a95317d GS |
1685 | The glob() operator is implemented via the C<File::Glob> extension, |
1686 | which supports glob syntax of the C shell. This increases the flexibility | |
1687 | of the glob() operator, but there may be compatibility issues for | |
1688 | programs that relied on the older globbing syntax. If you want to | |
1689 | preserve compatibility with the older syntax, you might want to run | |
1690 | perl with C<-MFile::DosGlob>. For details and compatibility information, | |
1691 | see L<File::Glob>. | |
8fe0a5c4 | 1692 | |
7a95317d | 1693 | =head1 Significant bug fixes |
8fe0a5c4 | 1694 | |
7a95317d | 1695 | =head2 <HANDLE> on empty files |
8fe0a5c4 | 1696 | |
7a95317d GS |
1697 | With C<$/> set to C<undef>, "slurping" an empty file returns a string of |
1698 | zero length (instead of C<undef>, as it used to) the first time the | |
1699 | HANDLE is read after C<$/> is set to C<undef>. Further reads yield | |
1700 | C<undef>. | |
8fe0a5c4 | 1701 | |
7a95317d GS |
1702 | This means that the following will append "foo" to an empty file (it used |
1703 | to do nothing): | |
8fe0a5c4 | 1704 | |
7a95317d | 1705 | perl -0777 -pi -e 's/^/foo/' empty_file |
23d2500b | 1706 | |
7a95317d | 1707 | The behaviour of: |
23d2500b | 1708 | |
7a95317d | 1709 | perl -pi -e 's/^/foo/' empty_file |
9fe6733a | 1710 | |
7a95317d | 1711 | is unchanged (it continues to leave the file empty). |
9fe6733a | 1712 | |
7a95317d | 1713 | =head2 C<eval '...'> improvements |
9fe6733a | 1714 | |
7a95317d GS |
1715 | Line numbers (as reflected by caller() and most diagnostics) within |
1716 | C<eval '...'> were often incorrect where here documents were involved. | |
1717 | This has been corrected. | |
9fe6733a | 1718 | |
7a95317d GS |
1719 | Lexical lookups for variables appearing in C<eval '...'> within |
1720 | functions that were themselves called within an C<eval '...'> were | |
1721 | searching the wrong place for lexicals. The lexical search now | |
1722 | correctly ends at the subroutine's block boundary. | |
3e8c4fa0 | 1723 | |
7a95317d GS |
1724 | The use of C<return> within C<eval {...}> caused $@ not to be reset |
1725 | correctly when no exception occurred within the eval. This has | |
1726 | been fixed. | |
3e8c4fa0 | 1727 | |
7a95317d GS |
1728 | Parsing of here documents used to be flawed when they appeared as |
1729 | the replacement expression in C<eval 's/.../.../e'>. This has | |
1730 | been fixed. | |
09bef843 | 1731 | |
7a95317d | 1732 | =head2 All compilation errors are true errors |
6c67e1bb | 1733 | |
4375e838 | 1734 | Some "errors" encountered at compile time were by necessity |
7a95317d GS |
1735 | generated as warnings followed by eventual termination of the |
1736 | program. This enabled more such errors to be reported in a | |
1737 | single run, rather than causing a hard stop at the first error | |
1738 | that was encountered. | |
6c67e1bb | 1739 | |
7a95317d GS |
1740 | The mechanism for reporting such errors has been reimplemented |
1741 | to queue compile-time errors and report them at the end of the | |
1742 | compilation as true errors rather than as warnings. This fixes | |
1743 | cases where error messages leaked through in the form of warnings | |
1744 | when code was compiled at run time using C<eval STRING>, and | |
1745 | also allows such errors to be reliably trapped using C<eval "...">. | |
ba8251e8 | 1746 | |
7a95317d | 1747 | =head2 Implicitly closed filehandles are safer |
a5222a85 | 1748 | |
7a95317d GS |
1749 | Sometimes implicitly closed filehandles (as when they are localized, |
1750 | and Perl automatically closes them on exiting the scope) could | |
1751 | inadvertently set $? or $!. This has been corrected. | |
a5222a85 | 1752 | |
a5222a85 | 1753 | |
7a95317d | 1754 | =head2 Behavior of list slices is more consistent |
055fd3a9 | 1755 | |
7a95317d GS |
1756 | When taking a slice of a literal list (as opposed to a slice of |
1757 | an array or hash), Perl used to return an empty list if the | |
1758 | result happened to be composed of all undef values. | |
055fd3a9 | 1759 | |
7a95317d GS |
1760 | The new behavior is to produce an empty list if (and only if) |
1761 | the original list was empty. Consider the following example: | |
055fd3a9 | 1762 | |
7a95317d | 1763 | @a = (1,undef,undef,2)[2,1,2]; |
055fd3a9 | 1764 | |
7a95317d GS |
1765 | The old behavior would have resulted in @a having no elements. |
1766 | The new behavior ensures it has three undefined elements. | |
ba8251e8 | 1767 | |
7a95317d GS |
1768 | Note in particular that the behavior of slices of the following |
1769 | cases remains unchanged: | |
5fdc711f | 1770 | |
7a95317d GS |
1771 | @a = ()[1,2]; |
1772 | @a = (getpwent)[7,0]; | |
1773 | @a = (anything_returning_empty_list())[2,1,2]; | |
1774 | @a = @b[2,1,2]; | |
1775 | @a = @c{'a','b','c'}; | |
954c1994 | 1776 | |
7a95317d | 1777 | See L<perldata>. |
954c1994 | 1778 | |
7a95317d | 1779 | =head2 C<(\$)> prototype and C<$foo{a}> |
883d36a6 | 1780 | |
7a95317d GS |
1781 | A scalar reference prototype now correctly allows a hash or |
1782 | array element in that slot. | |
883d36a6 | 1783 | |
7a95317d | 1784 | =head2 C<goto &sub> and AUTOLOAD |
055fd3a9 | 1785 | |
7a95317d GS |
1786 | The C<goto &sub> construct works correctly when C<&sub> happens |
1787 | to be autoloaded. | |
055fd3a9 | 1788 | |
7a95317d | 1789 | =head2 C<-bareword> allowed under C<use integer> |
055fd3a9 | 1790 | |
7a95317d GS |
1791 | The autoquoting of barewords preceded by C<-> did not work |
1792 | in prior versions when the C<integer> pragma was enabled. | |
1793 | This has been fixed. | |
055fd3a9 | 1794 | |
7a95317d | 1795 | =head2 Failures in DESTROY() |
c7c04614 | 1796 | |
7a95317d GS |
1797 | When code in a destructor threw an exception, it went unnoticed |
1798 | in earlier versions of Perl, unless someone happened to be | |
1799 | looking in $@ just after the point the destructor happened to | |
1800 | run. Such failures are now visible as warnings when warnings are | |
1801 | enabled. | |
c7c04614 | 1802 | |
7a95317d | 1803 | =head2 Locale bugs fixed |
883d36a6 | 1804 | |
7a95317d GS |
1805 | printf() and sprintf() previously reset the numeric locale |
1806 | back to the default "C" locale. This has been fixed. | |
883d36a6 | 1807 | |
7a95317d GS |
1808 | Numbers formatted according to the local numeric locale |
1809 | (such as using a decimal comma instead of a decimal dot) caused | |
1810 | "isn't numeric" warnings, even while the operations accessing | |
1811 | those numbers produced correct results. These warnings have been | |
1812 | discontinued. | |
954c1994 | 1813 | |
7a95317d | 1814 | =head2 Memory leaks |
954c1994 | 1815 | |
7a95317d GS |
1816 | The C<eval 'return sub {...}'> construct could sometimes leak |
1817 | memory. This has been fixed. | |
f8284313 | 1818 | |
7a95317d GS |
1819 | Operations that aren't filehandle constructors used to leak memory |
1820 | when used on invalid filehandles. This has been fixed. | |
5fdc711f | 1821 | |
7a95317d GS |
1822 | Constructs that modified C<@_> could fail to deallocate values |
1823 | in C<@_> and thus leak memory. This has been corrected. | |
5fdc711f | 1824 | |
7a95317d | 1825 | =head2 Spurious subroutine stubs after failed subroutine calls |
5fdc711f | 1826 | |
7a95317d GS |
1827 | Perl could sometimes create empty subroutine stubs when a |
1828 | subroutine was not found in the package. Such cases stopped | |
1829 | later method lookups from progressing into base packages. | |
1830 | This has been corrected. | |
694468e3 | 1831 | |
7a95317d | 1832 | =head2 Taint failures under C<-U> |
694468e3 | 1833 | |
7a95317d GS |
1834 | When running in unsafe mode, taint violations could sometimes |
1835 | cause silent failures. This has been fixed. | |
1836 | ||
1837 | =head2 END blocks and the C<-c> switch | |
1838 | ||
1839 | Prior versions used to run BEGIN B<and> END blocks when Perl was | |
1840 | run in compile-only mode. Since this is typically not the expected | |
1841 | behavior, END blocks are not executed anymore when the C<-c> switch | |
db517d64 | 1842 | is used, or if compilation fails. |
14218588 | 1843 | |
13a2d996 SP |
1844 | See L</"Support for CHECK blocks"> for how to run things when the compile |
1845 | phase ends. | |
14218588 | 1846 | |
7a95317d | 1847 | =head2 Potential to leak DATA filehandles |
393fec97 | 1848 | |
7a95317d GS |
1849 | Using the C<__DATA__> token creates an implicit filehandle to |
1850 | the file that contains the token. It is the program's | |
1851 | responsibility to close it when it is done reading from it. | |
393fec97 | 1852 | |
7a95317d GS |
1853 | This caveat is now better explained in the documentation. |
1854 | See L<perldata>. | |
e02fdbd2 | 1855 | |
73b437c8 | 1856 | =head1 New or Changed Diagnostics |
ba8251e8 | 1857 | |
a99ba403 GS |
1858 | =over 4 |
1859 | ||
56e90b21 GS |
1860 | =item "%s" variable %s masks earlier declaration in same %s |
1861 | ||
ddda08b7 | 1862 | (W misc) A "my" or "our" variable has been redeclared in the current scope or statement, |
56e90b21 GS |
1863 | effectively eliminating all access to the previous instance. This is almost |
1864 | always a typographical error. Note that the earlier variable will still exist | |
1865 | until the end of the scope or until all closure referents to it are | |
1866 | destroyed. | |
1867 | ||
33633739 GS |
1868 | =item "my sub" not yet implemented |
1869 | ||
1870 | (F) Lexically scoped subroutines are not yet implemented. Don't try that | |
1871 | yet. | |
1872 | ||
1873 | =item "our" variable %s redeclared | |
1874 | ||
ddda08b7 | 1875 | (W misc) You seem to have already declared the same global once before in the |
33633739 GS |
1876 | current lexical scope. |
1877 | ||
a99ba403 GS |
1878 | =item '!' allowed only after types %s |
1879 | ||
1880 | (F) The '!' is allowed in pack() and unpack() only after certain types. | |
1881 | See L<perlfunc/pack>. | |
1882 | ||
1883 | =item / cannot take a count | |
1884 | ||
1885 | (F) You had an unpack template indicating a counted-length string, | |
1886 | but you have also specified an explicit size for the string. | |
1887 | See L<perlfunc/pack>. | |
1888 | ||
1889 | =item / must be followed by a, A or Z | |
1890 | ||
1891 | (F) You had an unpack template indicating a counted-length string, | |
1892 | which must be followed by one of the letters a, A or Z | |
1893 | to indicate what sort of string is to be unpacked. | |
1894 | See L<perlfunc/pack>. | |
1895 | ||
1896 | =item / must be followed by a*, A* or Z* | |
1897 | ||
437784d6 | 1898 | (F) You had a pack template indicating a counted-length string, |
a99ba403 GS |
1899 | Currently the only things that can have their length counted are a*, A* or Z*. |
1900 | See L<perlfunc/pack>. | |
1901 | ||
1902 | =item / must follow a numeric type | |
1903 | ||
1904 | (F) You had an unpack template that contained a '#', | |
1905 | but this did not follow some numeric unpack specification. | |
1906 | See L<perlfunc/pack>. | |
1907 | ||
a99ba403 GS |
1908 | =item /%s/: Unrecognized escape \\%c passed through |
1909 | ||
ddda08b7 | 1910 | (W regexp) You used a backslash-character combination which is not recognized |
a99ba403 | 1911 | by Perl. This combination appears in an interpolated variable or a |
1028017a JH |
1912 | C<'>-delimited regular expression. The character was understood literally. |
1913 | ||
1914 | =item /%s/: Unrecognized escape \\%c in character class passed through | |
1915 | ||
ddda08b7 | 1916 | (W regexp) You used a backslash-character combination which is not recognized |
1028017a | 1917 | by Perl inside character classes. The character was understood literally. |
a99ba403 GS |
1918 | |
1919 | =item /%s/ should probably be written as "%s" | |
1920 | ||
ddda08b7 | 1921 | (W syntax) You have used a pattern where Perl expected to find a string, |
437784d6 | 1922 | as in the first argument to C<join>. Perl will treat the true |
a99ba403 GS |
1923 | or false result of matching the pattern against $_ as the string, |
1924 | which is probably not what you had in mind. | |
1925 | ||
1926 | =item %s() called too early to check prototype | |
1927 | ||
ddda08b7 | 1928 | (W prototype) You've called a function that has a prototype before the parser saw a |
a99ba403 GS |
1929 | definition or declaration for it, and Perl could not check that the call |
1930 | conforms to the prototype. You need to either add an early prototype | |
1931 | declaration for the subroutine in question, or move the subroutine | |
1932 | definition ahead of the call to get proper prototype checking. Alternatively, | |
1933 | if you are certain that you're calling the function correctly, you may put | |
1934 | an ampersand before the name to avoid the warning. See L<perlsub>. | |
1935 | ||
56e90b21 GS |
1936 | =item %s argument is not a HASH or ARRAY element |
1937 | ||
1938 | (F) The argument to exists() must be a hash or array element, such as: | |
1939 | ||
1940 | $foo{$bar} | |
7a95317d | 1941 | $ref->{"susie"}[12] |
56e90b21 GS |
1942 | |
1943 | =item %s argument is not a HASH or ARRAY element or slice | |
1944 | ||
1945 | (F) The argument to delete() must be either a hash or array element, such as: | |
1946 | ||
1947 | $foo{$bar} | |
7a95317d | 1948 | $ref->{"susie"}[12] |
56e90b21 GS |
1949 | |
1950 | or a hash or array slice, such as: | |
1951 | ||
1952 | @foo[$bar, $baz, $xyzzy] | |
1953 | @{$ref->[12]}{"susie", "queue"} | |
1954 | ||
afebc493 GS |
1955 | =item %s argument is not a subroutine name |
1956 | ||
1957 | (F) The argument to exists() for C<exists &sub> must be a subroutine | |
1958 | name, and not a subroutine call. C<exists &sub()> will generate this error. | |
1959 | ||
09bef843 SB |
1960 | =item %s package attribute may clash with future reserved word: %s |
1961 | ||
ddda08b7 | 1962 | (W reserved) A lowercase attribute name was used that had a package-specific handler. |
09bef843 SB |
1963 | That name might have a meaning to Perl itself some day, even though it |
1964 | doesn't yet. Perhaps you should use a mixed-case attribute name, instead. | |
1965 | See L<attributes>. | |
1966 | ||
cc507455 | 1967 | =item (in cleanup) %s |
6b121555 | 1968 | |
ddda08b7 | 1969 | (W misc) This prefix usually indicates that a DESTROY() method raised |
a99ba403 GS |
1970 | the indicated exception. Since destructors are usually called by |
1971 | the system at arbitrary points during execution, and often a vast | |
1972 | number of times, the warning is issued only once for any number | |
1973 | of failures that would otherwise result in the same message being | |
1974 | repeated. | |
1975 | ||
1976 | Failure of user callbacks dispatched using the C<G_KEEPERR> flag | |
1977 | could also result in this warning. See L<perlcall/G_KEEPERR>. | |
1978 | ||
1979 | =item <> should be quotes | |
1980 | ||
c47ff5f1 | 1981 | (F) You wrote C<< require <file> >> when you should have written |
a99ba403 GS |
1982 | C<require 'file'>. |
1983 | ||
1984 | =item Attempt to join self | |
1985 | ||
1986 | (F) You tried to join a thread from within itself, which is an | |
1987 | impossible task. You may be joining the wrong thread, or you may | |
1988 | need to move the join() to some other thread. | |
1989 | ||
1990 | =item Bad evalled substitution pattern | |
1991 | ||
1992 | (F) You've used the /e switch to evaluate the replacement for a | |
1993 | substitution, but perl found a syntax error in the code to evaluate, | |
1994 | most likely an unexpected right brace '}'. | |
1995 | ||
1996 | =item Bad realloc() ignored | |
1997 | ||
1998 | (S) An internal routine called realloc() on something that had never been | |
1999 | malloc()ed in the first place. Mandatory, but can be disabled by | |
2000 | setting environment variable C<PERL_BADFREE> to 1. | |
2001 | ||
34d09196 GS |
2002 | =item Bareword found in conditional |
2003 | ||
ddda08b7 | 2004 | (W bareword) The compiler found a bareword where it expected a conditional, |
34d09196 GS |
2005 | which often indicates that an || or && was parsed as part of the |
2006 | last argument of the previous construct, for example: | |
2007 | ||
2008 | open FOO || die; | |
2009 | ||
2010 | It may also indicate a misspelled constant that has been interpreted | |
2011 | as a bareword: | |
2012 | ||
2013 | use constant TYPO => 1; | |
2014 | if (TYOP) { print "foo" } | |
2015 | ||
2016 | The C<strict> pragma is useful in avoiding such errors. | |
2017 | ||
a99ba403 GS |
2018 | =item Binary number > 0b11111111111111111111111111111111 non-portable |
2019 | ||
ddda08b7 | 2020 | (W portable) The binary number you specified is larger than 2**32-1 |
a99ba403 GS |
2021 | (4294967295) and therefore non-portable between systems. See |
2022 | L<perlport> for more on portability concerns. | |
2023 | ||
2024 | =item Bit vector size > 32 non-portable | |
2025 | ||
ddda08b7 | 2026 | (W portable) Using bit vector sizes larger than 32 is non-portable. |
a99ba403 GS |
2027 | |
2028 | =item Buffer overflow in prime_env_iter: %s | |
2029 | ||
ddda08b7 | 2030 | (W internal) A warning peculiar to VMS. While Perl was preparing to iterate over |
a99ba403 GS |
2031 | %ENV, it encountered a logical name or symbol definition which was too long, |
2032 | so it was truncated to the string shown. | |
2033 | ||
2034 | =item Can't check filesystem of script "%s" | |
2035 | ||
2036 | (P) For some reason you can't check the filesystem of the script for nosuid. | |
2037 | ||
56e90b21 GS |
2038 | =item Can't declare class for non-scalar %s in "%s" |
2039 | ||
2040 | (S) Currently, only scalar variables can declared with a specific class | |
2041 | qualifier in a "my" or "our" declaration. The semantics may be extended | |
2042 | for other types of variables in future. | |
2043 | ||
2044 | =item Can't declare %s in "%s" | |
2045 | ||
2046 | (F) Only scalar, array, and hash variables may be declared as "my" or | |
2047 | "our" variables. They must have ordinary identifiers as names. | |
2048 | ||
0b5b802d GS |
2049 | =item Can't ignore signal CHLD, forcing to default |
2050 | ||
ddda08b7 | 2051 | (W signal) Perl has detected that it is being run with the SIGCHLD signal |
0b5b802d GS |
2052 | (sometimes known as SIGCLD) disabled. Since disabling this signal |
2053 | will interfere with proper determination of exit status of child | |
2054 | processes, Perl has reset the signal to its default value. | |
2055 | This situation typically indicates that the parent program under | |
642f9deb | 2056 | which Perl may be running (e.g., cron) is being very careless. |
0b5b802d | 2057 | |
a99ba403 GS |
2058 | =item Can't modify non-lvalue subroutine call |
2059 | ||
437784d6 GS |
2060 | (F) Subroutines meant to be used in lvalue context should be declared as |
2061 | such, see L<perlsub/"Lvalue subroutines">. | |
a99ba403 GS |
2062 | |
2063 | =item Can't read CRTL environ | |
2064 | ||
2065 | (S) A warning peculiar to VMS. Perl tried to read an element of %ENV | |
2066 | from the CRTL's internal environment array and discovered the array was | |
2067 | missing. You need to figure out where your CRTL misplaced its environ | |
2068 | or define F<PERL_ENV_TABLES> (see L<perlvms>) so that environ is not searched. | |
2069 | ||
2070 | =item Can't remove %s: %s, skipping file | |
2071 | ||
2072 | (S) You requested an inplace edit without creating a backup file. Perl | |
2073 | was unable to remove the original file to replace it with the modified | |
2074 | file. The file was left unmodified. | |
2075 | ||
2076 | =item Can't return %s from lvalue subroutine | |
2077 | ||
2078 | (F) Perl detected an attempt to return illegal lvalues (such | |
2079 | as temporary or readonly values) from a subroutine used as an lvalue. | |
2080 | This is not allowed. | |
2081 | ||
2082 | =item Can't weaken a nonreference | |
2083 | ||
2084 | (F) You attempted to weaken something that was not a reference. Only | |
2085 | references can be weakened. | |
2086 | ||
2087 | =item Character class [:%s:] unknown | |
2088 | ||
2089 | (F) The class in the character class [: :] syntax is unknown. | |
437784d6 | 2090 | See L<perlre>. |
a99ba403 GS |
2091 | |
2092 | =item Character class syntax [%s] belongs inside character classes | |
2093 | ||
ddda08b7 | 2094 | (W unsafe) The character class constructs [: :], [= =], and [. .] go |
a99ba403 | 2095 | I<inside> character classes, the [] are part of the construct, |
437784d6 GS |
2096 | for example: /[012[:alpha:]345]/. Note that [= =] and [. .] |
2097 | are not currently implemented; they are simply placeholders for | |
2098 | future extensions. | |
a99ba403 GS |
2099 | |
2100 | =item Constant is not %s reference | |
2101 | ||
2102 | (F) A constant value (perhaps declared using the C<use constant> pragma) | |
2103 | is being dereferenced, but it amounts to the wrong type of reference. The | |
2104 | message indicates the type of reference that was expected. This usually | |
2105 | indicates a syntax error in dereferencing the constant value. | |
2106 | See L<perlsub/"Constant Functions"> and L<constant>. | |
2107 | ||
a99ba403 GS |
2108 | =item constant(%s): %s |
2109 | ||
f0af216f GS |
2110 | (F) The parser found inconsistencies either while attempting to define an |
2111 | overloaded constant, or when trying to find the character name specified | |
2112 | in the C<\N{...}> escape. Perhaps you forgot to load the corresponding | |
2113 | C<overload> or C<charnames> pragma? See L<charnames> and L<overload>. | |
a99ba403 | 2114 | |
6798c92b GS |
2115 | =item CORE::%s is not a keyword |
2116 | ||
2117 | (F) The CORE:: namespace is reserved for Perl keywords. | |
2118 | ||
a99ba403 GS |
2119 | =item defined(@array) is deprecated |
2120 | ||
2121 | (D) defined() is not usually useful on arrays because it checks for an | |
2122 | undefined I<scalar> value. If you want to see if the array is empty, | |
2123 | just use C<if (@array) { # not empty }> for example. | |
2124 | ||
2125 | =item defined(%hash) is deprecated | |
2126 | ||
2127 | (D) defined() is not usually useful on hashes because it checks for an | |
2128 | undefined I<scalar> value. If you want to see if the hash is empty, | |
2129 | just use C<if (%hash) { # not empty }> for example. | |
2130 | ||
2131 | =item Did not produce a valid header | |
2132 | ||
2133 | See Server error. | |
2134 | ||
cc507455 | 2135 | =item (Did you mean "local" instead of "our"?) |
33633739 | 2136 | |
ddda08b7 | 2137 | (W misc) Remember that "our" does not localize the declared global variable. |
33633739 GS |
2138 | You have declared it again in the same lexical scope, which seems superfluous. |
2139 | ||
a99ba403 GS |
2140 | =item Document contains no data |
2141 | ||
2142 | See Server error. | |
2143 | ||
2144 | =item entering effective %s failed | |
2145 | ||
2146 | (F) While under the C<use filetest> pragma, switching the real and | |
2147 | effective uids or gids failed. | |
6b121555 | 2148 | |
73b437c8 JH |
2149 | =item false [] range "%s" in regexp |
2150 | ||
ddda08b7 | 2151 | (W regexp) A character class range must start and end at a literal character, not |
73b437c8 JH |
2152 | another character class like C<\d> or C<[:alpha:]>. The "-" in your false |
2153 | range is interpreted as a literal "-". Consider quoting the "-", "\-". | |
2154 | See L<perlre>. | |
2155 | ||
af8c498a | 2156 | =item Filehandle %s opened only for output |
6b121555 | 2157 | |
ddda08b7 | 2158 | (W io) You tried to read from a filehandle opened only for writing. If you |
437784d6 | 2159 | intended it to be a read/write filehandle, you needed to open it with |
c47ff5f1 GS |
2160 | "+<" or "+>" or "+>>" instead of with "<" or nothing. If |
2161 | you intended only to read from the file, use "<". See | |
af8c498a | 2162 | L<perlfunc/open>. |
e02fdbd2 | 2163 | |
56e90b21 GS |
2164 | =item flock() on closed filehandle %s |
2165 | ||
ddda08b7 | 2166 | (W closed) The filehandle you're attempting to flock() got itself closed some |
56e90b21 GS |
2167 | time before now. Check your logic flow. flock() operates on filehandles. |
2168 | Are you attempting to call flock() on a dirhandle by the same name? | |
2169 | ||
2170 | =item Global symbol "%s" requires explicit package name | |
2171 | ||
2172 | (F) You've said "use strict vars", which indicates that all variables | |
2173 | must either be lexically scoped (using "my"), declared beforehand using | |
2174 | "our", or explicitly qualified to say which package the global variable | |
2175 | is in (using "::"). | |
2176 | ||
a99ba403 GS |
2177 | =item Hexadecimal number > 0xffffffff non-portable |
2178 | ||
ddda08b7 | 2179 | (W portable) The hexadecimal number you specified is larger than 2**32-1 |
a99ba403 GS |
2180 | (4294967295) and therefore non-portable between systems. See |
2181 | L<perlport> for more on portability concerns. | |
2182 | ||
2183 | =item Ill-formed CRTL environ value "%s" | |
2184 | ||
ddda08b7 | 2185 | (W internal) A warning peculiar to VMS. Perl tried to read the CRTL's internal |
a99ba403 | 2186 | environ array, and encountered an element without the C<=> delimiter |
4375e838 | 2187 | used to separate keys from values. The element is ignored. |
a99ba403 GS |
2188 | |
2189 | =item Ill-formed message in prime_env_iter: |%s| | |
2190 | ||
ddda08b7 | 2191 | (W internal) A warning peculiar to VMS. Perl tried to read a logical name |
a99ba403 GS |
2192 | or CLI symbol definition when preparing to iterate over %ENV, and |
2193 | didn't see the expected delimiter between key and value, so the | |
2194 | line was ignored. | |
2195 | ||
2196 | =item Illegal binary digit %s | |
2197 | ||
437784d6 | 2198 | (F) You used a digit other than 0 or 1 in a binary number. |
a99ba403 GS |
2199 | |
2200 | =item Illegal binary digit %s ignored | |
2201 | ||
ddda08b7 | 2202 | (W digit) You may have tried to use a digit other than 0 or 1 in a binary number. |
a99ba403 GS |
2203 | Interpretation of the binary number stopped before the offending digit. |
2204 | ||
2205 | =item Illegal number of bits in vec | |
2206 | ||
2207 | (F) The number of bits in vec() (the third argument) must be a power of | |
2208 | two from 1 to 32 (or 64, if your platform supports that). | |
2209 | ||
2210 | =item Integer overflow in %s number | |
2211 | ||
ddda08b7 | 2212 | (W overflow) The hexadecimal, octal or binary number you have specified either |
c6edd1b7 | 2213 | as a literal or as an argument to hex() or oct() is too big for your |
a99ba403 GS |
2214 | architecture, and has been converted to a floating point number. On a |
2215 | 32-bit architecture the largest hexadecimal, octal or binary number | |
2216 | representable without overflow is 0xFFFFFFFF, 037777777777, or | |
2217 | 0b11111111111111111111111111111111 respectively. Note that Perl | |
2218 | transparently promotes all numbers to a floating point representation | |
2219 | internally--subject to loss of precision errors in subsequent | |
2220 | operations. | |
2221 | ||
09bef843 SB |
2222 | =item Invalid %s attribute: %s |
2223 | ||
2224 | The indicated attribute for a subroutine or variable was not recognized | |
2225 | by Perl or by a user-supplied handler. See L<attributes>. | |
2226 | ||
2227 | =item Invalid %s attributes: %s | |
2228 | ||
2229 | The indicated attributes for a subroutine or variable were not recognized | |
2230 | by Perl or by a user-supplied handler. See L<attributes>. | |
2231 | ||
73b437c8 JH |
2232 | =item invalid [] range "%s" in regexp |
2233 | ||
2234 | The offending range is now explicitly displayed. | |
2235 | ||
09bef843 SB |
2236 | =item Invalid separator character %s in attribute list |
2237 | ||
0120eecf | 2238 | (F) Something other than a colon or whitespace was seen between the |
09bef843 SB |
2239 | elements of an attribute list. If the previous attribute |
2240 | had a parenthesised parameter list, perhaps that list was terminated | |
2241 | too soon. See L<attributes>. | |
2242 | ||
a99ba403 GS |
2243 | =item Invalid separator character %s in subroutine attribute list |
2244 | ||
0120eecf | 2245 | (F) Something other than a colon or whitespace was seen between the |
a99ba403 GS |
2246 | elements of a subroutine attribute list. If the previous attribute |
2247 | had a parenthesised parameter list, perhaps that list was terminated | |
2248 | too soon. | |
2249 | ||
2250 | =item leaving effective %s failed | |
2251 | ||
2252 | (F) While under the C<use filetest> pragma, switching the real and | |
2253 | effective uids or gids failed. | |
2254 | ||
2255 | =item Lvalue subs returning %s not implemented yet | |
2256 | ||
2257 | (F) Due to limitations in the current implementation, array and hash | |
2258 | values cannot be returned in subroutines used in lvalue context. | |
2259 | See L<perlsub/"Lvalue subroutines">. | |
2260 | ||
2261 | =item Method %s not permitted | |
2262 | ||
2263 | See Server error. | |
2264 | ||
2265 | =item Missing %sbrace%s on \N{} | |
2266 | ||
2267 | (F) Wrong syntax of character name literal C<\N{charname}> within | |
2268 | double-quotish context. | |
2269 | ||
06eaf0bc GS |
2270 | =item Missing command in piped open |
2271 | ||
ddda08b7 | 2272 | (W pipe) You used the C<open(FH, "| command")> or C<open(FH, "command |")> |
06eaf0bc GS |
2273 | construction, but the command was missing or blank. |
2274 | ||
09bef843 SB |
2275 | =item Missing name in "my sub" |
2276 | ||
2277 | (F) The reserved syntax for lexically scoped subroutines requires that they | |
2278 | have a name with which they can be found. | |
2279 | ||
56e90b21 GS |
2280 | =item No %s specified for -%c |
2281 | ||
2282 | (F) The indicated command line switch needs a mandatory argument, but | |
2283 | you haven't specified one. | |
2284 | ||
2285 | =item No package name allowed for variable %s in "our" | |
2286 | ||
2287 | (F) Fully qualified variable names are not allowed in "our" declarations, | |
2288 | because that doesn't make much sense under existing semantics. Such | |
2289 | syntax is reserved for future extensions. | |
2290 | ||
2291 | =item No space allowed after -%c | |
2292 | ||
2293 | (F) The argument to the indicated command line switch must follow immediately | |
2294 | after the switch, without intervening spaces. | |
2295 | ||
a99ba403 GS |
2296 | =item no UTC offset information; assuming local time is UTC |
2297 | ||
2298 | (S) A warning peculiar to VMS. Perl was unable to find the local | |
2299 | timezone offset, so it's assuming that local system time is equivalent | |
2300 | to UTC. If it's not, define the logical name F<SYS$TIMEZONE_DIFFERENTIAL> | |
2301 | to translate to the number of seconds which need to be added to UTC to | |
2302 | get local time. | |
2303 | ||
2304 | =item Octal number > 037777777777 non-portable | |
2305 | ||
ddda08b7 | 2306 | (W portable) The octal number you specified is larger than 2**32-1 (4294967295) |
a99ba403 GS |
2307 | and therefore non-portable between systems. See L<perlport> for more |
2308 | on portability concerns. | |
2309 | ||
2310 | See also L<perlport> for writing portable code. | |
2311 | ||
2312 | =item panic: del_backref | |
2313 | ||
2314 | (P) Failed an internal consistency check while trying to reset a weak | |
2315 | reference. | |
2316 | ||
2317 | =item panic: kid popen errno read | |
2318 | ||
2319 | (F) forked child returned an incomprehensible message about its errno. | |
2320 | ||
2321 | =item panic: magic_killbackrefs | |
2322 | ||
2323 | (P) Failed an internal consistency check while trying to reset all weak | |
2324 | references to an object. | |
2325 | ||
56e90b21 GS |
2326 | =item Parentheses missing around "%s" list |
2327 | ||
ddda08b7 | 2328 | (W parenthesis) You said something like |
56e90b21 GS |
2329 | |
2330 | my $foo, $bar = @_; | |
2331 | ||
2332 | when you meant | |
2333 | ||
2334 | my ($foo, $bar) = @_; | |
2335 | ||
54884818 | 2336 | Remember that "my", "our", and "local" bind tighter than comma. |
56e90b21 | 2337 | |
8593bda5 GS |
2338 | =item Possible unintended interpolation of %s in string |
2339 | ||
2340 | (W ambiguous) It used to be that Perl would try to guess whether you | |
2341 | wanted an array interpolated or a literal @. It no longer does this; | |
2342 | arrays are now I<always> interpolated into strings. This means that | |
2343 | if you try something like: | |
2344 | ||
2345 | print "fred@example.com"; | |
2346 | ||
2347 | and the array C<@example> doesn't exist, Perl is going to print | |
2348 | C<fred.com>, which is probably not what you wanted. To get a literal | |
2349 | C<@> sign in a string, put a backslash before it, just as you would | |
2350 | to get a literal C<$> sign. | |
2351 | ||
a99ba403 GS |
2352 | =item Possible Y2K bug: %s |
2353 | ||
ddda08b7 | 2354 | (W y2k) You are concatenating the number 19 with another number, which |
a99ba403 GS |
2355 | could be a potential Year 2000 problem. |
2356 | ||
8cd79558 GS |
2357 | =item pragma "attrs" is deprecated, use "sub NAME : ATTRS" instead |
2358 | ||
4375e838 | 2359 | (W deprecated) You have written something like this: |
8cd79558 GS |
2360 | |
2361 | sub doit | |
2362 | { | |
2363 | use attrs qw(locked); | |
2364 | } | |
2365 | ||
2366 | You should use the new declaration syntax instead. | |
2367 | ||
2368 | sub doit : locked | |
2369 | { | |
2370 | ... | |
2371 | ||
2372 | The C<use attrs> pragma is now obsolete, and is only provided for | |
2373 | backward-compatibility. See L<perlsub/"Subroutine Attributes">. | |
2374 | ||
a99ba403 GS |
2375 | =item Premature end of script headers |
2376 | ||
2377 | See Server error. | |
2378 | ||
0b5b802d GS |
2379 | =item Repeat count in pack overflows |
2380 | ||
2381 | (F) You can't specify a repeat count so large that it overflows | |
2382 | your signed integers. See L<perlfunc/pack>. | |
2383 | ||
2384 | =item Repeat count in unpack overflows | |
2385 | ||
2386 | (F) You can't specify a repeat count so large that it overflows | |
2387 | your signed integers. See L<perlfunc/unpack>. | |
2388 | ||
a99ba403 GS |
2389 | =item realloc() of freed memory ignored |
2390 | ||
2391 | (S) An internal routine called realloc() on something that had already | |
2392 | been freed. | |
2393 | ||
2394 | =item Reference is already weak | |
2395 | ||
7a95317d GS |
2396 | (W misc) You have attempted to weaken a reference that is already weak. |
2397 | Doing so has no effect. | |
2398 | ||
2399 | =item setpgrp can't take arguments | |
2400 | ||
2401 | (F) Your system has the setpgrp() from BSD 4.2, which takes no arguments, | |
2402 | unlike POSIX setpgid(), which takes a process ID and process group ID. | |
2403 | ||
2404 | =item Strange *+?{} on zero-length expression | |
2405 | ||
2406 | (W regexp) You applied a regular expression quantifier in a place where it | |
2407 | makes no sense, such as on a zero-width assertion. | |
2408 | Try putting the quantifier inside the assertion instead. For example, | |
2409 | the way to match "abc" provided that it is followed by three | |
2410 | repetitions of "xyz" is C</abc(?=(?:xyz){3})/>, not C</abc(?=xyz){3}/>. | |
2411 | ||
2412 | =item switching effective %s is not implemented | |
2413 | ||
2414 | (F) While under the C<use filetest> pragma, we cannot switch the | |
2415 | real and effective uids or gids. | |
2416 | ||
2417 | =item This Perl can't reset CRTL environ elements (%s) | |
2418 | ||
2419 | =item This Perl can't set CRTL environ elements (%s=%s) | |
2420 | ||
2421 | (W internal) Warnings peculiar to VMS. You tried to change or delete an element | |
2422 | of the CRTL's internal environ array, but your copy of Perl wasn't | |
2423 | built with a CRTL that contained the setenv() function. You'll need to | |
2424 | rebuild Perl with a CRTL that does, or redefine F<PERL_ENV_TABLES> (see | |
2425 | L<perlvms>) so that the environ array isn't the target of the change to | |
2426 | %ENV which produced the warning. | |
2427 | ||
2428 | =item Too late to run %s block | |
2429 | ||
2430 | (W void) A CHECK or INIT block is being defined during run time proper, | |
2431 | when the opportunity to run them has already passed. Perhaps you are | |
2432 | loading a file with C<require> or C<do> when you should be using | |
2433 | C<use> instead. Or perhaps you should put the C<require> or C<do> | |
2434 | inside a BEGIN block. | |
2435 | ||
2436 | =item Unknown open() mode '%s' | |
2437 | ||
2438 | (F) The second argument of 3-argument open() is not among the list | |
2439 | of valid modes: C<< < >>, C<< > >>, C<<< >> >>>, C<< +< >>, | |
2440 | C<< +> >>, C<<< +>> >>>, C<-|>, C<|->. | |
2441 | ||
2442 | =item Unknown process %x sent message to prime_env_iter: %s | |
2443 | ||
2444 | (P) An error peculiar to VMS. Perl was reading values for %ENV before | |
2445 | iterating over it, and someone else stuck a message in the stream of | |
2446 | data Perl expected. Someone's very confused, or perhaps trying to | |
2447 | subvert Perl's population of %ENV for nefarious purposes. | |
2448 | ||
2449 | =item Unrecognized escape \\%c passed through | |
2450 | ||
2451 | (W misc) You used a backslash-character combination which is not recognized | |
2452 | by Perl. The character was understood literally. | |
2453 | ||
2454 | =item Unterminated attribute parameter in attribute list | |
2455 | ||
2456 | (F) The lexer saw an opening (left) parenthesis character while parsing an | |
2457 | attribute list, but the matching closing (right) parenthesis | |
2458 | character was not found. You may need to add (or remove) a backslash | |
2459 | character to get your parentheses to balance. See L<attributes>. | |
2460 | ||
2461 | =item Unterminated attribute list | |
2462 | ||
2463 | (F) The lexer found something other than a simple identifier at the start | |
2464 | of an attribute, and it wasn't a semicolon or the start of a | |
2465 | block. Perhaps you terminated the parameter list of the previous attribute | |
2466 | too soon. See L<attributes>. | |
2467 | ||
2468 | =item Unterminated attribute parameter in subroutine attribute list | |
2469 | ||
2470 | (F) The lexer saw an opening (left) parenthesis character while parsing a | |
2471 | subroutine attribute list, but the matching closing (right) parenthesis | |
2472 | character was not found. You may need to add (or remove) a backslash | |
2473 | character to get your parentheses to balance. | |
2474 | ||
2475 | =item Unterminated subroutine attribute list | |
2476 | ||
2477 | (F) The lexer found something other than a simple identifier at the start | |
2478 | of a subroutine attribute, and it wasn't a semicolon or the start of a | |
2479 | block. Perhaps you terminated the parameter list of the previous attribute | |
2480 | too soon. | |
2481 | ||
2482 | =item Value of CLI symbol "%s" too long | |
2483 | ||
2484 | (W misc) A warning peculiar to VMS. Perl tried to read the value of an %ENV | |
2485 | element from a CLI symbol table, and found a resultant string longer | |
2486 | than 1024 characters. The return value has been truncated to 1024 | |
2487 | characters. | |
2488 | ||
2489 | =item Version number must be a constant number | |
2490 | ||
2491 | (P) The attempt to translate a C<use Module n.n LIST> statement into | |
2492 | its equivalent C<BEGIN> block found an internal inconsistency with | |
2493 | the version number. | |
2494 | ||
2495 | =back | |
2496 | ||
2497 | =head1 New tests | |
2498 | ||
2499 | =over 4 | |
2500 | ||
2501 | =item lib/attrs | |
2502 | ||
2503 | Compatibility tests for C<sub : attrs> vs the older C<use attrs>. | |
2504 | ||
2505 | =item lib/env | |
2506 | ||
2507 | Tests for new environment scalar capability (e.g., C<use Env qw($BAR);>). | |
2508 | ||
2509 | =item lib/env-array | |
2510 | ||
2511 | Tests for new environment array capability (e.g., C<use Env qw(@PATH);>). | |
2512 | ||
2513 | =item lib/io_const | |
2514 | ||
2515 | IO constants (SEEK_*, _IO*). | |
2516 | ||
2517 | =item lib/io_dir | |
2518 | ||
2519 | Directory-related IO methods (new, read, close, rewind, tied delete). | |
2520 | ||
2521 | =item lib/io_multihomed | |
2522 | ||
2523 | INET sockets with multi-homed hosts. | |
2524 | ||
2525 | =item lib/io_poll | |
2526 | ||
2527 | IO poll(). | |
2528 | ||
2529 | =item lib/io_unix | |
2530 | ||
2531 | UNIX sockets. | |
2532 | ||
2533 | =item op/attrs | |
2534 | ||
2535 | Regression tests for C<my ($x,@y,%z) : attrs> and <sub : attrs>. | |
2536 | ||
2537 | =item op/filetest | |
2538 | ||
2539 | File test operators. | |
2540 | ||
2541 | =item op/lex_assign | |
2542 | ||
2543 | Verify operations that access pad objects (lexicals and temporaries). | |
2544 | ||
2545 | =item op/exists_sub | |
2546 | ||
2547 | Verify C<exists &sub> operations. | |
2548 | ||
2549 | =back | |
2550 | ||
2551 | =head1 Incompatible Changes | |
2552 | ||
2553 | =head2 Perl Source Incompatibilities | |
2554 | ||
2555 | Beware that any new warnings that have been added or old ones | |
2556 | that have been enhanced are B<not> considered incompatible changes. | |
2557 | ||
2558 | Since all new warnings must be explicitly requested via the C<-w> | |
2559 | switch or the C<warnings> pragma, it is ultimately the programmer's | |
2560 | responsibility to ensure that warnings are enabled judiciously. | |
2561 | ||
2562 | =over 4 | |
2563 | ||
2564 | =item CHECK is a new keyword | |
2565 | ||
2566 | All subroutine definitions named CHECK are now special. See | |
2567 | C</"Support for CHECK blocks"> for more information. | |
2568 | ||
2569 | =item Treatment of list slices of undef has changed | |
2570 | ||
2571 | There is a potential incompatibility in the behavior of list slices | |
2572 | that are comprised entirely of undefined values. | |
2573 | See L</"Behavior of list slices is more consistent">. | |
2574 | ||
8593bda5 | 2575 | =item Format of $English::PERL_VERSION is different |
7a95317d GS |
2576 | |
2577 | The English module now sets $PERL_VERSION to $^V (a string value) rather | |
2578 | than C<$]> (a numeric value). This is a potential incompatibility. | |
2579 | Send us a report via perlbug if you are affected by this. | |
2580 | ||
2581 | See L</"Improved Perl version numbering system"> for the reasons for | |
2582 | this change. | |
2583 | ||
2584 | =item Literals of the form C<1.2.3> parse differently | |
2585 | ||
2586 | Previously, numeric literals with more than one dot in them were | |
2587 | interpreted as a floating point number concatenated with one or more | |
2588 | numbers. Such "numbers" are now parsed as strings composed of the | |
2589 | specified ordinals. | |
2590 | ||
2591 | For example, C<print 97.98.99> used to output C<97.9899> in earlier | |
2592 | versions, but now prints C<abc>. | |
2593 | ||
2594 | See L</"Support for strings represented as a vector of ordinals">. | |
2595 | ||
2596 | =item Possibly changed pseudo-random number generator | |
2597 | ||
2598 | Perl programs that depend on reproducing a specific set of pseudo-random | |
2599 | numbers may now produce different output due to improvements made to the | |
2600 | rand() builtin. You can use C<sh Configure -Drandfunc=rand> to obtain | |
2601 | the old behavior. | |
2602 | ||
2603 | See L</"Better pseudo-random number generator">. | |
2604 | ||
2605 | =item Hashing function for hash keys has changed | |
2606 | ||
2607 | Even though Perl hashes are not order preserving, the apparently | |
2608 | random order encountered when iterating on the contents of a hash | |
2609 | is actually determined by the hashing algorithm used. Improvements | |
2610 | in the algorithm may yield a random order that is B<different> from | |
2611 | that of previous versions, especially when iterating on hashes. | |
2612 | ||
2613 | See L</"Better worst-case behavior of hashes"> for additional | |
2614 | information. | |
2615 | ||
2616 | =item C<undef> fails on read only values | |
2617 | ||
2618 | Using the C<undef> operator on a readonly value (such as $1) has | |
2619 | the same effect as assigning C<undef> to the readonly value--it | |
2620 | throws an exception. | |
2621 | ||
2622 | =item Close-on-exec bit may be set on pipe and socket handles | |
2623 | ||
2624 | Pipe and socket handles are also now subject to the close-on-exec | |
2625 | behavior determined by the special variable $^F. | |
2626 | ||
2627 | See L</"More consistent close-on-exec behavior">. | |
2628 | ||
2629 | =item Writing C<"$$1"> to mean C<"${$}1"> is unsupported | |
2630 | ||
2631 | Perl 5.004 deprecated the interpretation of C<$$1> and | |
2632 | similar within interpolated strings to mean C<$$ . "1">, | |
2633 | but still allowed it. | |
2634 | ||
2635 | In Perl 5.6.0 and later, C<"$$1"> always means C<"${$1}">. | |
2636 | ||
cb49b31f | 2637 | =item delete(), each(), values() and C<\(%h)> |
551e1d92 | 2638 | |
cb49b31f | 2639 | operate on aliases to values, not copies |
7a95317d | 2640 | |
cb49b31f RB |
2641 | delete(), each(), values() and hashes (e.g. C<\(%h)>) |
2642 | in a list context return the actual | |
7a95317d GS |
2643 | values in the hash, instead of copies (as they used to in earlier |
2644 | versions). Typical idioms for using these constructs copy the | |
2645 | returned values, but this can make a significant difference when | |
2646 | creating references to the returned values. Keys in the hash are still | |
2647 | returned as copies when iterating on a hash. | |
2648 | ||
2649 | See also L</"delete(), each(), values() and hash iteration are faster">. | |
2650 | ||
2651 | =item vec(EXPR,OFFSET,BITS) enforces powers-of-two BITS | |
2652 | ||
2653 | vec() generates a run-time error if the BITS argument is not | |
2654 | a valid power-of-two integer. | |
2655 | ||
2656 | =item Text of some diagnostic output has changed | |
2657 | ||
2658 | Most references to internal Perl operations in diagnostics | |
2659 | have been changed to be more descriptive. This may be an | |
2660 | issue for programs that may incorrectly rely on the exact | |
2661 | text of diagnostics for proper functioning. | |
2662 | ||
2663 | =item C<%@> has been removed | |
2664 | ||
2665 | The undocumented special variable C<%@> that used to accumulate | |
2666 | "background" errors (such as those that happen in DESTROY()) | |
2667 | has been removed, because it could potentially result in memory | |
2668 | leaks. | |
2669 | ||
2670 | =item Parenthesized not() behaves like a list operator | |
a99ba403 | 2671 | |
7a95317d GS |
2672 | The C<not> operator now falls under the "if it looks like a function, |
2673 | it behaves like a function" rule. | |
a99ba403 | 2674 | |
7a95317d GS |
2675 | As a result, the parenthesized form can be used with C<grep> and C<map>. |
2676 | The following construct used to be a syntax error before, but it works | |
2677 | as expected now: | |
a99ba403 | 2678 | |
7a95317d | 2679 | grep not($_), @things; |
a99ba403 | 2680 | |
7a95317d GS |
2681 | On the other hand, using C<not> with a literal list slice may not |
2682 | work. The following previously allowed construct: | |
a99ba403 | 2683 | |
7a95317d | 2684 | print not (1,2,3)[0]; |
a99ba403 | 2685 | |
7a95317d | 2686 | needs to be written with additional parentheses now: |
a99ba403 | 2687 | |
7a95317d | 2688 | print not((1,2,3)[0]); |
a99ba403 | 2689 | |
7a95317d | 2690 | The behavior remains unaffected when C<not> is not followed by parentheses. |
a99ba403 | 2691 | |
7a95317d | 2692 | =item Semantics of bareword prototype C<(*)> have changed |
a99ba403 | 2693 | |
7a95317d GS |
2694 | The semantics of the bareword prototype C<*> have changed. Perl 5.005 |
2695 | always coerced simple scalar arguments to a typeglob, which wasn't useful | |
2696 | in situations where the subroutine must distinguish between a simple | |
2697 | scalar and a typeglob. The new behavior is to not coerce bareword | |
2698 | arguments to a typeglob. The value will always be visible as either | |
2699 | a simple scalar or as a reference to a typeglob. | |
ddda08b7 | 2700 | |
7a95317d | 2701 | See L</"More functional bareword prototype (*)">. |
ddda08b7 | 2702 | |
8593bda5 | 2703 | =item Semantics of bit operators may have changed on 64-bit platforms |
a99ba403 | 2704 | |
7a95317d GS |
2705 | If your platform is either natively 64-bit or if Perl has been |
2706 | configured to used 64-bit integers, i.e., $Config{ivsize} is 8, | |
2707 | there may be a potential incompatibility in the behavior of bitwise | |
2708 | numeric operators (& | ^ ~ << >>). These operators used to strictly | |
2709 | operate on the lower 32 bits of integers in previous versions, but now | |
2710 | operate over the entire native integral width. In particular, note | |
2711 | that unary C<~> will produce different results on platforms that have | |
2712 | different $Config{ivsize}. For portability, be sure to mask off | |
2713 | the excess bits in the result of unary C<~>, e.g., C<~$x & 0xffffffff>. | |
a99ba403 | 2714 | |
7a95317d | 2715 | See L</"Bit operators support full native integer width">. |
a99ba403 | 2716 | |
8593bda5 | 2717 | =item More builtins taint their results |
a99ba403 | 2718 | |
7a95317d GS |
2719 | As described in L</"Improved security features">, there may be more |
2720 | sources of taint in a Perl program. | |
af8c498a | 2721 | |
7a95317d GS |
2722 | To avoid these new tainting behaviors, you can build Perl with the |
2723 | Configure option C<-Accflags=-DINCOMPLETE_TAINTS>. Beware that the | |
2724 | ensuing perl binary may be insecure. | |
af8c498a | 2725 | |
7a95317d | 2726 | =back |
09bef843 | 2727 | |
7a95317d | 2728 | =head2 C Source Incompatibilities |
09bef843 | 2729 | |
7a95317d | 2730 | =over 4 |
09bef843 | 2731 | |
7a95317d | 2732 | =item C<PERL_POLLUTE> |
09bef843 | 2733 | |
7a95317d GS |
2734 | Release 5.005 grandfathered old global symbol names by providing preprocessor |
2735 | macros for extension source compatibility. As of release 5.6.0, these | |
2736 | preprocessor definitions are not available by default. You need to explicitly | |
2737 | compile perl with C<-DPERL_POLLUTE> to get these definitions. For | |
2738 | extensions still using the old symbols, this option can be | |
2739 | specified via MakeMaker: | |
09bef843 | 2740 | |
7a95317d | 2741 | perl Makefile.PL POLLUTE=1 |
09bef843 | 2742 | |
7a95317d | 2743 | =item C<PERL_IMPLICIT_CONTEXT> |
09bef843 | 2744 | |
7a95317d GS |
2745 | This new build option provides a set of macros for all API functions |
2746 | such that an implicit interpreter/thread context argument is passed to | |
2747 | every API function. As a result of this, something like C<sv_setsv(foo,bar)> | |
2748 | amounts to a macro invocation that actually translates to something like | |
2749 | C<Perl_sv_setsv(my_perl,foo,bar)>. While this is generally expected | |
2750 | to not have any significant source compatibility issues, the difference | |
2751 | between a macro and a real function call will need to be considered. | |
09bef843 | 2752 | |
7a95317d GS |
2753 | This means that there B<is> a source compatibility issue as a result of |
2754 | this if your extensions attempt to use pointers to any of the Perl API | |
2755 | functions. | |
eb6e2d6f | 2756 | |
7a95317d GS |
2757 | Note that the above issue is not relevant to the default build of |
2758 | Perl, whose interfaces continue to match those of prior versions | |
2759 | (but subject to the other options described here). | |
eb6e2d6f | 2760 | |
c35f3909 KW |
2761 | |
2762 | See L<perlguts/Background and PERL_IMPLICIT_CONTEXT> for detailed information on the | |
7a95317d | 2763 | ramifications of building Perl with this option. |
ba8251e8 | 2764 | |
7a95317d GS |
2765 | NOTE: PERL_IMPLICIT_CONTEXT is automatically enabled whenever Perl is built |
2766 | with one of -Dusethreads, -Dusemultiplicity, or both. It is not | |
2767 | intended to be enabled by users at this time. | |
a99ba403 | 2768 | |
7a95317d | 2769 | =item C<PERL_POLLUTE_MALLOC> |
27806c82 | 2770 | |
7a95317d GS |
2771 | Enabling Perl's malloc in release 5.005 and earlier caused the namespace of |
2772 | the system's malloc family of functions to be usurped by the Perl versions, | |
2773 | since by default they used the same names. Besides causing problems on | |
2774 | platforms that do not allow these functions to be cleanly replaced, this | |
2775 | also meant that the system versions could not be called in programs that | |
2776 | used Perl's malloc. Previous versions of Perl have allowed this behaviour | |
2777 | to be suppressed with the HIDEMYMALLOC and EMBEDMYMALLOC preprocessor | |
2778 | definitions. | |
3175b8cd | 2779 | |
7a95317d GS |
2780 | As of release 5.6.0, Perl's malloc family of functions have default names |
2781 | distinct from the system versions. You need to explicitly compile perl with | |
2782 | C<-DPERL_POLLUTE_MALLOC> to get the older behaviour. HIDEMYMALLOC | |
2783 | and EMBEDMYMALLOC have no effect, since the behaviour they enabled is now | |
2784 | the default. | |
a99ba403 | 2785 | |
7a95317d GS |
2786 | Note that these functions do B<not> constitute Perl's memory allocation API. |
2787 | See L<perlguts/"Memory Allocation"> for further information about that. | |
a99ba403 | 2788 | |
7a95317d | 2789 | =back |
a99ba403 | 2790 | |
7a95317d | 2791 | =head2 Compatible C Source API Changes |
a99ba403 | 2792 | |
13a2d996 | 2793 | =over 4 |
a99ba403 | 2794 | |
7a95317d | 2795 | =item C<PATCHLEVEL> is now C<PERL_VERSION> |
34d09196 | 2796 | |
7a95317d GS |
2797 | The cpp macros C<PERL_REVISION>, C<PERL_VERSION>, and C<PERL_SUBVERSION> |
2798 | are now available by default from perl.h, and reflect the base revision, | |
2799 | patchlevel, and subversion respectively. C<PERL_REVISION> had no | |
2800 | prior equivalent, while C<PERL_VERSION> and C<PERL_SUBVERSION> were | |
2801 | previously available as C<PATCHLEVEL> and C<SUBVERSION>. | |
34d09196 | 2802 | |
7a95317d GS |
2803 | The new names cause less pollution of the B<cpp> namespace and reflect what |
2804 | the numbers have come to stand for in common practice. For compatibility, | |
2805 | the old names are still supported when F<patchlevel.h> is explicitly | |
2806 | included (as required before), so there is no source incompatibility | |
2807 | from the change. | |
34d09196 | 2808 | |
7a95317d | 2809 | =back |
a99ba403 | 2810 | |
7a95317d | 2811 | =head2 Binary Incompatibilities |
a99ba403 | 2812 | |
7a95317d GS |
2813 | In general, the default build of this release is expected to be binary |
2814 | compatible for extensions built with the 5.005 release or its maintenance | |
2815 | versions. However, specific platforms may have broken binary compatibility | |
2816 | due to changes in the defaults used in hints files. Therefore, please be | |
2817 | sure to always check the platform-specific README files for any notes to | |
2818 | the contrary. | |
a99ba403 | 2819 | |
7a95317d GS |
2820 | The usethreads or usemultiplicity builds are B<not> binary compatible |
2821 | with the corresponding builds in 5.005. | |
a99ba403 | 2822 | |
7a95317d GS |
2823 | On platforms that require an explicit list of exports (AIX, OS/2 and Windows, |
2824 | among others), purely internal symbols such as parser functions and the | |
2825 | run time opcodes are not exported by default. Perl 5.005 used to export | |
2826 | all functions irrespective of whether they were considered part of the | |
2827 | public API or not. | |
a99ba403 | 2828 | |
7a95317d | 2829 | For the full list of public API functions, see L<perlapi>. |
3175b8cd | 2830 | |
fc641c2d JH |
2831 | =head1 Known Problems |
2832 | ||
227e8dd4 | 2833 | =head2 Thread test failures |
fc641c2d | 2834 | |
97017a80 | 2835 | The subtests 19 and 20 of lib/thr5005.t test are known to fail due to |
227e8dd4 GS |
2836 | fundamental problems in the 5.005 threading implementation. These are |
2837 | not new failures--Perl 5.005_0x has the same bugs, but didn't have these | |
2838 | tests. | |
fc641c2d JH |
2839 | |
2840 | =head2 EBCDIC platforms not supported | |
2841 | ||
227e8dd4 GS |
2842 | In earlier releases of Perl, EBCDIC environments like OS390 (also |
2843 | known as Open Edition MVS) and VM-ESA were supported. Due to changes | |
2844 | required by the UTF-8 (Unicode) support, the EBCDIC platforms are not | |
2845 | supported in Perl 5.6.0. | |
fc641c2d | 2846 | |
d57b1ce7 GS |
2847 | =head2 In 64-bit HP-UX the lib/io_multihomed test may hang |
2848 | ||
2849 | The lib/io_multihomed test may hang in HP-UX if Perl has been | |
2850 | configured to be 64-bit. Because other 64-bit platforms do not | |
2851 | hang in this test, HP-UX is suspect. All other tests pass | |
2852 | in 64-bit HP-UX. The test attempts to create and connect to | |
2853 | "multihomed" sockets (sockets which have multiple IP addresses). | |
2854 | ||
f46deeb4 JH |
2855 | =head2 NEXTSTEP 3.3 POSIX test failure |
2856 | ||
2857 | In NEXTSTEP 3.3p2 the implementation of the strftime(3) in the | |
2858 | operating system libraries is buggy: the %j format numbers the days of | |
2859 | a month starting from zero, which, while being logical to programmers, | |
2860 | will cause the subtests 19 to 27 of the lib/posix test may fail. | |
2861 | ||
2cae8c0d JH |
2862 | =head2 Tru64 (aka Digital UNIX, aka DEC OSF/1) lib/sdbm test failure with gcc |
2863 | ||
2864 | If compiled with gcc 2.95 the lib/sdbm test will fail (dump core). | |
2865 | The cure is to use the vendor cc, it comes with the operating system | |
2866 | and produces good code. | |
2867 | ||
fc641c2d JH |
2868 | =head2 UNICOS/mk CC failures during Configure run |
2869 | ||
2870 | In UNICOS/mk the following errors may appear during the Configure run: | |
2871 | ||
2872 | Guessing which symbols your C compiler and preprocessor define... | |
2873 | CC-20 cc: ERROR File = try.c, Line = 3 | |
2874 | ... | |
2875 | bad switch yylook 79bad switch yylook 79bad switch yylook 79bad switch yylook 79#ifdef A29K | |
2876 | ... | |
2877 | 4 errors detected in the compilation of "try.c". | |
2878 | ||
2879 | The culprit is the broken awk of UNICOS/mk. The effect is fortunately | |
2880 | rather mild: Perl itself is not adversely affected by the error, only | |
2881 | the h2ph utility coming with Perl, and that is rather rarely needed | |
2882 | these days. | |
2883 | ||
14190b26 GS |
2884 | =head2 Arrow operator and arrays |
2885 | ||
2886 | When the left argument to the arrow operator C<< -> >> is an array, or | |
2887 | the C<scalar> operator operating on an array, the result of the | |
2888 | operation must be considered erroneous. For example: | |
2889 | ||
2890 | @x->[2] | |
2891 | scalar(@x)->[2] | |
2892 | ||
2893 | These expressions will get run-time errors in some future release of | |
2894 | Perl. | |
2895 | ||
4bca7e4f | 2896 | =head2 Experimental features |
fc641c2d | 2897 | |
227e8dd4 GS |
2898 | As discussed above, many features are still experimental. Interfaces and |
2899 | implementation of these features are subject to change, and in extreme cases, | |
2900 | even subject to removal in some future release of Perl. These features | |
2901 | include the following: | |
fc641c2d JH |
2902 | |
2903 | =over 4 | |
2904 | ||
2905 | =item Threads | |
2906 | ||
2907 | =item Unicode | |
2908 | ||
4bca7e4f GS |
2909 | =item 64-bit support |
2910 | ||
fc641c2d JH |
2911 | =item Lvalue subroutines |
2912 | ||
2913 | =item Weak references | |
2914 | ||
4bca7e4f | 2915 | =item The pseudo-hash data type |
fc641c2d JH |
2916 | |
2917 | =item The Compiler suite | |
2918 | ||
4bca7e4f GS |
2919 | =item Internal implementation of file globbing |
2920 | ||
227e8dd4 | 2921 | =item The DB module |
fc641c2d | 2922 | |
cb49b31f RB |
2923 | =item The regular expression code constructs: |
2924 | ||
2925 | C<(?{ code })> and C<(??{ code })> | |
fc641c2d JH |
2926 | |
2927 | =back | |
2928 | ||
7a95317d GS |
2929 | =head1 Obsolete Diagnostics |
2930 | ||
2931 | =over 4 | |
2932 | ||
2933 | =item Character class syntax [: :] is reserved for future extensions | |
2934 | ||
2935 | (W) Within regular expression character classes ([]) the syntax beginning | |
2936 | with "[:" and ending with ":]" is reserved for future extensions. | |
2937 | If you need to represent those character sequences inside a regular | |
2938 | expression character class, just quote the square brackets with the | |
2939 | backslash: "\[:" and ":\]". | |
2940 | ||
2941 | =item Ill-formed logical name |%s| in prime_env_iter | |
2942 | ||
2943 | (W) A warning peculiar to VMS. A logical name was encountered when preparing | |
2944 | to iterate over %ENV which violates the syntactic rules governing logical | |
2945 | names. Because it cannot be translated normally, it is skipped, and will not | |
2946 | appear in %ENV. This may be a benign occurrence, as some software packages | |
2947 | might directly modify logical name tables and introduce nonstandard names, | |
2948 | or it may indicate that a logical name table has been corrupted. | |
2949 | ||
8593bda5 GS |
2950 | =item In string, @%s now must be written as \@%s |
2951 | ||
2952 | The description of this error used to say: | |
2953 | ||
2954 | (Someday it will simply assume that an unbackslashed @ | |
2955 | interpolates an array.) | |
2956 | ||
2957 | That day has come, and this fatal error has been removed. It has been | |
2958 | replaced by a non-fatal warning instead. | |
2959 | See L</Arrays now always interpolate into double-quoted strings> for | |
2960 | details. | |
2961 | ||
7a95317d GS |
2962 | =item Probable precedence problem on %s |
2963 | ||
2964 | (W) The compiler found a bareword where it expected a conditional, | |
2965 | which often indicates that an || or && was parsed as part of the | |
2966 | last argument of the previous construct, for example: | |
2967 | ||
2968 | open FOO || die; | |
2969 | ||
2970 | =item regexp too big | |
2971 | ||
2972 | (F) The current implementation of regular expressions uses shorts as | |
2973 | address offsets within a string. Unfortunately this means that if | |
2974 | the regular expression compiles to longer than 32767, it'll blow up. | |
2975 | Usually when you want a regular expression this big, there is a better | |
2976 | way to do it with multiple statements. See L<perlre>. | |
2977 | ||
2978 | =item Use of "$$<digit>" to mean "${$}<digit>" is deprecated | |
2979 | ||
2980 | (D) Perl versions before 5.004 misinterpreted any type marker followed | |
2981 | by "$" and a digit. For example, "$$0" was incorrectly taken to mean | |
2982 | "${$}0" instead of "${$0}". This bug is (mostly) fixed in Perl 5.004. | |
2983 | ||
2984 | However, the developers of Perl 5.004 could not fix this bug completely, | |
2985 | because at least two widely-used modules depend on the old meaning of | |
2986 | "$$0" in a string. So Perl 5.004 still interprets "$$<digit>" in the | |
2987 | old (broken) way inside strings; but it generates this message as a | |
2988 | warning. And in Perl 5.005, this special treatment will cease. | |
2989 | ||
2990 | =back | |
2991 | ||
2992 | =head1 Reporting Bugs | |
ba8251e8 | 2993 | |
437784d6 | 2994 | If you find what you think is a bug, you might check the |
14218588 | 2995 | articles recently posted to the comp.lang.perl.misc newsgroup. |
f224927c | 2996 | There may also be information at http://www.perl.com/perl/ , the Perl |
ba8251e8 GS |
2997 | Home Page. |
2998 | ||
2999 | If you believe you have an unreported bug, please run the B<perlbug> | |
642f9deb | 3000 | program included with your release. Be sure to trim your bug down |
ba8251e8 | 3001 | to a tiny but sufficient test case. Your bug report, along with the |
7f2de2d2 | 3002 | output of C<perl -V>, will be sent off to perlbug@perl.org to be |
ba8251e8 GS |
3003 | analysed by the Perl porting team. |
3004 | ||
3005 | =head1 SEE ALSO | |
3006 | ||
3007 | The F<Changes> file for exhaustive details on what changed. | |
3008 | ||
3009 | The F<INSTALL> file for how to build Perl. | |
3010 | ||
3011 | The F<README> file for general stuff. | |
3012 | ||
3013 | The F<Artistic> and F<Copying> files for copyright information. | |
3014 | ||
3015 | =head1 HISTORY | |
3016 | ||
a5222a85 GS |
3017 | Written by Gurusamy Sarathy <F<gsar@activestate.com>>, with many |
3018 | contributions from The Perl Porters. | |
ba8251e8 | 3019 | |
7f2de2d2 | 3020 | Send omissions or corrections to <F<perlbug@perl.org>>. |
ba8251e8 GS |
3021 | |
3022 | =cut |