Commit | Line | Data |
---|---|---|
0453d815 | 1 | =head1 NAME |
d74e8afc | 2 | X<warning, lexical> X<warnings> X<warning> |
0453d815 PM |
3 | |
4 | perllexwarn - Perl Lexical Warnings | |
5 | ||
6 | =head1 DESCRIPTION | |
5a3e7812 | 7 | |
00eb3f2b | 8 | The C<use warnings> pragma enables to control precisely what warnings are |
598bcb82 | 9 | to be enabled in which parts of a Perl program. It's a more flexible |
00eb3f2b RGS |
10 | alternative for both the command line flag B<-w> and the equivalent Perl |
11 | variable, C<$^W>. | |
0453d815 | 12 | |
00eb3f2b | 13 | This pragma works just like the C<strict> pragma. |
0453d815 | 14 | This means that the scope of the warning pragma is limited to the |
598bcb82 FC |
15 | enclosing block. It also means that the pragma setting will not |
16 | leak across files (via C<use>, C<require> or C<do>). This allows | |
0453d815 PM |
17 | authors to independently define the degree of warning checks that will |
18 | be applied to their module. | |
19 | ||
20 | By default, optional warnings are disabled, so any legacy code that | |
21 | doesn't attempt to control the warnings will work unchanged. | |
22 | ||
23 | All warnings are enabled in a block by either of these: | |
c47ff5f1 | 24 | |
4358a253 SS |
25 | use warnings; |
26 | use warnings 'all'; | |
c47ff5f1 | 27 | |
0453d815 PM |
28 | Similarly all warnings are disabled in a block by either of these: |
29 | ||
4358a253 SS |
30 | no warnings; |
31 | no warnings 'all'; | |
0453d815 PM |
32 | |
33 | For example, consider the code below: | |
34 | ||
4358a253 SS |
35 | use warnings; |
36 | my @a; | |
0453d815 | 37 | { |
4358a253 SS |
38 | no warnings; |
39 | my $b = @a[0]; | |
0453d815 | 40 | } |
f1f33818 | 41 | my $c = @a[0]; |
0453d815 PM |
42 | |
43 | The code in the enclosing block has warnings enabled, but the inner | |
598bcb82 | 44 | block has them disabled. In this case that means the assignment to the |
f1f33818 PM |
45 | scalar C<$c> will trip the C<"Scalar value @a[0] better written as $a[0]"> |
46 | warning, but the assignment to the scalar C<$b> will not. | |
0453d815 PM |
47 | |
48 | =head2 Default Warnings and Optional Warnings | |
49 | ||
50 | Before the introduction of lexical warnings, Perl had two classes of | |
51 | warnings: mandatory and optional. | |
52 | ||
53 | As its name suggests, if your code tripped a mandatory warning, you | |
54 | would get a warning whether you wanted it or not. | |
252aa082 JH |
55 | For example, the code below would always produce an C<"isn't numeric"> |
56 | warning about the "2:". | |
0453d815 | 57 | |
252aa082 | 58 | my $a = "2:" + 3; |
0453d815 | 59 | |
0453d815 | 60 | With the introduction of lexical warnings, mandatory warnings now become |
598bcb82 | 61 | I<default> warnings. The difference is that although the previously |
0453d815 | 62 | mandatory warnings are still enabled by default, they can then be |
598bcb82 | 63 | subsequently enabled or disabled with the lexical warning pragma. For |
e476b1b5 | 64 | example, in the code below, an C<"isn't numeric"> warning will only |
0453d815 PM |
65 | be reported for the C<$a> variable. |
66 | ||
252aa082 | 67 | my $a = "2:" + 3; |
4358a253 | 68 | no warnings; |
252aa082 | 69 | my $b = "2:" + 3; |
0453d815 PM |
70 | |
71 | Note that neither the B<-w> flag or the C<$^W> can be used to | |
598bcb82 | 72 | disable/enable default warnings. They are still mandatory in this case. |
0453d815 PM |
73 | |
74 | =head2 What's wrong with B<-w> and C<$^W> | |
75 | ||
76 | Although very useful, the big problem with using B<-w> on the command | |
598bcb82 FC |
77 | line to enable warnings is that it is all or nothing. Take the typical |
78 | scenario when you are writing a Perl program. Parts of the code you | |
0453d815 | 79 | will write yourself, but it's very likely that you will make use of |
598bcb82 | 80 | pre-written Perl modules. If you use the B<-w> flag in this case, you |
0453d815 PM |
81 | end up enabling warnings in pieces of code that you haven't written. |
82 | ||
83 | Similarly, using C<$^W> to either disable or enable blocks of code is | |
598bcb82 FC |
84 | fundamentally flawed. For a start, say you want to disable warnings in |
85 | a block of code. You might expect this to be enough to do the trick: | |
0453d815 PM |
86 | |
87 | { | |
4358a253 SS |
88 | local ($^W) = 0; |
89 | my $a =+ 2; | |
90 | my $b; chop $b; | |
0453d815 PM |
91 | } |
92 | ||
93 | When this code is run with the B<-w> flag, a warning will be produced | |
ac036724 | 94 | for the C<$a> line: C<"Reversed += operator">. |
0453d815 | 95 | |
598bcb82 | 96 | The problem is that Perl has both compile-time and run-time warnings. To |
0453d815 PM |
97 | disable compile-time warnings you need to rewrite the code like this: |
98 | ||
99 | { | |
100 | BEGIN { $^W = 0 } | |
4358a253 SS |
101 | my $a =+ 2; |
102 | my $b; chop $b; | |
0453d815 PM |
103 | } |
104 | ||
f1f33818 | 105 | The other big problem with C<$^W> is the way you can inadvertently |
598bcb82 | 106 | change the warning setting in unexpected places in your code. For example, |
0453d815 PM |
107 | when the code below is run (without the B<-w> flag), the second call |
108 | to C<doit> will trip a C<"Use of uninitialized value"> warning, whereas | |
109 | the first will not. | |
110 | ||
111 | sub doit | |
112 | { | |
4358a253 | 113 | my $b; chop $b; |
0453d815 PM |
114 | } |
115 | ||
4358a253 | 116 | doit(); |
0453d815 PM |
117 | |
118 | { | |
4358a253 | 119 | local ($^W) = 1; |
0453d815 PM |
120 | doit() |
121 | } | |
122 | ||
123 | This is a side-effect of C<$^W> being dynamically scoped. | |
124 | ||
125 | Lexical warnings get around these limitations by allowing finer control | |
126 | over where warnings can or can't be tripped. | |
127 | ||
128 | =head2 Controlling Warnings from the Command Line | |
129 | ||
130 | There are three Command Line flags that can be used to control when | |
131 | warnings are (or aren't) produced: | |
132 | ||
133 | =over 5 | |
134 | ||
135 | =item B<-w> | |
d74e8afc | 136 | X<-w> |
0453d815 | 137 | |
598bcb82 | 138 | This is the existing flag. If the lexical warnings pragma is B<not> |
0453d815 | 139 | used in any of you code, or any of the modules that you use, this flag |
598bcb82 | 140 | will enable warnings everywhere. See L<Backward Compatibility> for |
0453d815 PM |
141 | details of how this flag interacts with lexical warnings. |
142 | ||
143 | =item B<-W> | |
d74e8afc | 144 | X<-W> |
c47ff5f1 | 145 | |
0453d815 PM |
146 | If the B<-W> flag is used on the command line, it will enable all warnings |
147 | throughout the program regardless of whether warnings were disabled | |
598bcb82 FC |
148 | locally using C<no warnings> or C<$^W =0>. |
149 | This includes all files that get | |
0453d815 PM |
150 | included via C<use>, C<require> or C<do>. |
151 | Think of it as the Perl equivalent of the "lint" command. | |
152 | ||
153 | =item B<-X> | |
d74e8afc | 154 | X<-X> |
0453d815 PM |
155 | |
156 | Does the exact opposite to the B<-W> flag, i.e. it disables all warnings. | |
157 | ||
158 | =back | |
159 | ||
160 | =head2 Backward Compatibility | |
161 | ||
1dc2b704 | 162 | If you are used to working with a version of Perl prior to the |
0453d815 PM |
163 | introduction of lexically scoped warnings, or have code that uses both |
164 | lexical warnings and C<$^W>, this section will describe how they interact. | |
165 | ||
166 | How Lexical Warnings interact with B<-w>/C<$^W>: | |
5a3e7812 | 167 | |
0453d815 PM |
168 | =over 5 |
169 | ||
170 | =item 1. | |
171 | ||
172 | If none of the three command line flags (B<-w>, B<-W> or B<-X>) that | |
1dc2b704 | 173 | control warnings is used and neither C<$^W> nor the C<warnings> pragma |
e476b1b5 GS |
174 | are used, then default warnings will be enabled and optional warnings |
175 | disabled. | |
0453d815 PM |
176 | This means that legacy code that doesn't attempt to control the warnings |
177 | will work unchanged. | |
178 | ||
179 | =item 2. | |
180 | ||
598bcb82 | 181 | The B<-w> flag just sets the global C<$^W> variable as in 5.005. This |
0453d815 PM |
182 | means that any legacy code that currently relies on manipulating C<$^W> |
183 | to control warning behavior will still work as is. | |
184 | ||
185 | =item 3. | |
c47ff5f1 | 186 | |
0453d815 PM |
187 | Apart from now being a boolean, the C<$^W> variable operates in exactly |
188 | the same horrible uncontrolled global way, except that it cannot | |
189 | disable/enable default warnings. | |
190 | ||
191 | =item 4. | |
c47ff5f1 | 192 | |
e476b1b5 | 193 | If a piece of code is under the control of the C<warnings> pragma, |
0453d815 PM |
194 | both the C<$^W> variable and the B<-w> flag will be ignored for the |
195 | scope of the lexical warning. | |
196 | ||
197 | =item 5. | |
c47ff5f1 | 198 | |
0453d815 PM |
199 | The only way to override a lexical warnings setting is with the B<-W> |
200 | or B<-X> command line flags. | |
201 | ||
202 | =back | |
203 | ||
106325ad | 204 | The combined effect of 3 & 4 is that it will allow code which uses |
e476b1b5 | 205 | the C<warnings> pragma to control the warning behavior of $^W-type |
0453d815 PM |
206 | code (using a C<local $^W=0>) if it really wants to, but not vice-versa. |
207 | ||
0453d815 | 208 | =head2 Category Hierarchy |
d74e8afc | 209 | X<warning, categories> |
c47ff5f1 | 210 | |
e476b1b5 GS |
211 | A hierarchy of "categories" have been defined to allow groups of warnings |
212 | to be enabled/disabled in isolation. | |
213 | ||
214 | The current hierarchy is: | |
215 | ||
f2a78a48 FC |
216 | =for comment |
217 | This tree is generated by regen/warnings.pl. Any changes made here | |
218 | will be lost. | |
219 | ||
220 | =for warnings.pl begin | |
221 | ||
6f87cb12 FC |
222 | all -+ |
223 | | | |
224 | +- closure | |
225 | | | |
226 | +- deprecated | |
227 | | | |
228 | +- exiting | |
229 | | | |
f1d34ca8 FC |
230 | +- experimental --+ |
231 | | | | |
d401967c | 232 | | +- experimental::autoderef |
0953b66b | 233 | | | |
f1d34ca8 | 234 | | +- experimental::lexical_subs |
f2a78a48 FC |
235 | | | |
236 | | +- experimental::lexical_topic | |
237 | | | | |
1f25714a FC |
238 | | +- experimental::postderef |
239 | | | | |
f2a78a48 FC |
240 | | +- experimental::regex_sets |
241 | | | | |
30d9c59b Z |
242 | | +- experimental::signatures |
243 | | | | |
f2a78a48 | 244 | | +- experimental::smartmatch |
6f87cb12 FC |
245 | | |
246 | +- glob | |
247 | | | |
248 | +- imprecision | |
249 | | | |
250 | +- io ------------+ | |
251 | | | | |
252 | | +- closed | |
253 | | | | |
254 | | +- exec | |
255 | | | | |
256 | | +- layer | |
257 | | | | |
258 | | +- newline | |
259 | | | | |
260 | | +- pipe | |
261 | | | | |
c8028aa6 TC |
262 | | +- syscalls |
263 | | | | |
6f87cb12 FC |
264 | | +- unopened |
265 | | | |
266 | +- misc | |
267 | | | |
268 | +- numeric | |
269 | | | |
270 | +- once | |
271 | | | |
272 | +- overflow | |
273 | | | |
274 | +- pack | |
275 | | | |
276 | +- portable | |
277 | | | |
278 | +- recursion | |
279 | | | |
280 | +- redefine | |
281 | | | |
282 | +- regexp | |
283 | | | |
284 | +- severe --------+ | |
285 | | | | |
286 | | +- debugging | |
287 | | | | |
288 | | +- inplace | |
289 | | | | |
290 | | +- internal | |
291 | | | | |
292 | | +- malloc | |
293 | | | |
294 | +- signal | |
295 | | | |
296 | +- substr | |
297 | | | |
298 | +- syntax --------+ | |
299 | | | | |
300 | | +- ambiguous | |
301 | | | | |
302 | | +- bareword | |
303 | | | | |
304 | | +- digit | |
305 | | | | |
306 | | +- illegalproto | |
307 | | | | |
308 | | +- parenthesis | |
309 | | | | |
310 | | +- precedence | |
311 | | | | |
312 | | +- printf | |
313 | | | | |
314 | | +- prototype | |
315 | | | | |
316 | | +- qw | |
317 | | | | |
318 | | +- reserved | |
319 | | | | |
320 | | +- semicolon | |
321 | | | |
322 | +- taint | |
323 | | | |
324 | +- threads | |
325 | | | |
326 | +- uninitialized | |
327 | | | |
328 | +- unpack | |
329 | | | |
330 | +- untie | |
331 | | | |
332 | +- utf8 ----------+ | |
333 | | | | |
334 | | +- non_unicode | |
335 | | | | |
336 | | +- nonchar | |
337 | | | | |
338 | | +- surrogate | |
339 | | | |
340 | +- void | |
0453d815 | 341 | |
f2a78a48 FC |
342 | =for warnings.pl end |
343 | ||
4438c4b7 JH |
344 | Just like the "strict" pragma any of these categories can be combined |
345 | ||
4358a253 SS |
346 | use warnings qw(void redefine); |
347 | no warnings qw(io syntax untie); | |
4438c4b7 JH |
348 | |
349 | Also like the "strict" pragma, if there is more than one instance of the | |
e476b1b5 | 350 | C<warnings> pragma in a given scope the cumulative effect is additive. |
4438c4b7 | 351 | |
4358a253 | 352 | use warnings qw(void); # only "void" warnings enabled |
4438c4b7 | 353 | ... |
4358a253 | 354 | use warnings qw(io); # only "void" & "io" warnings enabled |
4438c4b7 | 355 | ... |
4358a253 | 356 | no warnings qw(void); # only "io" warnings enabled |
4438c4b7 | 357 | |
e476b1b5 GS |
358 | To determine which category a specific warning has been assigned to see |
359 | L<perldiag>. | |
0453d815 | 360 | |
3ac2191a | 361 | Note: Before Perl 5.8.0, the lexical warnings category "deprecated" was a |
598bcb82 | 362 | sub-category of the "syntax" category. It is now a top-level category |
12bcd1a6 PM |
363 | in its own right. |
364 | ||
0453d815 | 365 | =head2 Fatal Warnings |
d74e8afc | 366 | X<warning, fatal> |
c47ff5f1 | 367 | |
0453d815 | 368 | The presence of the word "FATAL" in the category list will escalate any |
e476b1b5 | 369 | warnings detected from the categories specified in the lexical scope |
598bcb82 | 370 | into fatal errors. In the code below, the use of C<time>, C<length> |
f1f33818 PM |
371 | and C<join> can all produce a C<"Useless use of xxx in void context"> |
372 | warning. | |
4438c4b7 | 373 | |
4358a253 | 374 | use warnings; |
cea6626f | 375 | |
4358a253 | 376 | time; |
cea6626f | 377 | |
0453d815 | 378 | { |
4358a253 SS |
379 | use warnings FATAL => qw(void); |
380 | length "abc"; | |
0453d815 | 381 | } |
cea6626f | 382 | |
4358a253 | 383 | join "", 1,2,3; |
cea6626f | 384 | |
4358a253 | 385 | print "done\n"; |
f1f33818 PM |
386 | |
387 | When run it produces this output | |
388 | ||
389 | Useless use of time in void context at fatal line 3. | |
390 | Useless use of length in void context at fatal line 7. | |
391 | ||
392 | The scope where C<length> is used has escalated the C<void> warnings | |
e214621b | 393 | category into a fatal error, so the program terminates immediately when it |
f1f33818 | 394 | encounters the warning. |
c47ff5f1 | 395 | |
6e9af7e4 PM |
396 | To explicitly turn off a "FATAL" warning you just disable the warning |
397 | it is associated with. So, for example, to disable the "void" warning | |
398 | in the example above, either of these will do the trick: | |
08540116 PM |
399 | |
400 | no warnings qw(void); | |
401 | no warnings FATAL => qw(void); | |
0453d815 | 402 | |
6e9af7e4 | 403 | If you want to downgrade a warning that has been escalated into a fatal |
598bcb82 | 404 | error back to a normal warning, you can use the "NONFATAL" keyword. For |
6e9af7e4 PM |
405 | example, the code below will promote all warnings into fatal errors, |
406 | except for those in the "syntax" category. | |
407 | ||
408 | use warnings FATAL => 'all', NONFATAL => 'syntax'; | |
409 | ||
c91312d5 H |
410 | As of Perl 5.20, instead of C<< use warnings FATAL => 'all'; >> you can |
411 | use: | |
412 | ||
b2818f92 KW |
413 | use v5.20; # Perl 5.20 or greater is required for the following |
414 | use warnings 'FATAL'; # short form of "use warnings FATAL => 'all';" | |
c91312d5 H |
415 | |
416 | If you want your program to be compatible with versions of Perl before | |
417 | 5.20, you must use C<< use warnings FATAL => 'all'; >> instead. (In | |
418 | previous versions of Perl, the behavior of the statements | |
419 | C<< use warnings 'FATAL'; >>, C<< use warnings 'NONFATAL'; >> and | |
420 | C<< no warnings 'FATAL'; >> was unspecified; they did not behave as if | |
421 | they included the C<< => 'all' >> portion. As of 5.20, they do.) | |
422 | ||
e9158b84 FC |
423 | B<NOTE:> Users of FATAL warnings, especially |
424 | those using C<< FATAL => 'all' >> | |
5e0ced9c | 425 | should be fully aware that they are risking future portability of their |
598bcb82 | 426 | programs by doing so. Perl makes absolutely no commitments to not |
5e0ced9c | 427 | introduce new warnings, or warnings categories in the future, and indeed |
598bcb82 | 428 | we explicitly reserve the right to do so. Code that may not warn now may |
5e0ced9c YO |
429 | warn in a future release of Perl if the Perl5 development team deems it |
430 | in the best interests of the community to do so. Should code using FATAL | |
431 | warnings break due to the introduction of a new warning we will NOT | |
598bcb82 | 432 | consider it an incompatible change. Users of FATAL warnings should take |
5e0ced9c YO |
433 | special caution during upgrades to check to see if their code triggers |
434 | any new warnings and should pay particular attention to the fine print of | |
435 | the documentation of the features they use to ensure they do not exploit | |
436 | features that are documented as risky, deprecated, or unspecified, or where | |
437 | the documentation says "so don't do that", or anything with the same sense | |
598bcb82 | 438 | and spirit. Use of such features in combination with FATAL warnings is |
e9158b84 | 439 | ENTIRELY AT THE USER'S RISK. |
5e0ced9c | 440 | |
e476b1b5 | 441 | =head2 Reporting Warnings from a Module |
d74e8afc | 442 | X<warning, reporting> X<warning, registering> |
e476b1b5 | 443 | |
d3a7d8c7 | 444 | The C<warnings> pragma provides a number of functions that are useful for |
598bcb82 | 445 | module authors. These are used when you want to report a module-specific |
7e6d00f8 | 446 | warning to a calling module has enabled warnings via the C<warnings> |
d3a7d8c7 | 447 | pragma. |
e476b1b5 | 448 | |
d3a7d8c7 | 449 | Consider the module C<MyMod::Abc> below. |
e476b1b5 | 450 | |
d3a7d8c7 | 451 | package MyMod::Abc; |
e476b1b5 | 452 | |
d3a7d8c7 GS |
453 | use warnings::register; |
454 | ||
455 | sub open { | |
4358a253 | 456 | my $path = shift; |
7ddf7bb5 | 457 | if ($path !~ m#^/#) { |
2359510d | 458 | warnings::warn("changing relative path to /var/abc") |
7ddf7bb5 | 459 | if warnings::enabled(); |
2359510d | 460 | $path = "/var/abc/$path"; |
d3a7d8c7 GS |
461 | } |
462 | } | |
463 | ||
4358a253 | 464 | 1; |
d3a7d8c7 GS |
465 | |
466 | The call to C<warnings::register> will create a new warnings category | |
c901ad27 | 467 | called "MyMod::Abc", i.e. the new category name matches the current |
598bcb82 FC |
468 | package name. The C<open> function in the module will display a warning |
469 | message if it gets given a relative path as a parameter. This warnings | |
7e6d00f8 PM |
470 | will only be displayed if the code that uses C<MyMod::Abc> has actually |
471 | enabled them with the C<warnings> pragma like below. | |
d3a7d8c7 GS |
472 | |
473 | use MyMod::Abc; | |
474 | use warnings 'MyMod::Abc'; | |
475 | ... | |
476 | abc::open("../fred.txt"); | |
477 | ||
478 | It is also possible to test whether the pre-defined warnings categories are | |
598bcb82 | 479 | set in the calling module with the C<warnings::enabled> function. Consider |
d3a7d8c7 GS |
480 | this snippet of code: |
481 | ||
482 | package MyMod::Abc; | |
483 | ||
484 | sub open { | |
7e6d00f8 | 485 | warnings::warnif("deprecated", |
4358a253 SS |
486 | "open is deprecated, use new instead"); |
487 | new(@_); | |
e476b1b5 | 488 | } |
6bc102ca | 489 | |
e476b1b5 GS |
490 | sub new |
491 | ... | |
4358a253 | 492 | 1; |
e476b1b5 GS |
493 | |
494 | The function C<open> has been deprecated, so code has been included to | |
495 | display a warning message whenever the calling module has (at least) the | |
598bcb82 | 496 | "deprecated" warnings category enabled. Something like this, say. |
e476b1b5 GS |
497 | |
498 | use warnings 'deprecated'; | |
d3a7d8c7 | 499 | use MyMod::Abc; |
e476b1b5 | 500 | ... |
4358a253 | 501 | MyMod::Abc::open($filename); |
e476b1b5 | 502 | |
7e6d00f8 | 503 | Either the C<warnings::warn> or C<warnings::warnif> function should be |
598bcb82 | 504 | used to actually display the warnings message. This is because they can |
7e6d00f8 | 505 | make use of the feature that allows warnings to be escalated into fatal |
598bcb82 | 506 | errors. So in this case |
e476b1b5 | 507 | |
d3a7d8c7 GS |
508 | use MyMod::Abc; |
509 | use warnings FATAL => 'MyMod::Abc'; | |
e476b1b5 | 510 | ... |
d3a7d8c7 | 511 | MyMod::Abc::open('../fred.txt'); |
e476b1b5 | 512 | |
7e6d00f8 | 513 | the C<warnings::warnif> function will detect this and die after |
d3a7d8c7 | 514 | displaying the warning message. |
e476b1b5 | 515 | |
7e6d00f8 PM |
516 | The three warnings functions, C<warnings::warn>, C<warnings::warnif> |
517 | and C<warnings::enabled> can optionally take an object reference in place | |
598bcb82 | 518 | of a category name. In this case the functions will use the class name |
7e6d00f8 PM |
519 | of the object as the warnings category. |
520 | ||
521 | Consider this example: | |
522 | ||
4358a253 | 523 | package Original; |
7e6d00f8 | 524 | |
4358a253 SS |
525 | no warnings; |
526 | use warnings::register; | |
7e6d00f8 PM |
527 | |
528 | sub new | |
529 | { | |
4358a253 SS |
530 | my $class = shift; |
531 | bless [], $class; | |
7e6d00f8 PM |
532 | } |
533 | ||
534 | sub check | |
535 | { | |
4358a253 SS |
536 | my $self = shift; |
537 | my $value = shift; | |
7e6d00f8 PM |
538 | |
539 | if ($value % 2 && warnings::enabled($self)) | |
540 | { warnings::warn($self, "Odd numbers are unsafe") } | |
541 | } | |
542 | ||
543 | sub doit | |
544 | { | |
4358a253 SS |
545 | my $self = shift; |
546 | my $value = shift; | |
547 | $self->check($value); | |
7e6d00f8 PM |
548 | # ... |
549 | } | |
550 | ||
4358a253 | 551 | 1; |
7e6d00f8 | 552 | |
4358a253 | 553 | package Derived; |
7e6d00f8 | 554 | |
4358a253 SS |
555 | use warnings::register; |
556 | use Original; | |
557 | our @ISA = qw( Original ); | |
7e6d00f8 PM |
558 | sub new |
559 | { | |
4358a253 SS |
560 | my $class = shift; |
561 | bless [], $class; | |
7e6d00f8 PM |
562 | } |
563 | ||
13a2d996 | 564 | |
4358a253 | 565 | 1; |
7e6d00f8 PM |
566 | |
567 | The code below makes use of both modules, but it only enables warnings from | |
568 | C<Derived>. | |
569 | ||
4358a253 SS |
570 | use Original; |
571 | use Derived; | |
7e6d00f8 | 572 | use warnings 'Derived'; |
63acfd00 | 573 | my $a = Original->new(); |
4358a253 | 574 | $a->doit(1); |
63acfd00 | 575 | my $b = Derived->new(); |
4358a253 | 576 | $a->doit(1); |
7e6d00f8 PM |
577 | |
578 | When this code is run only the C<Derived> object, C<$b>, will generate | |
579 | a warning. | |
580 | ||
581 | Odd numbers are unsafe at main.pl line 7 | |
582 | ||
583 | Notice also that the warning is reported at the line where the object is first | |
584 | used. | |
585 | ||
572bfd36 RS |
586 | When registering new categories of warning, you can supply more names to |
587 | warnings::register like this: | |
588 | ||
589 | package MyModule; | |
590 | use warnings::register qw(format precision); | |
591 | ||
592 | ... | |
593 | ||
594 | warnings::warnif('MyModule::format', '...'); | |
595 | ||
0453d815 PM |
596 | =head1 SEE ALSO |
597 | ||
e476b1b5 | 598 | L<warnings>, L<perldiag>. |
c47ff5f1 | 599 | |
0453d815 | 600 | =head1 AUTHOR |
c47ff5f1 | 601 | |
0453d815 | 602 | Paul Marquess |