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