Commit | Line | Data |
---|---|---|
ba8251e8 GS |
1 | =head1 NAME |
2 | ||
a5222a85 | 3 | perldelta - what's new for perl v5.6 (as of v5.005_62) |
ba8251e8 GS |
4 | |
5 | =head1 DESCRIPTION | |
6 | ||
f29c64d6 GS |
7 | This is an unsupported alpha release, meant for intrepid Perl developers |
8 | only. The included sources may not even build correctly on some platforms. | |
9 | Subscribing to perl5-porters is the best way to monitor and contribute | |
10 | to the progress of development releases (see www.perl.org for info). | |
11 | ||
ba8251e8 GS |
12 | This document describes differences between the 5.005 release and this one. |
13 | ||
14 | =head1 Incompatible Changes | |
15 | ||
e02fdbd2 GS |
16 | =head2 Perl Source Incompatibilities |
17 | ||
a5222a85 GS |
18 | Beware that any new warnings that have been added are B<not> considered |
19 | incompatible changes. | |
20 | ||
21 | Since all new warnings must be explicitly requested via the C<-w> | |
22 | switch or the C<warnings> pragma, it is ultimately the programmer's | |
23 | responsibility to ensure that warnings are enabled judiciously. | |
e02fdbd2 | 24 | |
757edf6f AD |
25 | =over 4 |
26 | ||
08cd8952 GS |
27 | =item Treatment of list slices of undef has changed |
28 | ||
29 | When taking a slice of a literal list (as opposed to a slice of | |
30 | an array or hash), Perl used to return an empty list if the | |
31 | result happened to be composed of all undef values. | |
32 | ||
33 | The new behavior is to produce an empty list if (and only if) | |
34 | the original list was empty. Consider the following example: | |
35 | ||
36 | @a = (1,undef,undef,2)[2,1,2]; | |
37 | ||
38 | The old behavior would have resulted in @a having no elements. | |
39 | The new behavior ensures it has three undefined elements. | |
40 | ||
41 | Note in particular that the behavior of slices of the following | |
42 | cases remains unchanged: | |
43 | ||
44 | @a = ()[1,2]; | |
45 | @a = (getpwent)[7,0]; | |
46 | @a = (anything_returning_empty_list())[2,1,2]; | |
47 | @a = @b[2,1,2]; | |
48 | @a = @c{'a','b','c'}; | |
49 | ||
50 | See L<perldata>. | |
51 | ||
757edf6f AD |
52 | =item Possibly changed pseudo-random number generator |
53 | ||
54 | In 5.005_0x and earlier, perl's rand() function used the C library | |
55 | rand(3) function. As of 5.005_52, Configure tests for drand48(), | |
56 | random(), and rand() (in that order) and picks the first one it finds. | |
57 | Perl programs that depend on reproducing a specific set of pseudo-random | |
58 | numbers will now likely produce different output. | |
59 | ||
a5222a85 GS |
60 | =item Hashing function for hash keys has changed |
61 | ||
62 | Perl hashes are not order preserving. The apparently random order | |
63 | encountered when iterating on the contents of a hash is determined | |
64 | by the hashing algorithm used. To improve the distribution of lower | |
65 | bits in the hashed value, the algorithm has changed slightly as of | |
66 | 5.005_52. When iterating over hashes, this may yield a random order | |
67 | that is B<different> from that of previous versions. | |
68 | ||
69 | =item C<undef> fails on read only values | |
70 | ||
71 | Using the C<undef> operator on a readonly value (such as $1) has | |
72 | the same effect as assigning C<undef> to the readonly value--it | |
73 | throws an exception. | |
74 | ||
75 | =item Close-on-exec bit may be set on pipe() handles | |
76 | ||
77 | On systems that support a close-on-exec flag on filehandles, the | |
78 | flag will be set for any handles created by pipe(), if that is | |
79 | warranted by the value of $^F that may be in effect. Earlier | |
80 | versions neglected to set the flag for handles created with | |
81 | pipe(). See L<perlfunc/pipe> and L<perlvar/$^F>. | |
82 | ||
83 | =item Writing C<"$$1"> to mean C<"${$}1"> is unsupported | |
84 | ||
85 | Perl 5.004 deprecated the interpretation of C<$$1> and | |
86 | similar within interpolated strings to mean C<$$ . "1">, | |
87 | but still allowed it. | |
88 | ||
89 | In Perl 5.6 and later, C<"$$1"> always means C<"${$1}">. | |
90 | ||
91 | =item values(%h) and C<\(%h)> operate on aliases to values, not copies | |
92 | ||
93 | each(), values() and hashes in a list context return the actual | |
94 | values in the hash, instead of copies (as they used to in earlier | |
95 | versions). Typical idioms for using these constructs copy the | |
96 | returned values, but this is can make a significant difference when | |
97 | creating references to the returned values. | |
98 | ||
99 | Keys in the hash are still returned as copies when iterating on | |
08cd8952 | 100 | a hash. |
a5222a85 GS |
101 | |
102 | =item vec(EXPR,OFFSET,BITS) enforces powers-of-two BITS | |
103 | ||
08cd8952 | 104 | vec() generates a run-time error if the BITS argument is not |
a5222a85 GS |
105 | a valid power-of-two integer. |
106 | ||
107 | =item Text of some diagnostic output has changed | |
108 | ||
109 | Most references to internal Perl operations in diagnostics | |
110 | have been changed to be more descriptive. This may be an | |
111 | issue for programs that may incorrectly rely on the exact | |
112 | text of diagnostics for proper functioning. | |
113 | ||
114 | =item C<%@> has been removed | |
115 | ||
116 | The undocumented special variable C<%@> that used to accumulate | |
117 | "background" errors (such as those that happen in DESTROY()) | |
118 | has been removed, because it could potentially result in memory | |
119 | leaks. | |
120 | ||
757edf6f AD |
121 | =back |
122 | ||
e02fdbd2 GS |
123 | =head2 C Source Incompatibilities |
124 | ||
125 | =over 4 | |
126 | ||
127 | =item C<PERL_POLLUTE> | |
128 | ||
129 | Release 5.005 grandfathered old global symbol names by providing preprocessor | |
87275199 | 130 | macros for extension source compatibility. As of release 5.6, these |
e02fdbd2 | 131 | preprocessor definitions are not available by default. You need to explicitly |
14218588 GS |
132 | compile perl with C<-DPERL_POLLUTE> to get these definitions. For |
133 | extensions still using the old symbols, this option can be | |
2aea4d40 JD |
134 | specified via MakeMaker: |
135 | ||
14218588 | 136 | perl Makefile.PL POLLUTE=1 |
e02fdbd2 | 137 | |
f29c64d6 GS |
138 | =item C<PERL_IMPLICIT_CONTEXT> |
139 | ||
140 | This new build option provides a set of macros for all API functions | |
141 | such that an implicit interpreter/thread context argument is passed to | |
142 | every API function. As a result of this, something like C<sv_setsv(foo,bar)> | |
2c2d71f5 | 143 | amounts to a macro invocation that actually translates to something like |
f29c64d6 GS |
144 | C<Perl_sv_setsv(my_perl,foo,bar)>. While this is generally expected |
145 | to not have any significant source compatibility issues, the difference | |
146 | between a macro and a real function call will need to be considered. | |
147 | ||
2c2d71f5 JH |
148 | This means that there B<is> a source compatibility issue as a result of |
149 | this if your extensions attempt to use pointers to any of the Perl API | |
150 | functions. | |
151 | ||
f29c64d6 GS |
152 | Note that the above issue is not relevant to the default build of |
153 | Perl, whose interfaces continue to match those of prior versions | |
154 | (but subject to the other options described here). | |
155 | ||
651a3225 GS |
156 | PERL_IMPLICIT_CONTEXT is automatically enabled whenever Perl is built |
157 | with one of -Dusethreads, -Dusemultiplicity, or both. | |
f29c64d6 | 158 | |
2c2d71f5 JH |
159 | See L<perlguts/"The Perl API"> for detailed information on the |
160 | ramifications of building Perl using this option. | |
161 | ||
86058a2d GS |
162 | =item C<PERL_POLLUTE_MALLOC> |
163 | ||
14218588 | 164 | Enabling Perl's malloc in release 5.005 and earlier caused |
86058a2d | 165 | the namespace of system versions of the malloc family of functions to |
14218588 GS |
166 | be usurped by the Perl versions, since by default they used the |
167 | same names. | |
86058a2d GS |
168 | |
169 | Besides causing problems on platforms that do not allow these functions to | |
170 | be cleanly replaced, this also meant that the system versions could not | |
171 | be called in programs that used Perl's malloc. Previous versions of Perl | |
14218588 | 172 | have allowed this behaviour to be suppressed with the HIDEMYMALLOC and |
86058a2d GS |
173 | EMBEDMYMALLOC preprocessor definitions. |
174 | ||
87275199 | 175 | As of release 5.6, Perl's malloc family of functions have default names |
86058a2d | 176 | distinct from the system versions. You need to explicitly compile perl with |
14218588 GS |
177 | C<-DPERL_POLLUTE_MALLOC> to get the older behaviour. HIDEMYMALLOC |
178 | and EMBEDMYMALLOC have no effect, since the behaviour they enabled is now | |
86058a2d GS |
179 | the default. |
180 | ||
181 | Note that these functions do B<not> constitute Perl's memory allocation API. | |
182 | See L<perlguts/"Memory Allocation"> for further information about that. | |
183 | ||
e02fdbd2 GS |
184 | =item C<PL_na> and C<dTHR> Issues |
185 | ||
186 | The C<PL_na> global is now thread local, so a C<dTHR> declaration is needed | |
14218588 | 187 | in the scope in which the global appears. XSUBs should handle this automatically, |
e02fdbd2 GS |
188 | but if you have used C<PL_na> in support functions, you either need to |
189 | change the C<PL_na> to a local variable (which is recommended), or put in | |
190 | a C<dTHR>. | |
191 | ||
192 | =back | |
193 | ||
cceca5ed GS |
194 | =head2 Compatible C Source API Changes |
195 | ||
196 | =over | |
197 | ||
198 | =item C<PATCHLEVEL> is now C<PERL_VERSION> | |
199 | ||
14218588 | 200 | The cpp macros C<PERL_REVISION>, C<PERL_VERSION>, and C<PERL_SUBVERSION> |
cceca5ed | 201 | are now available by default from perl.h, and reflect the base revision, |
14218588 | 202 | patchlevel, and subversion respectively. C<PERL_REVISION> had no |
cceca5ed GS |
203 | prior equivalent, while C<PERL_VERSION> and C<PERL_SUBVERSION> were |
204 | previously available as C<PATCHLEVEL> and C<SUBVERSION>. | |
205 | ||
14218588 | 206 | The new names cause less pollution of the B<cpp> namespace and reflect what |
cceca5ed | 207 | the numbers have come to stand for in common practice. For compatibility, |
14218588 | 208 | the old names are still supported when F<patchlevel.h> is explicitly |
cceca5ed | 209 | included (as required before), so there is no source incompatibility |
14218588 | 210 | from the change. |
cceca5ed | 211 | |
a5222a85 GS |
212 | =item Support for C++ exceptions |
213 | ||
214 | change#3386, also needs perlguts documentation | |
215 | [TODO - Chip Salzenberg <chip@perlsupport.com>] | |
216 | ||
cceca5ed GS |
217 | =back |
218 | ||
e02fdbd2 GS |
219 | =head2 Binary Incompatibilities |
220 | ||
9c107f78 JH |
221 | The default build of this release is binary compatible with the 5.005 |
222 | release or its maintenance versions. | |
f29c64d6 GS |
223 | |
224 | The usethreads or usemultiplicity builds are B<not> binary compatible | |
225 | with the corresponding builds in 5.005. | |
e02fdbd2 | 226 | |
a5222a85 GS |
227 | =head1 Installation and Configuration Improvements |
228 | ||
229 | =head2 New Configure flags | |
230 | ||
231 | The following new flags may be enabled on the Configure command line | |
232 | by running Configure with C<-Dflag>. | |
233 | ||
234 | usemultiplicity | |
67d3893f JH |
235 | |
236 | uselongdouble | |
a5222a85 GS |
237 | usemorebits |
238 | uselargefiles | |
a5222a85 | 239 | |
67d3893f JH |
240 | =head2 -Dusethreads and -Duse64bits now more daring |
241 | ||
242 | The Configure options enabling the use of threads and the use of | |
243 | 64-bitness are now more daring in the sense that they no more have | |
244 | an explicit list of operating systems of known threads/64-bit | |
245 | capabilities. In other words: if your operating system has the | |
246 | necessary APIs, you should be able just to go ahead and use them. | |
247 | See also L<"64-bit support">. | |
248 | ||
249 | =head2 Long Doubles | |
250 | ||
251 | Some platforms have "long doubles", floating point numbers of even | |
252 | larger range than ordinary "doubles". To enable using ng doubles for | |
253 | Perl's scalars, use -Duselongdouble. | |
254 | ||
255 | =head2 -Dusemorebits | |
256 | ||
257 | You can enable both -Duse64bits and -Dlongdouble by -Dusemorebits. | |
258 | See also L<"64-bit support">. | |
259 | ||
260 | =head2 -Duselargefiles | |
261 | ||
262 | Some platforms support large files, files larger than two gigabytes. | |
263 | See L<"Large file support"> for more information. | |
a5222a85 GS |
264 | |
265 | =head2 installusrbinperl | |
266 | ||
267 | You can use "Configure -Uinstallusrbinperl" which causes installperl | |
268 | to skip installing perl also as /usr/bin/perl. This is useful if you | |
269 | prefer not to modify /usr/bin for some reason or another but harmful | |
270 | because many scripts assume to find Perl in /usr/bin/perl. | |
271 | ||
272 | =head2 SOCKS support | |
273 | ||
274 | You can use "Configure -Dusesocks" which causes Perl to probe | |
275 | for the SOCKS proxy protocol library, http://www.socks.nec.com/ | |
276 | ||
277 | =head2 C<-A> flag | |
278 | ||
279 | You can "post-edit" the Configure variables using the Configure C<-A> | |
280 | flag. The editing happens immediately after the platform specific | |
281 | hints files have been processed but before the actual configuration | |
282 | process starts. Run C<Configure -h> to find out the full C<-A> syntax. | |
283 | ||
67d3893f JH |
284 | =head2 New Installation Scheme |
285 | ||
286 | vendorprefix et al | |
287 | [TODO - Andy Dougherty <doughera@lafcol.lafayette.edu>] | |
288 | ||
ba8251e8 GS |
289 | =head1 Core Changes |
290 | ||
9d73390d GS |
291 | =head2 Unicode and UTF-8 support |
292 | ||
293 | Perl can optionally use UTF-8 as its internal representation for character | |
a5222a85 | 294 | strings. The C<utf8> pragma enables this support in the current lexical |
9d73390d GS |
295 | scope. See L<utf8> for more information. |
296 | ||
297 | =head2 Lexically scoped warning categories | |
298 | ||
299 | You can now control the granularity of warnings emitted by perl at a finer | |
4438c4b7 | 300 | level using the C<use warnings> pragma. See L<warnings> and L<perllexwarn> |
0453d815 | 301 | for details. |
9d73390d | 302 | |
a5222a85 GS |
303 | =head2 Lvalue subroutines |
304 | ||
305 | WARNING: This is an experimental feature. | |
306 | ||
307 | change#4081 | |
308 | [TODO - Ilya Zakharevich <ilya@math.ohio-state.edu>, | |
309 | Tuomas Lukka <lukka@fas.harvard.edu>)] | |
310 | ||
311 | =head2 "our" declarations | |
312 | ||
313 | An "our" declaration introduces a value that can be best understood | |
314 | as a lexically scoped symbolic alias to a global variable in the | |
315 | current package. This is mostly useful as an alternative to the | |
316 | C<vars> pragma, but also provides the opportunity to introduce | |
317 | typing and other attributes for such variables. See L<perlfunc/our>. | |
318 | ||
319 | =head2 Weak references | |
320 | ||
321 | WARNING: This is an experimental feature. | |
322 | ||
323 | change#3385, also need perlguts documentation | |
324 | ||
325 | [TODO - Tuomas Lukka <lukka@fas.harvard.edu>] | |
326 | ||
5fdc711f GS |
327 | =head2 Binary numbers supported |
328 | ||
4f19785b WSI |
329 | Binary numbers are now supported as literals, in s?printf formats, and |
330 | C<oct()>: | |
331 | ||
14218588 GS |
332 | $answer = 0b101010; |
333 | printf "The answer is: %b\n", oct("0b101010"); | |
4f19785b | 334 | |
a5222a85 GS |
335 | =head2 Some arrows may be omitted in calls through references |
336 | ||
337 | Perl now allows the arrow to be omitted in many constructs | |
338 | involving subroutine calls through references. For example, | |
339 | C<$foo[10]->('foo')> may now be written C<$foo[10]('foo')>. | |
340 | This is rather similar to how the arrow may be omitted from | |
341 | C<$foo[10]->{'foo'}>. Note however, that the arrow is still | |
342 | required for C<foo(10)->('bar')>. | |
343 | ||
5fdc711f GS |
344 | =head2 syswrite() ease-of-use |
345 | ||
a5222a85 GS |
346 | The length argument of C<syswrite()> has become optional. |
347 | ||
348 | =head2 Filehandles can be autovivified | |
349 | ||
350 | The construct C<open(my $fh, ...)> can be used to create filehandles | |
351 | more easily. The filehandle will be automatically closed at the end | |
352 | of the scope of $fh, provided there are no other references to it. This | |
353 | largely eliminates the need for typeglobs when opening filehandles | |
354 | that must be passed around, as in the following example: | |
355 | ||
356 | sub myopen { | |
357 | open my $fh, "@_" | |
358 | or die "Can't open '@_': $!"; | |
359 | return $fh; | |
360 | } | |
361 | ||
362 | { | |
363 | my $f = myopen("</etc/motd"); | |
364 | print <$f>; | |
365 | # $f implicitly closed here | |
366 | } | |
367 | ||
368 | [TODO - this idiom needs more pod penetration] | |
6c67e1bb | 369 | |
5fdc711f GS |
370 | =head2 64-bit support |
371 | ||
9c107f78 JH |
372 | All platforms that have 64-bit integers either (a) natively as longs |
373 | or ints (b) via special compiler flags (c) using long long are able to | |
374 | use "quads" (64-integers) as follows: | |
375 | ||
376 | =over 4 | |
377 | ||
a5222a85 GS |
378 | =item * |
379 | ||
380 | constants (decimal, hexadecimal, octal, binary) in the code | |
381 | ||
382 | =item * | |
9c107f78 | 383 | |
a5222a85 | 384 | arguments to oct() and hex() |
9c107f78 | 385 | |
a5222a85 GS |
386 | =item * |
387 | ||
388 | arguments to print(), printf() and sprintf() (flag prefixes ll, L, q) | |
389 | ||
390 | =item * | |
9c107f78 | 391 | |
a5222a85 | 392 | printed as such |
9c107f78 | 393 | |
a5222a85 GS |
394 | =item * |
395 | ||
396 | pack() and unpack() "q" and "Q" formats | |
397 | ||
398 | =item * | |
399 | ||
400 | in basic arithmetics: + - * / % | |
401 | ||
402 | =item * | |
1fad5d67 | 403 | |
a5222a85 | 404 | vec() (but see the below note about bit arithmetics) |
9c107f78 JH |
405 | |
406 | =back | |
407 | ||
408 | Note that unless you have the case (a) you will have to configure | |
409 | and compile Perl using the -Duse64bits Configure flag. | |
410 | ||
3175b8cd JH |
411 | Unfortunately bit arithmetics (&, |, ^, ~, <<, >>) for numbers are not |
412 | 64-bit clean, they are explictly forced to be 32-bit. Bit arithmetics | |
413 | for bit vectors (created by vec()) are not limited in their width. | |
d0ba1bd2 | 414 | |
2d4389e4 | 415 | Last but not least: note that due to Perl's habit of always using |
d0ba1bd2 JH |
416 | floating point numbers the quads are still not true integers. |
417 | When quads overflow their limits (0...18_446_744_073_709_551_615 unsigned, | |
418 | -9_223_372_036_854_775_808...9_223_372_036_854_775_807 signed), they | |
419 | are silently promoted to floating point numbers, after which they will | |
420 | start losing precision (their lower digits). | |
2d4389e4 JH |
421 | |
422 | =head2 Large file support | |
423 | ||
424 | If you have filesystems that support "large files" (files larger than | |
aa855319 | 425 | 2 gigabytes), you may now also be able to create and access them from |
249b38c6 JH |
426 | Perl. You have to use Configure -Duselargefiles. Turning on the |
427 | large file support turns on also the 64-bit support, for obvious reasons. | |
2d4389e4 | 428 | |
eed7fde4 JH |
429 | Note that in addition to requiring a proper file system to do large |
430 | files you may also need to adjust your per-process (or your | |
431 | per-system, or per-process-group, or per-user-group) maximum filesize | |
432 | limits before running Perl scripts that try to handle large files, | |
433 | especially if you intend to write such files. | |
434 | ||
435 | Finally, in addition to your process/process group maximum filesize | |
436 | limits, you may have quota limits on your filesystems that stop you | |
437 | (your user id or your user group id) from using large files. | |
438 | ||
439 | Adjusting your process/user/group/file system/operating system limits | |
440 | is outside the scope of Perl core language. For process limits, you | |
441 | may try increasing the limits using your shell's limits/limit/ulimit | |
442 | command before running Perl. The BSD::Resource extension (not | |
443 | included with the standard Perl distribution) may also be of use, it | |
444 | offers the getrlimit/setrlimit interface that can be used to adjust | |
445 | process resource usage limits, including the maximum filesize limit. | |
2d4389e4 | 446 | |
aa855319 JH |
447 | =head2 Long doubles |
448 | ||
449 | In some systems you may be able to use long doubles to enhance the | |
450 | range of precision of your double precision floating point numbers | |
451 | (that is, Perl's numbers). Use Configure -Duselongdouble to enable | |
452 | this support (if it is available). | |
453 | ||
454 | =head2 "more bits" | |
455 | ||
456 | You can Configure -Dusemorebits to turn on both the 64-bit support | |
457 | and the long double support. | |
09bef843 | 458 | |
62c18ce2 GS |
459 | =head2 Better syntax checks on parenthesized unary operators |
460 | ||
461 | Expressions such as: | |
462 | ||
14218588 GS |
463 | print defined(&foo,&bar,&baz); |
464 | print uc("foo","bar","baz"); | |
465 | undef($foo,&bar); | |
62c18ce2 | 466 | |
7711098a | 467 | used to be accidentally allowed in earlier versions, and produced |
14218588 GS |
468 | unpredictable behaviour. Some produced ancillary warnings |
469 | when used in this way; others silently did the wrong thing. | |
62c18ce2 GS |
470 | |
471 | The parenthesized forms of most unary operators that expect a single | |
14218588 GS |
472 | argument now ensure that they are not called with more than one |
473 | argument, making the cases shown above syntax errors. The usual | |
474 | behaviour of: | |
62c18ce2 | 475 | |
14218588 GS |
476 | print defined &foo, &bar, &baz; |
477 | print uc "foo", "bar", "baz"; | |
478 | undef $foo, &bar; | |
62c18ce2 GS |
479 | |
480 | remains unchanged. See L<perlop>. | |
481 | ||
3e3318e7 GS |
482 | =head2 POSIX character class syntax [: :] supported |
483 | ||
484 | For example to match alphabetic characters use /[[:alpha:]]/. | |
485 | See L<perlre> for details. | |
486 | ||
5a929a98 | 487 | =head2 Improved C<qw//> operator |
8127e0e3 | 488 | |
26ef7447 GS |
489 | The C<qw//> operator is now evaluated at compile time into a true list |
490 | instead of being replaced with a run time call to C<split()>. This | |
14218588 GS |
491 | removes the confusing misbehaviour of C<qw//> in scalar context, which |
492 | had inherited that behaviour from split(). | |
26ef7447 GS |
493 | |
494 | Thus: | |
495 | ||
496 | $foo = ($bar) = qw(a b c); print "$foo|$bar\n"; | |
497 | ||
498 | now correctly prints "3|a", instead of "2|a". | |
8127e0e3 | 499 | |
5a929a98 VU |
500 | =head2 pack() format 'Z' supported |
501 | ||
502 | The new format type 'Z' is useful for packing and unpacking null-terminated | |
503 | strings. See L<perlfunc/"pack">. | |
504 | ||
4d0c1c44 | 505 | =head2 pack() format modifier '!' supported |
ee3907e2 | 506 | |
14218588 | 507 | The new format type modifier '!' is useful for packing and unpacking |
ee3907e2 JH |
508 | native shorts, ints, and longs. See L<perlfunc/"pack">. |
509 | ||
f29c64d6 GS |
510 | =head2 pack() and unpack() support counted strings |
511 | ||
a5222a85 | 512 | The template character '/' can be used to specify a counted string |
f29c64d6 GS |
513 | type to be packed or unpacked. See L<perlfunc/"pack">. |
514 | ||
a5222a85 GS |
515 | =head2 Comments in pack() templates |
516 | ||
517 | The '#' character in a template introduces a comment up to | |
518 | end of the line. This facilitates documentation of pack() | |
519 | templates. | |
520 | ||
2b92dfce GS |
521 | =head2 $^X variables may now have names longer than one character |
522 | ||
523 | Formerly, $^X was synonymous with ${"\cX"}, but $^XY was a syntax | |
524 | error. Now variable names that begin with a control character may be | |
525 | arbitrarily long. However, for compatibility reasons, these variables | |
526 | I<must> be written with explicit braces, as C<${^XY}> for example. | |
14218588 | 527 | C<${^XYZ}> is synonymous with ${"\cXYZ"}. Variable names with more |
2b92dfce GS |
528 | than one control character, such as C<${^XY^Z}>, are illegal. |
529 | ||
14218588 GS |
530 | The old syntax has not changed. As before, `^X' may be either a |
531 | literal control-X character or the two-character sequence `caret' plus | |
532 | `X'. When braces are omitted, the variable name stops after the | |
2b92dfce | 533 | control character. Thus C<"$^XYZ"> continues to be synonymous with |
7711098a | 534 | C<$^X . "YZ"> as before. |
2b92dfce GS |
535 | |
536 | As before, lexical variables may not have names beginning with control | |
537 | characters. As before, variables whose names begin with a control | |
14218588 GS |
538 | character are always forced to be in package `main'. All such variables |
539 | are reserved for future extensions, except those that begin with | |
09bef843 | 540 | C<^_>, which may be used by user programs and are guaranteed not to |
14218588 | 541 | acquire special meaning in any future version of Perl. |
2b92dfce | 542 | |
09bef843 SB |
543 | =head2 C<use attrs> implicit in subroutine attributes |
544 | ||
545 | Formerly, if you wanted to mark a subroutine as being a method call or | |
546 | as requiring an automatic lock() when it is entered, you had to declare | |
547 | that with a C<use attrs> pragma in the body of the subroutine. | |
548 | That can now be accomplished with a declaration syntax, like this: | |
549 | ||
550 | sub mymethod : locked, method ; | |
551 | ... | |
552 | sub mymethod : locked, method { | |
553 | ... | |
554 | } | |
555 | ||
556 | F<AutoSplit.pm> and F<SelfLoader.pm> have been updated to keep the attributes | |
557 | with the stubs they provide. See L<attributes>. | |
558 | ||
a5222a85 GS |
559 | =head2 Regular expression improvements |
560 | ||
561 | change#2827,2373,2372,2365,1813,1800,4112,4158,4215,4301 | |
562 | [TODO - Ilya Zakharevich <ilya@math.ohio-state.edu>] | |
563 | ||
564 | =head2 Overloading improvements | |
565 | ||
566 | change#2150 | |
567 | [TODO - Ilya Zakharevich <ilya@math.ohio-state.edu>] | |
568 | ||
569 | =head2 open() with more than two arguments | |
570 | ||
571 | [TODO - Ilya Zakharevich <ilya@math.ohio-state.edu>] | |
572 | ||
573 | =head2 Support for interpolating named characters | |
574 | ||
575 | change#4052 | |
576 | [TODO - Ilya Zakharevich <ilya@math.ohio-state.edu>] | |
577 | ||
08cd8952 | 578 | =head2 Experimental support for user-hooks in @INC |
a5222a85 GS |
579 | |
580 | [TODO - Ken Fox <kfox@ford.com>] | |
581 | ||
582 | =head2 C<require> and C<do> may be overridden | |
583 | ||
584 | C<require> and C<do 'file'> operations may be overridden locally | |
585 | by importing subroutines of the same name into the current package | |
586 | (or globally by importing them into the CORE::GLOBAL:: namespace). | |
587 | Overriding C<require> will also affect C<use>, provided the override | |
588 | is visible at compile-time. | |
589 | See L<perlsub/"Overriding Built-in Functions">. | |
590 | ||
591 | =head2 New variable $^C reflects C<-c> switch | |
592 | ||
08cd8952 | 593 | C<$^C> has a boolean value that reflects whether perl is being run |
a5222a85 GS |
594 | in compile-only mode (i.e. via the C<-c> switch). Since |
595 | BEGIN blocks are executed under such conditions, this variable | |
596 | enables perl code to determine whether actions that make sense | |
597 | only during normal running are warranted. See L<perlvar>. | |
598 | ||
599 | =head2 Optional Y2K warnings | |
600 | ||
601 | If Perl is built with the cpp macro C<PERL_Y2KWARN> defined, | |
602 | it emits optional warnings when concatenating the number 19 | |
603 | with another number. | |
604 | ||
605 | This behavior must be specifically enabled when running Configure. | |
606 | See L<INSTALL> and L<README.Y2K>. | |
607 | ||
fbad3eb5 GS |
608 | =head1 Significant bug fixes |
609 | ||
610 | =head2 E<lt>HANDLEE<gt> on empty files | |
611 | ||
612 | With C<$/> set to C<undef>, slurping an empty file returns a string of | |
14218588 GS |
613 | zero length (instead of C<undef>, as it used to) the first time the |
614 | HANDLE is read. Further reads yield C<undef>. | |
fbad3eb5 GS |
615 | |
616 | This means that the following will append "foo" to an empty file (it used | |
14218588 | 617 | to do nothing): |
fbad3eb5 GS |
618 | |
619 | perl -0777 -pi -e 's/^/foo/' empty_file | |
620 | ||
14218588 | 621 | The behaviour of: |
fbad3eb5 GS |
622 | |
623 | perl -pi -e 's/^/foo/' empty_file | |
624 | ||
625 | is unchanged (it continues to leave the file empty). | |
626 | ||
0244c3a4 GS |
627 | =head2 C<eval '...'> improvements |
628 | ||
629 | Line numbers (as reflected by caller() and most diagnostics) within | |
630 | C<eval '...'> were often incorrect when here documents were involved. | |
631 | This has been corrected. | |
632 | ||
633 | Lexical lookups for variables appearing in C<eval '...'> within | |
634 | functions that were themselves called within an C<eval '...'> were | |
14218588 GS |
635 | searching the wrong place for lexicals. The lexical search now |
636 | correctly ends at the subroutine's block boundary. | |
0244c3a4 GS |
637 | |
638 | Parsing of here documents used to be flawed when they appeared as | |
639 | the replacement expression in C<eval 's/.../.../e'>. This has | |
640 | been fixed. | |
641 | ||
a5222a85 GS |
642 | =head2 All compilation errors are true errors |
643 | ||
644 | Some "errors" encountered at compile time were by neccessity | |
645 | generated as warnings followed by eventual termination of the | |
646 | program. This enabled more such errors to be reported in a | |
647 | single run, rather than causing a hard stop at the first error | |
648 | that was encountered. | |
649 | ||
650 | The mechanism for reporting such errors has been reimplemented | |
651 | to queue compile-time errors and report them at the end of the | |
652 | compilation as true errors rather than as warnings. This fixes | |
08cd8952 GS |
653 | cases where error messages leaked through in the form of warnings |
654 | when code was compiled at run time using C<eval STRING>, and | |
655 | also allows such errors to be reliably trapped using __DIE__ hooks. | |
a5222a85 | 656 | |
45bc9206 GS |
657 | =head2 Automatic flushing of output buffers |
658 | ||
14218588 GS |
659 | fork(), exec(), system(), qx//, and pipe open()s now flush buffers |
660 | of all files opened for output when the operation | |
661 | was attempted. This mostly eliminates confusing | |
45bc9206 | 662 | buffering mishaps suffered by users unaware of how Perl internally |
14218588 | 663 | handles I/O. |
45bc9206 | 664 | |
af8c498a GS |
665 | =head2 Better diagnostics on meaningless filehandle operations |
666 | ||
667 | Constructs such as C<open(E<lt>FHE<gt>)> and C<close(E<lt>FHE<gt>)> | |
668 | are compile time errors. Attempting to read from filehandles that | |
669 | were opened only for writing will now produce warnings (just as | |
670 | writing to read-only filehandles does). | |
671 | ||
a5222a85 GS |
672 | =head2 Where possible, buffered data discarded from duped input filehandle |
673 | ||
674 | C<open(NEW, "E<lt>&OLD")> now attempts to discard any data that | |
675 | was previously read and buffered in C<OLD> before duping the handle. | |
676 | On platforms where doing this is allowed, the next read operation | |
677 | on C<NEW> will return the same data as the corresponding operation | |
678 | on C<OLD>. Formerly, it would have returned the data from the start | |
679 | of the following disk block instead. | |
680 | ||
681 | =head2 system(), backticks and pipe open now reflect exec() failure | |
682 | ||
683 | On Unix and similar platforms, system(), qx() and open(FOO, "cmd |") | |
684 | etc., are implemented via fork() and exec(). When the underlying | |
685 | exec() fails, earlier versions did not report the error properly, | |
686 | since the exec() happened to be in a different process. | |
687 | ||
688 | The child process now communicates with the parent about the | |
689 | error in launching the external command, which allow these | |
690 | constructs to return with their usual error value and set $!. | |
691 | ||
692 | =head2 Implicitly closed filehandles are safer | |
693 | ||
694 | Sometimes implicitly closed filehandles (as when they are localized, | |
695 | and Perl automatically closes them on exiting the scope) could | |
696 | inadvertently set $? or $!. This has been corrected. | |
697 | ||
698 | =head2 C<(\$)> prototype and C<$foo{a}> | |
699 | ||
700 | An scalar reference prototype now correctly allows a hash or | |
701 | array element in that slot. | |
702 | ||
703 | =head2 Pseudo-hashes work better | |
704 | ||
705 | Dereferencing some types of reference values in a pseudo-hash, | |
706 | such as C<$ph->{foo}[1]>, was accidentally disallowed. This has | |
707 | been corrected. | |
708 | ||
709 | When applied to a pseudo-hash element, exists() now reports whether | |
710 | the specified value exists, not merely if the key is valid. | |
711 | ||
712 | =head2 C<goto &sub> and AUTOLOAD | |
713 | ||
08cd8952 | 714 | The C<goto &sub> construct works correctly when C<&sub> happens |
a5222a85 GS |
715 | to be autoloaded. |
716 | ||
717 | =head2 C<-bareword> allowed under C<use integer> | |
718 | ||
719 | The autoquoting of barewords preceded by C<-> did not work | |
720 | in prior versions when the C<integer> pragma was enabled. | |
721 | This has been fixed. | |
722 | ||
723 | =head2 Boolean assignment operators are legal lvalues | |
724 | ||
725 | Constructs such as C<($a ||= 2) += 1> are now allowed. | |
726 | ||
727 | =head2 C<sort $coderef @foo> allowed | |
728 | ||
729 | sort() did not accept a subroutine reference as the comparison | |
08cd8952 | 730 | function in earlier versions. This is now permitted. |
a5222a85 GS |
731 | |
732 | =head2 Failures in DESTROY() | |
733 | ||
734 | When code in a destructor threw an exception, it went unnoticed | |
735 | in earlier versions of Perl, unless someone happened to be | |
736 | looking in $@ just after the point the destructor happened to | |
737 | run. Such failures are now visible as warnings when warnings are | |
738 | enabled. | |
739 | ||
740 | =head2 Locale bugs fixed | |
54195c32 | 741 | |
67d3893f JH |
742 | printf() and sprintf() previously did reset the numeric locale |
743 | back to the default "C" locale. This has been fixed. | |
744 | ||
745 | Numbers formatted according to the local numeric locale | |
746 | (such as using a decimal comma instead of a decimal dot) caused | |
747 | "isn't numeric" warnings, even while the operations accessing | |
748 | those numbers produced correct results. The warnings are gone. | |
54195c32 | 749 | |
a5222a85 GS |
750 | =head2 Memory leaks |
751 | ||
752 | The C<eval 'return sub {...}'> construct could sometimes leak | |
753 | memory. This has been fixed. | |
754 | ||
755 | Operations that aren't filehandle constructors used to leak memory | |
756 | when used on invalid filehandles. This has been fixed. | |
757 | ||
758 | Constructs that modified C<@_> could fail to deallocate values | |
759 | in C<@_> and thus leak memory. This has been corrected. | |
760 | ||
761 | =head2 Spurious subroutine stubs after failed subroutine calls | |
762 | ||
763 | Perl could sometimes create empty subroutine stubs when a | |
764 | subroutine was not found in the package. Such cases stopped | |
765 | later method lookups from progressing into base packages. | |
766 | This has been corrected. | |
767 | ||
768 | =head2 Consistent numeric conversions | |
769 | ||
770 | change#3378,3318 | |
771 | [TODO - Ilya Zakharevich <ilya@math.ohio-state.edu>] | |
772 | ||
773 | =head2 Taint failures under C<-U> | |
774 | ||
775 | When running in unsafe mode, taint violations could sometimes | |
776 | cause silent failures. This has been fixed. | |
777 | ||
778 | =head2 END blocks and the C<-c> switch | |
779 | ||
780 | Prior versions used to run BEGIN B<and> END blocks when Perl was | |
781 | run in compile-only mode. Since this is typically not the expected | |
08cd8952 | 782 | behavior, END blocks are not executed anymore when the C<-c> switch |
a5222a85 GS |
783 | is used. |
784 | ||
785 | Note that something resembling the previous behavior can still be | |
786 | obtained by putting C<BEGIN { $^C = 0; exit; } at the very end of | |
787 | the top level source file. | |
788 | ||
789 | =head2 Potential to leak DATA filehandles | |
790 | ||
791 | Using the C<__DATA__> token creates an implicit filehandle to | |
792 | the file that contains the token. It is the program's | |
793 | responsibility to close it when it is done reading from it. | |
794 | ||
795 | This caveat is now better explained in the documentation. | |
796 | See L<perldata>. | |
797 | ||
798 | =head2 Diagnostics follow STDERR | |
799 | ||
800 | Diagnostic output now goes to whichever file the C<STDERR> handle | |
801 | is pointing at, instead of always going to the underlying C runtime | |
802 | library's C<stderr>. | |
803 | ||
804 | =head2 Other fixes for better diagnostics | |
805 | ||
806 | Line numbers are suppressed no more (under most likely circumstances) | |
807 | during the global destruction phase. | |
808 | ||
809 | Diagnostics emitted from code running in threads other than the main | |
810 | thread are now accompanied by the thread ID. | |
811 | ||
812 | Embedded null characters in diagnostics now actually show up. They | |
813 | used to truncate the message in prior versions. | |
814 | ||
815 | $foo::a and $foo::b are now exempt from "possible typo" warnings only | |
816 | if sort() is encountered in package foo. | |
817 | ||
818 | Unrecognized alphabetic escapes encountered when parsing quoting | |
819 | constructs now generate a warning, since they may take on new | |
820 | semantics in later versions of Perl. | |
821 | ||
822 | =head1 Performance enhancements | |
823 | ||
824 | =head2 Simple sort() using { $a <=> $b } and the like are optimized | |
825 | ||
08cd8952 | 826 | Many common sort() operations using a simple inlined block are now |
a5222a85 GS |
827 | optimized for faster performance. |
828 | ||
829 | =head2 Optimized assignments to lexical variables | |
830 | ||
831 | Certain operations in the RHS of assignment statements have been | |
832 | optimized to directly set the lexical variable on the LHS, | |
833 | eliminating redundant copying overheads. | |
834 | ||
835 | =head2 Method lookups optimized | |
836 | ||
837 | [TODO - Chip Salzenberg <chip@perlsupport.com>] | |
838 | ||
839 | =head2 Faster mechanism to invoke XSUBs | |
840 | ||
841 | change#4044,4125 | |
842 | [TODO - Ilya Zakharevich <ilya@math.ohio-state.edu>] | |
843 | ||
844 | =head2 Perl_malloc() improvements | |
845 | ||
846 | change#4237 | |
847 | [TODO - Ilya Zakharevich <ilya@math.ohio-state.edu>] | |
848 | ||
849 | =head2 Faster subroutine calls | |
850 | ||
851 | Minor changes in how subroutine calls are handled internally | |
852 | provide marginal improvements in performance. | |
853 | ||
854 | =head1 Platform specific changes | |
855 | ||
856 | =head2 Additional supported platforms | |
ba8251e8 | 857 | |
5fdc711f GS |
858 | =over 4 |
859 | ||
860 | =item * | |
861 | ||
6c67e1bb TC |
862 | VM/ESA is now supported. |
863 | ||
5fdc711f GS |
864 | =item * |
865 | ||
ee3907e2 JH |
866 | Siemens BS2000 is now supported under the POSIX Shell. |
867 | ||
868 | =item * | |
869 | ||
2bb14304 JH |
870 | The Mach CThreads (NEXTSTEP, OPENSTEP) are now supported by the Thread |
871 | extension. | |
6c67e1bb | 872 | |
5fdc711f GS |
873 | =item * |
874 | ||
ee3907e2 | 875 | GNU/Hurd is now supported. |
6c67e1bb | 876 | |
00ad96e1 JH |
877 | =item * |
878 | ||
879 | Rhapsody is now supported. | |
880 | ||
27806c82 JH |
881 | =item * |
882 | ||
883 | EPOC is is now supported (on Psion 5). | |
884 | ||
5fdc711f GS |
885 | =back |
886 | ||
a5222a85 GS |
887 | =head2 DOS |
888 | ||
889 | [TODO - Laszlo Molnar <laszlo.molnar@eth.ericsson.se>] | |
890 | ||
891 | =head2 OS/2 | |
892 | ||
893 | [TODO - Ilya Zakharevich <ilya@math.ohio-state.edu>] | |
894 | ||
895 | =head2 VMS | |
896 | ||
897 | [TODO - Charles Bailey <bailey@newman.upenn.edu>] | |
898 | ||
899 | =head2 Win32 | |
900 | ||
901 | Site library searches failed to look for ".../site/5.XXX/lib" | |
902 | if ".../site/5.XXXYY/lib" wasn't found. This has been corrected. | |
903 | ||
904 | When given a pathname that consists only of a drivename, such | |
905 | as C<A:>, opendir() and stat() now use the current working | |
906 | directory for the drive rather than the drive root. | |
907 | ||
908 | The builtin XSUB functions in the Win32:: namespace are | |
909 | documented. See L<Win32>. | |
910 | ||
911 | $^X now contains the full path name of the running executable. | |
912 | ||
913 | A Win32::GetLongPathName() function is provided to complement | |
914 | Win32::GetFullPathName() and Win32::GetShortPathName(). See L<Win32>. | |
915 | ||
916 | POSIX::uname() is supported. | |
917 | ||
918 | system(1,...) now returns true process IDs rather than process | |
919 | handles. kill() accepts any real process id, rather than strictly | |
920 | return values from system(1,...). | |
921 | ||
922 | The C<Shell> module is supported. | |
923 | ||
924 | [TODO - GSAR] | |
925 | ||
6c67e1bb TC |
926 | =head1 New tests |
927 | ||
928 | =over 4 | |
929 | ||
09bef843 SB |
930 | =item lib/attrs |
931 | ||
932 | Compatibility tests for C<sub : attrs> vs the older C<use attrs>. | |
933 | ||
934 | =item lib/io_const | |
6c67e1bb TC |
935 | |
936 | IO constants (SEEK_*, _IO*). | |
14218588 | 937 | |
09bef843 | 938 | =item lib/io_dir |
6c67e1bb TC |
939 | |
940 | Directory-related IO methods (new, read, close, rewind, tied delete). | |
941 | ||
09bef843 | 942 | =item lib/io_multihomed |
6c67e1bb TC |
943 | |
944 | INET sockets with multi-homed hosts. | |
945 | ||
09bef843 | 946 | =item lib/io_poll |
6c67e1bb TC |
947 | |
948 | IO poll(). | |
949 | ||
09bef843 | 950 | =item lib/io_unix |
6c67e1bb TC |
951 | |
952 | UNIX sockets. | |
953 | ||
09bef843 SB |
954 | =item op/attrs |
955 | ||
956 | Regression tests for C<my ($x,@y,%z) : attrs> and <sub : attrs>. | |
957 | ||
6c67e1bb TC |
958 | =item op/filetest |
959 | ||
960 | File test operators. | |
961 | ||
962 | =item op/lex_assign | |
963 | ||
5fdc711f | 964 | Verify operations that access pad objects (lexicals and temporaries). |
6c67e1bb TC |
965 | |
966 | =back | |
e02fdbd2 | 967 | |
ba8251e8 GS |
968 | =head1 Modules and Pragmata |
969 | ||
3e8c4fa0 JH |
970 | =head2 Modules |
971 | ||
b7d8191e JH |
972 | =over 4 |
973 | ||
09bef843 SB |
974 | =item attributes |
975 | ||
976 | While used internally by Perl as a pragma, this module also | |
977 | provides a way to fetch subroutine and variable attributes. | |
978 | See L<attributes>. | |
979 | ||
a5222a85 GS |
980 | =item B |
981 | ||
982 | [TODO - Vishal Bhatia <vishal@gol.com>, | |
983 | Nick Ing-Simmons <nick@ni-s.u-net.com>] | |
984 | ||
f29c64d6 GS |
985 | =item ByteLoader |
986 | ||
a5222a85 | 987 | The ByteLoader is a dedicated extension to generate and run |
f29c64d6 GS |
988 | Perl bytecode. See L<ByteLoader>. |
989 | ||
990 | =item B | |
991 | ||
992 | The Perl Compiler suite has been extensively reworked for this | |
993 | release. | |
994 | ||
a5222a85 GS |
995 | =item constant |
996 | ||
997 | References can now be used. See L<constant>. | |
998 | ||
999 | =item charnames | |
1000 | ||
1001 | change#4052 | |
1002 | [TODO - Ilya Zakharevich <ilya@math.ohio-state.edu>] | |
1003 | ||
1004 | =item Data::Dumper | |
1005 | ||
1006 | A C<Maxdepth> setting can be specified to avoid venturing | |
1007 | too deeply into data structures that may be very deep. | |
1008 | See L<Data::Dumper>. | |
1009 | ||
1010 | Dumping C<qr//> objects works correctly. | |
1011 | ||
1012 | =item DB | |
1013 | ||
1014 | C<DB> is an experimental module that exposes a clean abstraction | |
1015 | to Perl's debugging API. | |
1016 | ||
1017 | =item DB_File | |
1018 | ||
1019 | [TODO - Paul Marquess <paul.marquess@bt.com>] | |
1020 | ||
f29c64d6 GS |
1021 | =item Devel::DProf |
1022 | ||
a5222a85 | 1023 | Devel::DProf, a Perl source code profiler has been added. See L<DProf>. |
f29c64d6 | 1024 | |
b7d8191e JH |
1025 | =item Dumpvalue |
1026 | ||
1027 | Added Dumpvalue module provides screen dumps of Perl data. | |
1028 | ||
1029 | =item Benchmark | |
1030 | ||
868cb350 | 1031 | You can now run tests for I<n> seconds instead of guessing the right |
14218588 GS |
1032 | number of tests to run: e.g. timethese(-5, ...) will run each |
1033 | code for at least 5 CPU seconds. Zero as the "number of repetitions" | |
155776c0 | 1034 | means "for at least 3 CPU seconds". The output format has also |
14218588 | 1035 | changed. For example: |
155776c0 JH |
1036 | |
1037 | use Benchmark;$x=3;timethese(-5,{a=>sub{$x*$x},b=>sub{$x**2}}) | |
1038 | ||
1039 | will now output something like this: | |
1040 | ||
1041 | Benchmark: running a, b, each for at least 5 CPU seconds... | |
1042 | a: 5 wallclock secs ( 5.77 usr + 0.00 sys = 5.77 CPU) @ 200551.91/s (n=1156516) | |
1043 | b: 4 wallclock secs ( 5.00 usr + 0.02 sys = 5.02 CPU) @ 159605.18/s (n=800686) | |
1044 | ||
1045 | New features: "each for at least N CPU seconds...", "wallclock secs", | |
1046 | and the "@ operations/CPU second (n=operations)". | |
b7d8191e | 1047 | |
a5222a85 GS |
1048 | change#4265,4266,4292 |
1049 | [TODO - Barrie Slaymaker <barries@slaysys.com>] | |
1050 | ||
f505c983 GS |
1051 | =item Devel::Peek |
1052 | ||
1053 | The Devel::Peek module provides access to the internal representation | |
14218588 | 1054 | of Perl variables and data. It is a data debugging tool for the XS programmer. |
f505c983 | 1055 | |
a5222a85 GS |
1056 | =item ExtUtils::MakeMaker |
1057 | ||
1058 | change#4135, also needs docs in module pod | |
1059 | [TODO - Ilya Zakharevich <ilya@math.ohio-state.edu>] | |
1060 | ||
b7d8191e JH |
1061 | =item Fcntl |
1062 | ||
1063 | More Fcntl constants added: F_SETLK64, F_SETLKW64, O_LARGEFILE for | |
14218588 | 1064 | large (more than 4G) file access (64-bit support is not yet |
b7d8191e JH |
1065 | working, though, so no need to get overly excited), Free/Net/OpenBSD |
1066 | locking behaviour flags F_FLOCK, F_POSIX, Linux F_SHLCK, and | |
1067 | O_ACCMODE: the mask of O_RDONLY, O_WRONLY, and O_RDWR. | |
1068 | ||
a5222a85 GS |
1069 | =item File::Compare |
1070 | ||
1071 | A compare_text() function has been added, which allows custom | |
1072 | comparison functions. See L<File::Compare>. | |
1073 | ||
1074 | =item File::Find | |
1075 | ||
1076 | File::Find now works correctly when the wanted() function is either | |
1077 | autoloaded or is a symbolic reference. | |
1078 | ||
08cd8952 | 1079 | A bug that caused File::Find to lose track of the working directory |
a5222a85 GS |
1080 | when pruning top-level directories has been fixed. |
1081 | ||
f505c983 GS |
1082 | =item File::Spec |
1083 | ||
1084 | New methods have been added to the File::Spec module: devnull() returns | |
19799a22 | 1085 | the name of the null device (/dev/null on Unix) and tmpdir() the name of |
14218588 | 1086 | the temp directory (normally /tmp on Unix). There are now also methods |
f505c983 | 1087 | to convert between absolute and relative filenames: abs2rel() and |
14218588 GS |
1088 | rel2abs(). For compatibility with operating systems that specify volume |
1089 | names in file paths, the splitpath(), splitdir(), and catdir() methods | |
f505c983 GS |
1090 | have been added. |
1091 | ||
1092 | =item File::Spec::Functions | |
1093 | ||
1094 | The new File::Spec::Functions modules provides a function interface | |
14218588 | 1095 | to the File::Spec module. Allows shorthand |
f505c983 | 1096 | |
14218588 | 1097 | $fullname = catfile($dir1, $dir2, $file); |
f505c983 GS |
1098 | |
1099 | instead of | |
1100 | ||
14218588 | 1101 | $fullname = File::Spec->catfile($dir1, $dir2, $file); |
f505c983 | 1102 | |
a5222a85 GS |
1103 | =item Getopt::Long |
1104 | ||
1105 | [TODO - Johan Vromans <jvromans@squirrel.nl>] | |
1106 | ||
1107 | =item IO | |
1108 | ||
1109 | write() and syswrite() will now accept a single-argument | |
1110 | form of the call, for consistency with Perl's syswrite(). | |
1111 | ||
1112 | You can now create a TCP-based IO::Socket::INET without forcing | |
1113 | a connect attempt. This allows you to configure its options | |
1114 | (like making it non-blocking) and then call connect() manually. | |
1115 | ||
1116 | A bug that prevented the IO::Socket::protocol() accessor | |
1117 | from ever returning the correct value has been corrected. | |
1118 | ||
1119 | =item JPL | |
1120 | ||
1121 | Java Perl Lingo is now distributed with Perl. See jpl/README | |
1122 | for more information. | |
1123 | ||
e16b8f49 WM |
1124 | =item Math::BigInt |
1125 | ||
14218588 | 1126 | The logical operations C<E<lt>E<lt>>, C<E<gt>E<gt>>, C<&>, C<|>, |
e16b8f49 WM |
1127 | and C<~> are now supported on bigints. |
1128 | ||
b7d8191e | 1129 | =item Math::Complex |
7711098a | 1130 | |
14218588 | 1131 | The accessor methods Re, Im, arg, abs, rho, and theta can now also |
868cb350 | 1132 | act as mutators (accessor $z->Re(), mutator $z->Re(3)). |
b7d8191e JH |
1133 | |
1134 | =item Math::Trig | |
1135 | ||
14218588 GS |
1136 | A little bit of radial trigonometry (cylindrical and spherical), |
1137 | radial coordinate conversions, and the great circle distance were added. | |
b7d8191e | 1138 | |
a5222a85 GS |
1139 | =item Pod::Parser |
1140 | ||
1141 | [TODO - Brad Appleton <bradapp@enteract.com>] | |
1142 | ||
1143 | =item Pod::Text and Pod::Man | |
1144 | ||
1145 | [TODO - Russ Allbery <rra@stanford.edu>] | |
1146 | ||
f4b9d880 RA |
1147 | =item SDBM_File |
1148 | ||
1149 | An EXISTS method has been added to this module (and sdbm_exists() has | |
1150 | been added to the underlying sdbm library), so one can now call exists | |
14218588 | 1151 | on an SDBM_File tied hash and get the correct result, rather than a |
f4b9d880 RA |
1152 | runtime error. |
1153 | ||
a5222a85 GS |
1154 | A bug that may have caused data loss when more than one disk block |
1155 | happens to be read from the database in a single FETCH() has been | |
1156 | fixed. | |
1157 | ||
06ef4121 PC |
1158 | =item Time::Local |
1159 | ||
1160 | The timelocal() and timegm() functions used to silently return bogus | |
1161 | results when the date exceeded the machine's integer range. They | |
a5222a85 | 1162 | now consistently croak() if the date falls in an unsupported range. |
06ef4121 | 1163 | |
8fe0a5c4 JD |
1164 | =item Win32 |
1165 | ||
1166 | The error return value in list context has been changed for all functions | |
14218588 GS |
1167 | that return a list of values. Previously these functions returned a list |
1168 | with a single element C<undef> if an error occurred. Now these functions | |
1169 | return the empty list in these situations. This applies to the following | |
8fe0a5c4 JD |
1170 | functions: |
1171 | ||
14218588 GS |
1172 | Win32::FsType |
1173 | Win32::GetOSVersion | |
8fe0a5c4 JD |
1174 | |
1175 | The remaining functions are unchanged and continue to return C<undef> on | |
1176 | error even in list context. | |
1177 | ||
1178 | The Win32::SetLastError(ERROR) function has been added as a complement | |
1179 | to the Win32::GetLastError() function. | |
1180 | ||
1181 | The new Win32::GetFullPathName(FILENAME) returns the full absolute | |
14218588 GS |
1182 | pathname for FILENAME in scalar context. In list context it returns |
1183 | a two-element list containing the fully qualified directory name and | |
8fe0a5c4 JD |
1184 | the filename. |
1185 | ||
9fe6733a PM |
1186 | =item DBM Filters |
1187 | ||
1188 | A new feature called "DBM Filters" has been added to all the | |
14218588 GS |
1189 | DBM modules--DB_File, GDBM_File, NDBM_File, ODBM_File, and SDBM_File. |
1190 | DBM Filters add four new methods to each DBM module: | |
9fe6733a PM |
1191 | |
1192 | filter_store_key | |
1193 | filter_store_value | |
1194 | filter_fetch_key | |
1195 | filter_fetch_value | |
1196 | ||
14218588 | 1197 | These can be used to filter key-value pairs before the pairs are |
9fe6733a PM |
1198 | written to the database or just after they are read from the database. |
1199 | See L<perldbmfilter> for further information. | |
1200 | ||
b7d8191e | 1201 | =back |
3e8c4fa0 JH |
1202 | |
1203 | =head2 Pragmata | |
1204 | ||
09bef843 SB |
1205 | C<use attrs> is now obsolescent, and is only provided for |
1206 | backward-compatibility. It's been replaced by the C<sub : attributes> | |
1207 | syntax. See L<perlsub/"Subroutine Attributes"> and L<attributes>. | |
1208 | ||
14218588 | 1209 | C<use utf8> to enable UTF-8 and Unicode support. |
43165c05 GS |
1210 | |
1211 | C<use caller 'encoding'> allows modules to inherit pragmatic attributes | |
1212 | from the caller's context. C<encoding> is currently the only supported | |
1213 | attribute. | |
9d73390d | 1214 | |
4438c4b7 | 1215 | Lexical warnings pragma, C<use warnings;>, to control optional warnings. |
a5222a85 | 1216 | See L<perllexwarn>. |
6c67e1bb | 1217 | |
67d3893f JH |
1218 | C<use filetest> to control the behaviour of filetests (C<-r> C<-w> |
1219 | ...). Currently only one subpragma implemented, "use filetest | |
1220 | 'access';", that uses access(2) or equivalent to check permissions | |
1221 | instead of using stat(2) as usual. This matters in filesystems | |
1222 | where there are ACLs (access control lists): the stat(2) might lie, | |
1223 | but access(2) knows better. | |
6c67e1bb | 1224 | |
ba8251e8 GS |
1225 | =head1 Utility Changes |
1226 | ||
a5222a85 GS |
1227 | =head2 h2ph |
1228 | ||
1229 | [TODO - Kurt Starsinic <kstar@chapin.edu>] | |
1230 | ||
1231 | =head2 perlcc | |
1232 | ||
1233 | C<perlcc> now supports the C and Bytecode backends. By default, | |
1234 | it generates output from the simple C backend rather than the | |
1235 | optimized C backend. | |
1236 | ||
1237 | Support for non-Unix platforms has been improved. | |
1238 | ||
1239 | =head2 h2xs | |
1240 | ||
1241 | change#4232 | |
1242 | [TODO - Ilya Zakharevich <ilya@math.ohio-state.edu>] | |
e02fdbd2 | 1243 | |
ba8251e8 GS |
1244 | =head1 Documentation Changes |
1245 | ||
5fdc711f GS |
1246 | =over 4 |
1247 | ||
1248 | =item perlopentut.pod | |
f8284313 | 1249 | |
5fdc711f GS |
1250 | A tutorial on using open() effectively. |
1251 | ||
1252 | =item perlreftut.pod | |
1253 | ||
1254 | A tutorial that introduces the essentials of references. | |
1255 | ||
14218588 GS |
1256 | =item perltootc.pod |
1257 | ||
1258 | A tutorial on managing class data for object modules. | |
1259 | ||
a5222a85 GS |
1260 | =item perlcompile.pod |
1261 | ||
1262 | An introduction to using the Perl Compiler suite. | |
1263 | ||
5fdc711f | 1264 | =back |
e02fdbd2 | 1265 | |
ba8251e8 GS |
1266 | =head1 New Diagnostics |
1267 | ||
a99ba403 GS |
1268 | =over 4 |
1269 | ||
09bef843 SB |
1270 | =item "my sub" not yet implemented |
1271 | ||
1272 | (F) Lexically scoped subroutines are not yet implemented. Don't try that | |
1273 | yet. | |
1274 | ||
a99ba403 GS |
1275 | =item '!' allowed only after types %s |
1276 | ||
1277 | (F) The '!' is allowed in pack() and unpack() only after certain types. | |
1278 | See L<perlfunc/pack>. | |
1279 | ||
1280 | =item / cannot take a count | |
1281 | ||
1282 | (F) You had an unpack template indicating a counted-length string, | |
1283 | but you have also specified an explicit size for the string. | |
1284 | See L<perlfunc/pack>. | |
1285 | ||
1286 | =item / must be followed by a, A or Z | |
1287 | ||
1288 | (F) You had an unpack template indicating a counted-length string, | |
1289 | which must be followed by one of the letters a, A or Z | |
1290 | to indicate what sort of string is to be unpacked. | |
1291 | See L<perlfunc/pack>. | |
1292 | ||
1293 | =item / must be followed by a*, A* or Z* | |
1294 | ||
1295 | (F) You had an pack template indicating a counted-length string, | |
1296 | Currently the only things that can have their length counted are a*, A* or Z*. | |
1297 | See L<perlfunc/pack>. | |
1298 | ||
1299 | =item / must follow a numeric type | |
1300 | ||
1301 | (F) You had an unpack template that contained a '#', | |
1302 | but this did not follow some numeric unpack specification. | |
1303 | See L<perlfunc/pack>. | |
1304 | ||
1305 | =item Repeat count in pack overflows | |
1306 | ||
1307 | (F) You can't specify a repeat count so large that it overflows | |
1308 | your signed integers. See L<perlfunc/pack>. | |
1309 | ||
1310 | =item Repeat count in unpack overflows | |
1311 | ||
1312 | (F) You can't specify a repeat count so large that it overflows | |
1313 | your signed integers. See L<perlfunc/unpack>. | |
1314 | ||
1315 | =item /%s/: Unrecognized escape \\%c passed through | |
1316 | ||
1317 | (W) You used a backslash-character combination which is not recognized | |
1318 | by Perl. This combination appears in an interpolated variable or a | |
1319 | C<'>-delimited regular expression. | |
1320 | ||
1321 | =item /%s/ should probably be written as "%s" | |
1322 | ||
1323 | (W) You have used a pattern where Perl expected to find a string, | |
1324 | like in the first argument to C<join>. Perl will treat the true | |
1325 | or false result of matching the pattern against $_ as the string, | |
1326 | which is probably not what you had in mind. | |
1327 | ||
1328 | =item %s() called too early to check prototype | |
1329 | ||
1330 | (W) You've called a function that has a prototype before the parser saw a | |
1331 | definition or declaration for it, and Perl could not check that the call | |
1332 | conforms to the prototype. You need to either add an early prototype | |
1333 | declaration for the subroutine in question, or move the subroutine | |
1334 | definition ahead of the call to get proper prototype checking. Alternatively, | |
1335 | if you are certain that you're calling the function correctly, you may put | |
1336 | an ampersand before the name to avoid the warning. See L<perlsub>. | |
1337 | ||
09bef843 SB |
1338 | =item %s package attribute may clash with future reserved word: %s |
1339 | ||
1340 | (W) A lowercase attribute name was used that had a package-specific handler. | |
1341 | That name might have a meaning to Perl itself some day, even though it | |
1342 | doesn't yet. Perhaps you should use a mixed-case attribute name, instead. | |
1343 | See L<attributes>. | |
1344 | ||
a99ba403 | 1345 | =item (in cleanup) %s |
6b121555 | 1346 | |
a99ba403 GS |
1347 | (W) This prefix usually indicates that a DESTROY() method raised |
1348 | the indicated exception. Since destructors are usually called by | |
1349 | the system at arbitrary points during execution, and often a vast | |
1350 | number of times, the warning is issued only once for any number | |
1351 | of failures that would otherwise result in the same message being | |
1352 | repeated. | |
1353 | ||
1354 | Failure of user callbacks dispatched using the C<G_KEEPERR> flag | |
1355 | could also result in this warning. See L<perlcall/G_KEEPERR>. | |
1356 | ||
1357 | =item <> should be quotes | |
1358 | ||
1359 | (F) You wrote C<require E<lt>fileE<gt>> when you should have written | |
1360 | C<require 'file'>. | |
1361 | ||
1362 | =item Attempt to join self | |
1363 | ||
1364 | (F) You tried to join a thread from within itself, which is an | |
1365 | impossible task. You may be joining the wrong thread, or you may | |
1366 | need to move the join() to some other thread. | |
1367 | ||
1368 | =item Bad evalled substitution pattern | |
1369 | ||
1370 | (F) You've used the /e switch to evaluate the replacement for a | |
1371 | substitution, but perl found a syntax error in the code to evaluate, | |
1372 | most likely an unexpected right brace '}'. | |
1373 | ||
1374 | =item Bad realloc() ignored | |
1375 | ||
1376 | (S) An internal routine called realloc() on something that had never been | |
1377 | malloc()ed in the first place. Mandatory, but can be disabled by | |
1378 | setting environment variable C<PERL_BADFREE> to 1. | |
1379 | ||
1380 | =item Binary number > 0b11111111111111111111111111111111 non-portable | |
1381 | ||
1382 | (W) The binary number you specified is larger than 2**32-1 | |
1383 | (4294967295) and therefore non-portable between systems. See | |
1384 | L<perlport> for more on portability concerns. | |
1385 | ||
1386 | =item Bit vector size > 32 non-portable | |
1387 | ||
1388 | (W) Using bit vector sizes larger than 32 is non-portable. | |
1389 | ||
1390 | =item Buffer overflow in prime_env_iter: %s | |
1391 | ||
1392 | (W) A warning peculiar to VMS. While Perl was preparing to iterate over | |
1393 | %ENV, it encountered a logical name or symbol definition which was too long, | |
1394 | so it was truncated to the string shown. | |
1395 | ||
1396 | =item Can't check filesystem of script "%s" | |
1397 | ||
1398 | (P) For some reason you can't check the filesystem of the script for nosuid. | |
1399 | ||
1400 | =item Can't modify non-lvalue subroutine call | |
1401 | ||
1402 | (F) Subroutines used in lvalue context should be marked as such, see | |
1403 | L<perlsub/"Lvalue subroutines">. | |
1404 | ||
1405 | =item Can't read CRTL environ | |
1406 | ||
1407 | (S) A warning peculiar to VMS. Perl tried to read an element of %ENV | |
1408 | from the CRTL's internal environment array and discovered the array was | |
1409 | missing. You need to figure out where your CRTL misplaced its environ | |
1410 | or define F<PERL_ENV_TABLES> (see L<perlvms>) so that environ is not searched. | |
1411 | ||
1412 | =item Can't remove %s: %s, skipping file | |
1413 | ||
1414 | (S) You requested an inplace edit without creating a backup file. Perl | |
1415 | was unable to remove the original file to replace it with the modified | |
1416 | file. The file was left unmodified. | |
1417 | ||
1418 | =item Can't return %s from lvalue subroutine | |
1419 | ||
1420 | (F) Perl detected an attempt to return illegal lvalues (such | |
1421 | as temporary or readonly values) from a subroutine used as an lvalue. | |
1422 | This is not allowed. | |
1423 | ||
1424 | =item Can't weaken a nonreference | |
1425 | ||
1426 | (F) You attempted to weaken something that was not a reference. Only | |
1427 | references can be weakened. | |
1428 | ||
1429 | =item Character class [:%s:] unknown | |
1430 | ||
1431 | (F) The class in the character class [: :] syntax is unknown. | |
1432 | ||
1433 | =item Character class syntax [%s] belongs inside character classes | |
1434 | ||
1435 | (W) The character class constructs [: :], [= =], and [. .] go | |
1436 | I<inside> character classes, the [] are part of the construct, | |
1437 | for example: /[012[:alpha:]345]/. Note that the last two constructs | |
1438 | are not currently implemented, they are placeholders for future extensions. | |
1439 | ||
1440 | =item Constant is not %s reference | |
1441 | ||
1442 | (F) A constant value (perhaps declared using the C<use constant> pragma) | |
1443 | is being dereferenced, but it amounts to the wrong type of reference. The | |
1444 | message indicates the type of reference that was expected. This usually | |
1445 | indicates a syntax error in dereferencing the constant value. | |
1446 | See L<perlsub/"Constant Functions"> and L<constant>. | |
1447 | ||
1448 | =item constant(%s): %%^H is not localized | |
1449 | ||
1450 | (F) When setting compile-time-lexicalized hash %^H one should set the | |
1451 | corresponding bit of $^H as well. | |
1452 | ||
1453 | =item constant(%s): %s | |
1454 | ||
1455 | (F) Compile-time-substitutions (such as overloaded constants and | |
1456 | character names) were not correctly set up. | |
1457 | ||
1458 | =item defined(@array) is deprecated | |
1459 | ||
1460 | (D) defined() is not usually useful on arrays because it checks for an | |
1461 | undefined I<scalar> value. If you want to see if the array is empty, | |
1462 | just use C<if (@array) { # not empty }> for example. | |
1463 | ||
1464 | =item defined(%hash) is deprecated | |
1465 | ||
1466 | (D) defined() is not usually useful on hashes because it checks for an | |
1467 | undefined I<scalar> value. If you want to see if the hash is empty, | |
1468 | just use C<if (%hash) { # not empty }> for example. | |
1469 | ||
1470 | =item Did not produce a valid header | |
1471 | ||
1472 | See Server error. | |
1473 | ||
1474 | =item Document contains no data | |
1475 | ||
1476 | See Server error. | |
1477 | ||
1478 | =item entering effective %s failed | |
1479 | ||
1480 | (F) While under the C<use filetest> pragma, switching the real and | |
1481 | effective uids or gids failed. | |
6b121555 | 1482 | |
af8c498a | 1483 | =item Filehandle %s opened only for output |
6b121555 | 1484 | |
af8c498a GS |
1485 | (W) You tried to read from a filehandle opened only for writing. If you |
1486 | intended it to be a read-write filehandle, you needed to open it with | |
1487 | "+E<lt>" or "+E<gt>" or "+E<gt>E<gt>" instead of with "E<lt>" or nothing. If | |
1488 | you intended only to read from the file, use "E<lt>". See | |
1489 | L<perlfunc/open>. | |
e02fdbd2 | 1490 | |
a99ba403 GS |
1491 | =item Hexadecimal number > 0xffffffff non-portable |
1492 | ||
1493 | (W) The hexadecimal number you specified is larger than 2**32-1 | |
1494 | (4294967295) and therefore non-portable between systems. See | |
1495 | L<perlport> for more on portability concerns. | |
1496 | ||
1497 | =item Ill-formed CRTL environ value "%s" | |
1498 | ||
1499 | (W) A warning peculiar to VMS. Perl tried to read the CRTL's internal | |
1500 | environ array, and encountered an element without the C<=> delimiter | |
1501 | used to spearate keys from values. The element is ignored. | |
1502 | ||
1503 | =item Ill-formed message in prime_env_iter: |%s| | |
1504 | ||
1505 | (W) A warning peculiar to VMS. Perl tried to read a logical name | |
1506 | or CLI symbol definition when preparing to iterate over %ENV, and | |
1507 | didn't see the expected delimiter between key and value, so the | |
1508 | line was ignored. | |
1509 | ||
1510 | =item Illegal binary digit %s | |
1511 | ||
1512 | (F) You used a digit other than 0 and 1 in a binary number. | |
1513 | ||
1514 | =item Illegal binary digit %s ignored | |
1515 | ||
1516 | (W) You may have tried to use a digit other than 0 or 1 in a binary number. | |
1517 | Interpretation of the binary number stopped before the offending digit. | |
1518 | ||
1519 | =item Illegal number of bits in vec | |
1520 | ||
1521 | (F) The number of bits in vec() (the third argument) must be a power of | |
1522 | two from 1 to 32 (or 64, if your platform supports that). | |
1523 | ||
1524 | =item Integer overflow in %s number | |
1525 | ||
1526 | (W) The hexadecimal, octal or binary number you have specified either | |
1527 | as a literal in your code or as a scalar is too big for your | |
1528 | architecture, and has been converted to a floating point number. On a | |
1529 | 32-bit architecture the largest hexadecimal, octal or binary number | |
1530 | representable without overflow is 0xFFFFFFFF, 037777777777, or | |
1531 | 0b11111111111111111111111111111111 respectively. Note that Perl | |
1532 | transparently promotes all numbers to a floating point representation | |
1533 | internally--subject to loss of precision errors in subsequent | |
1534 | operations. | |
1535 | ||
09bef843 SB |
1536 | =item Invalid %s attribute: %s |
1537 | ||
1538 | The indicated attribute for a subroutine or variable was not recognized | |
1539 | by Perl or by a user-supplied handler. See L<attributes>. | |
1540 | ||
1541 | =item Invalid %s attributes: %s | |
1542 | ||
1543 | The indicated attributes for a subroutine or variable were not recognized | |
1544 | by Perl or by a user-supplied handler. See L<attributes>. | |
1545 | ||
1546 | =item Invalid separator character %s in attribute list | |
1547 | ||
1548 | (F) Something other than a comma or whitespace was seen between the | |
1549 | elements of an attribute list. If the previous attribute | |
1550 | had a parenthesised parameter list, perhaps that list was terminated | |
1551 | too soon. See L<attributes>. | |
1552 | ||
a99ba403 GS |
1553 | =item Invalid separator character %s in subroutine attribute list |
1554 | ||
1555 | (F) Something other than a comma or whitespace was seen between the | |
1556 | elements of a subroutine attribute list. If the previous attribute | |
1557 | had a parenthesised parameter list, perhaps that list was terminated | |
1558 | too soon. | |
1559 | ||
1560 | =item leaving effective %s failed | |
1561 | ||
1562 | (F) While under the C<use filetest> pragma, switching the real and | |
1563 | effective uids or gids failed. | |
1564 | ||
1565 | =item Lvalue subs returning %s not implemented yet | |
1566 | ||
1567 | (F) Due to limitations in the current implementation, array and hash | |
1568 | values cannot be returned in subroutines used in lvalue context. | |
1569 | See L<perlsub/"Lvalue subroutines">. | |
1570 | ||
1571 | =item Method %s not permitted | |
1572 | ||
1573 | See Server error. | |
1574 | ||
1575 | =item Missing %sbrace%s on \N{} | |
1576 | ||
1577 | (F) Wrong syntax of character name literal C<\N{charname}> within | |
1578 | double-quotish context. | |
1579 | ||
06eaf0bc GS |
1580 | =item Missing command in piped open |
1581 | ||
1582 | (W) You used the C<open(FH, "| command")> or C<open(FH, "command |")> | |
1583 | construction, but the command was missing or blank. | |
1584 | ||
09bef843 SB |
1585 | =item Missing name in "my sub" |
1586 | ||
1587 | (F) The reserved syntax for lexically scoped subroutines requires that they | |
1588 | have a name with which they can be found. | |
1589 | ||
a99ba403 GS |
1590 | =item no UTC offset information; assuming local time is UTC |
1591 | ||
1592 | (S) A warning peculiar to VMS. Perl was unable to find the local | |
1593 | timezone offset, so it's assuming that local system time is equivalent | |
1594 | to UTC. If it's not, define the logical name F<SYS$TIMEZONE_DIFFERENTIAL> | |
1595 | to translate to the number of seconds which need to be added to UTC to | |
1596 | get local time. | |
1597 | ||
1598 | =item Octal number > 037777777777 non-portable | |
1599 | ||
1600 | (W) The octal number you specified is larger than 2**32-1 (4294967295) | |
1601 | and therefore non-portable between systems. See L<perlport> for more | |
1602 | on portability concerns. | |
1603 | ||
1604 | See also L<perlport> for writing portable code. | |
1605 | ||
1606 | =item panic: del_backref | |
1607 | ||
1608 | (P) Failed an internal consistency check while trying to reset a weak | |
1609 | reference. | |
1610 | ||
1611 | =item panic: kid popen errno read | |
1612 | ||
1613 | (F) forked child returned an incomprehensible message about its errno. | |
1614 | ||
1615 | =item panic: magic_killbackrefs | |
1616 | ||
1617 | (P) Failed an internal consistency check while trying to reset all weak | |
1618 | references to an object. | |
1619 | ||
1620 | =item Possible Y2K bug: %s | |
1621 | ||
1622 | (W) You are concatenating the number 19 with another number, which | |
1623 | could be a potential Year 2000 problem. | |
1624 | ||
1625 | =item Premature end of script headers | |
1626 | ||
1627 | See Server error. | |
1628 | ||
1629 | =item realloc() of freed memory ignored | |
1630 | ||
1631 | (S) An internal routine called realloc() on something that had already | |
1632 | been freed. | |
1633 | ||
1634 | =item Reference is already weak | |
1635 | ||
1636 | (W) You have attempted to weaken a reference that is already weak. | |
1637 | Doing so has no effect. | |
1638 | ||
1639 | =item setpgrp can't take arguments | |
1640 | ||
1641 | (F) Your system has the setpgrp() from BSD 4.2, which takes no arguments, | |
1642 | unlike POSIX setpgid(), which takes a process ID and process group ID. | |
1643 | ||
1644 | =item Strange *+?{} on zero-length expression | |
1645 | ||
1646 | (W) You applied a regular expression quantifier in a place where it | |
1647 | makes no sense, such as on a zero-width assertion. | |
1648 | Try putting the quantifier inside the assertion instead. For example, | |
1649 | the way to match "abc" provided that it is followed by three | |
1650 | repetitions of "xyz" is C</abc(?=(?:xyz){3})/>, not C</abc(?=xyz){3}/>. | |
1651 | ||
1652 | =item switching effective %s is not implemented | |
1653 | ||
1654 | (F) While under the C<use filetest> pragma, we cannot switch the | |
1655 | real and effective uids or gids. | |
1656 | ||
1657 | =item This Perl can't reset CRTL eviron elements (%s) | |
1658 | ||
1659 | =item This Perl can't set CRTL environ elements (%s=%s) | |
1660 | ||
1661 | (W) Warnings peculiar to VMS. You tried to change or delete an element | |
1662 | of the CRTL's internal environ array, but your copy of Perl wasn't | |
1663 | built with a CRTL that contained the setenv() function. You'll need to | |
1664 | rebuild Perl with a CRTL that does, or redefine F<PERL_ENV_TABLES> (see | |
1665 | L<perlvms>) so that the environ array isn't the target of the change to | |
1666 | %ENV which produced the warning. | |
1667 | ||
1668 | =item Unknown open() mode '%s' | |
1669 | ||
1670 | (F) The second argument of 3-arguments open is not one from the list | |
1671 | of C<L<lt>>, C<L<gt>>, C<E<gt>E<gt>>, C<+L<lt>>, C<+L<gt>>, | |
1672 | C<+E<gt>E<gt>>, C<-|>, C<|-> of possible open() modes. | |
1673 | ||
1674 | =item Unknown process %x sent message to prime_env_iter: %s | |
1675 | ||
1676 | (P) An error peculiar to VMS. Perl was reading values for %ENV before | |
1677 | iterating over it, and someone else stuck a message in the stream of | |
1678 | data Perl expected. Someone's very confused, or perhaps trying to | |
1679 | subvert Perl's population of %ENV for nefarious purposes. | |
1680 | ||
af8c498a GS |
1681 | =item Unrecognized escape \\%c passed through |
1682 | ||
1683 | (W) You used a backslash-character combination which is not recognized | |
1684 | by Perl. | |
1685 | ||
09bef843 SB |
1686 | =item Unterminated attribute parameter in attribute list |
1687 | ||
1688 | (F) The lexer saw an opening (left) parenthesis character while parsing an | |
1689 | attribute list, but the matching closing (right) parenthesis | |
1690 | character was not found. You may need to add (or remove) a backslash | |
1691 | character to get your parentheses to balance. See L<attributes>. | |
1692 | ||
1693 | =item Unterminated attribute list | |
1694 | ||
1695 | (F) The lexer found something other than a simple identifier at the start | |
1696 | of an attribute, and it wasn't a semicolon or the start of a | |
1697 | block. Perhaps you terminated the parameter list of the previous attribute | |
1698 | too soon. See L<attributes>. | |
1699 | ||
09bef843 SB |
1700 | =item Unterminated attribute parameter in subroutine attribute list |
1701 | ||
1702 | (F) The lexer saw an opening (left) parenthesis character while parsing a | |
1703 | subroutine attribute list, but the matching closing (right) parenthesis | |
1704 | character was not found. You may need to add (or remove) a backslash | |
1705 | character to get your parentheses to balance. | |
1706 | ||
1707 | =item Unterminated subroutine attribute list | |
1708 | ||
1709 | (F) The lexer found something other than a simple identifier at the start | |
1710 | of a subroutine attribute, and it wasn't a semicolon or the start of a | |
1711 | block. Perhaps you terminated the parameter list of the previous attribute | |
1712 | too soon. | |
1713 | ||
a99ba403 | 1714 | =item Value of CLI symbol "%s" too long |
eb6e2d6f | 1715 | |
a99ba403 GS |
1716 | (W) A warning peculiar to VMS. Perl tried to read the value of an %ENV |
1717 | element from a CLI symbol table, and found a resultant string longer | |
1718 | than 1024 characters. The return value has been truncated to 1024 | |
1719 | characters. | |
eb6e2d6f | 1720 | |
a99ba403 | 1721 | =item Version number must be a constant number |
ba8251e8 | 1722 | |
a99ba403 GS |
1723 | (P) The attempt to translate a C<use Module n.n LIST> statement into |
1724 | its equivalent C<BEGIN> block found an internal inconsistency with | |
1725 | the version number. | |
1726 | ||
1727 | =back | |
27806c82 | 1728 | |
a5222a85 | 1729 | =head1 Obsolete Diagnostics |
3175b8cd | 1730 | |
a99ba403 GS |
1731 | =over 4 |
1732 | ||
1733 | =item Character class syntax [: :] is reserved for future extensions | |
1734 | ||
1735 | (W) Within regular expression character classes ([]) the syntax beginning | |
1736 | with "[:" and ending with ":]" is reserved for future extensions. | |
1737 | If you need to represent those character sequences inside a regular | |
1738 | expression character class, just quote the square brackets with the | |
1739 | backslash: "\[:" and ":\]". | |
1740 | ||
1741 | =item Ill-formed logical name |%s| in prime_env_iter | |
1742 | ||
1743 | (W) A warning peculiar to VMS. A logical name was encountered when preparing | |
1744 | to iterate over %ENV which violates the syntactic rules governing logical | |
1745 | names. Because it cannot be translated normally, it is skipped, and will not | |
1746 | appear in %ENV. This may be a benign occurrence, as some software packages | |
1747 | might directly modify logical name tables and introduce nonstandard names, | |
1748 | or it may indicate that a logical name table has been corrupted. | |
1749 | ||
1750 | =item regexp too big | |
1751 | ||
1752 | (F) The current implementation of regular expressions uses shorts as | |
1753 | address offsets within a string. Unfortunately this means that if | |
1754 | the regular expression compiles to longer than 32767, it'll blow up. | |
1755 | Usually when you want a regular expression this big, there is a better | |
1756 | way to do it with multiple statements. See L<perlre>. | |
1757 | ||
1758 | =item Use of "$$<digit>" to mean "${$}<digit>" is deprecated | |
1759 | ||
1760 | (D) Perl versions before 5.004 misinterpreted any type marker followed | |
1761 | by "$" and a digit. For example, "$$0" was incorrectly taken to mean | |
1762 | "${$}0" instead of "${$0}". This bug is (mostly) fixed in Perl 5.004. | |
1763 | ||
1764 | However, the developers of Perl 5.004 could not fix this bug completely, | |
1765 | because at least two widely-used modules depend on the old meaning of | |
1766 | "$$0" in a string. So Perl 5.004 still interprets "$$<digit>" in the | |
1767 | old (broken) way inside strings; but it generates this message as a | |
1768 | warning. And in Perl 5.005, this special treatment will cease. | |
1769 | ||
1770 | =back | |
3175b8cd | 1771 | |
ba8251e8 GS |
1772 | =head1 BUGS |
1773 | ||
1774 | If you find what you think is a bug, you might check the headers of | |
14218588 | 1775 | articles recently posted to the comp.lang.perl.misc newsgroup. |
ba8251e8 GS |
1776 | There may also be information at http://www.perl.com/perl/, the Perl |
1777 | Home Page. | |
1778 | ||
1779 | If you believe you have an unreported bug, please run the B<perlbug> | |
14218588 | 1780 | program included with your release. Make sure to trim your bug down |
ba8251e8 | 1781 | to a tiny but sufficient test case. Your bug report, along with the |
14218588 | 1782 | output of C<perl -V>, will be sent off to perlbug@perl.com to be |
ba8251e8 GS |
1783 | analysed by the Perl porting team. |
1784 | ||
1785 | =head1 SEE ALSO | |
1786 | ||
1787 | The F<Changes> file for exhaustive details on what changed. | |
1788 | ||
1789 | The F<INSTALL> file for how to build Perl. | |
1790 | ||
1791 | The F<README> file for general stuff. | |
1792 | ||
1793 | The F<Artistic> and F<Copying> files for copyright information. | |
1794 | ||
1795 | =head1 HISTORY | |
1796 | ||
a5222a85 GS |
1797 | Written by Gurusamy Sarathy <F<gsar@activestate.com>>, with many |
1798 | contributions from The Perl Porters. | |
ba8251e8 GS |
1799 | |
1800 | Send omissions or corrections to <F<perlbug@perl.com>>. | |
1801 | ||
1802 | =cut |