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