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