Perl Cd Bookshelf [Electronic resources] نسخه متنی

12.12. Overriding Built-in Functions

12.12.1. Problem

You want to replace a
standard, built-in function with your own version.

12.12.2. Solution

Import that function from another module into your own namespace.

12.12.3. Discussion

Suppose you want to give a function of your own the same name as one
of Perl''s core built-ins. If you write:

sub time { "it''s howdy doody time" }
print time( );

then you won''t get your function called—you''ll still get Perl''s
original, built-in version. You could use an explicit ampersand to
call the function:

print &time( );

because that always gets your function, never the built-in. But then
you forego any prototype checking and context coercion on the
function''s arguments. However, there is a way to
override that.

Many (but not all) of Perl''s built-in functions may be overridden.
This is not something to be attempted lightly, but it is possible.
You might do this, for example, if you are running on a platform that
doesn''t support the function that you''d like to emulate. Or, you
might want to add your own wrapper around the built-in.

Not all reserved words have the same status. Those that return a
negative number in the C-language keyword( )
function in the toke.c file in your Perl source
kit may be overridden. Keywords that cannot be overridden as of
v5.8.1 are defined, delete,
do, else,
elsif, eval,
exists, for,
foreach, format,
glob, goto,
grep, if,
last, local,
m, map, my,
next, no,
our, package,
pos, print,
printf, prototype,
q, qq, qr,
qw, qx,
redo, require,
return, s,
scalar, sort,
split, study,
sub, tie,
tied, tr,
undef, unless,
untie, until,
use, while, and
y. The rest can.

A standard Perl
module that overrides a built-in is Cwd, which can overload
chdir. Others are the by-name versions of
functions that return lists: File::stat, Net::hostent, Net::netent,
Net::protoent, Net::servent, Time::gmtime, Time::localtime, Time::tm,
User::grent, and User::pwent. These modules all override built-in
functions like stat or getpwnam
to return an object that can be accessed using a name, like
getpwnam("daemon")->dir. To do this, they have
to override the original, list-returning versions of those functions.

Overriding may be done uniquely by importing the function from
another package. This import only takes effect in the importing
package, not in all possible packages. It''s not enough simply to
predeclare the function. You have to import it. This is a guard
against accidentally redefining built-ins.

Let''s say that you''d like to replace the built-in
time function, whose return value is in integer
seconds, with one that returns a floating-point number instead. You
could make a Time::HiRes module with an optionally exported
time function as follows:

package Time::HiRes;
use strict;
require Exporter;
use vars qw(@ISA @EXPORT_OK);
@ISA = qw(Exporter);
@EXPORT_OK = qw(time);
sub time( ) { ..... }  # TBA

Then the user who wants to use this augmented version of
time would say something like:

use Time::HiRes qw(time);
$start = time( );
1 while print time( ) - $start, "\n";

This code assumes that your system has a function you can stick in
the "TBA" definition shown previously. It just so happens, however,
that you don''t have to figure that part out, because the Time::HiRes
module (which is included standard with the Perl distribution) does
indeed behave as we''ve outlined it here. You can import its
time( ) function to get the one that is fancier
than the core built-in, just as we did here.

If you don''t want to take the trouble to create a full module file,
set up its exports, and all the rest of the rigamarole, there''s a
shortcut approach via the subs pragma. It works
like this:

use subs qw(time);
sub time { "it''s howdy doody time" }
print time( );

Now you''d get your own function, even without the ampersand.

Even when you override a built-in by importing a function, that
built-in is always still accessible if you fully qualify it using the
(pseudo)package named CORE. Thus, even if you imported time(
) from FineTime, overriding the built-in, that original
built-in can be called as CORE::time( ).

For overriding of methods and operators, see Chapter 13.

12.12.4. See Also

The section on "Overriding Built-in Functions" in Chapter 11 of
Programming Perl and in
perlsub(1); Recipe 10.11