NAME
Filter::Simple - Simplified source filtering
SYNOPSIS
# in MyFilter.pm:
package MyFilter;
use Filter::Simple sub { ... };
# in user's code:
use MyFilter;
# this code is filtered
no MyFilter;
# this code is not
DESCRIPTION
The Problem
Source filtering is an immensely powerful feature of recent versions of Perl. It allows one to extend the language itself (e.g. the Switch module), to simplify the language (e.g. Language::Pythonesque), or to completely recast the language (e.g. Lingua::Romana::Perligata). Effectively, it allows one to use the full power of Perl as its own, recursively applied, macro language.
The excellent Filter::Util::Call module (by Paul Marquess) provides a usable Perl interface to source filtering, but it is often too powerful and not nearly as simple as it could be.
To use the module it is necessary to do the following:
Download, build, and install the Filter::Util::Call module.
Set up a module that does a
use Filter::Util::Call
.Within that module, create an
import
subroutine.Within the
import
subroutine do a call tofilter_add
, passing it either a subroutine reference.Within the subroutine reference, call
filter_read
orfilter_read_exact
to "prime" $_ with source code data from the source file that willuse
your module. Check the status value returned to see if any source code was actually read in.Process the contents of $_ to change the source code in the desired manner.
Return the status value.
If the act of unimporting your module (via a
no
) should cause source code filtering to cease, create anunimport
subroutine, and have it callfilter_del
. Make sure that the call tofilter_read
orfilter_read_exact
in step 5 will not accidentally read past theno
. Effectively this limits source code filters to line-by-line operation, unless theimport
subroutine does some fancy pre-pre-parsing of the source code it's filtering.
For example, here is a minimal source code filter in a module named BANG.pm. It simply converts every occurrence of the sequence BANG\s+BANG
to the sequence die 'BANG' if $BANG
in any piece of code following a use BANG;
statement (until the next no BANG;
statement, if any):
package BANG;
use Filter::Util::Call ;
sub import {
filter_add( sub {
my $caller = caller;
my ($status, $no_seen, $data);
while ($status = filter_read()) {
if (/^\s*no\s+$caller\s*;\s*$/) {
$no_seen=1;
last;
}
$data .= $_;
$_ = "";
}
$_ = $data;
s/BANG\s+BANG/die 'BANG' if \$BANG/g
unless $status < 0;
$_ .= "no $class;\n" if $no_seen;
return 1;
})
}
sub unimport {
filter_del();
}
1 ;
This level of sophistication puts filtering out of the reach of many programmers.
A Solution
The Filter::Simple module provides a simplified interface to Filter::Util::Call; one that is sufficient for most common cases.
Instead of the above process, with Filter::Simple the task of setting up a source code filter is reduced to:
Set up a module that does a
use Filter::Simple sub { ... }
.Within the anonymous subroutine passed to
use Filter::Simple
, process the contents of $_ to change the source code in the desired manner.
In other words, the previous example, would become:
package BANG;
use Filter::Simple sub {
s/BANG\s+BANG/die 'BANG' if \$BANG/g;
};
1 ;
How it works
The Filter::Simple module exports into the package that use
s it (e.g. package "BANG" in the above example) two automagically constructed subroutines -- import
and unimport
-- which take care of all the nasty details.
In addition, the generated import
subroutine passes its own argument list to the filtering subroutine, so the BANG.pm filter could easily be made parametric:
package BANG;
use Filter::Simple sub {
my ($die_msg, $var_name) = @_;
s/BANG\s+BANG/die '$die_msg' if \${$var_name}/g;
};
# and in some user code:
use BANG "BOOM", "BAM; # "BANG BANG" becomes: die 'BOOM' if $BAM
The specified filtering subroutine is called every time a use BANG
is encountered, and passed all the source code following that call, up to either the next no BANG;
call or the end of the source file (whichever occurs first). Currently, any no BANG;
call must appear by itself on a separate line, or it is ignored.
AUTHOR
Damian Conway (damian@conway.org)
COPYRIGHT
Copyright (c) 2000, Damian Conway. All Rights Reserved.
This module is free software. It may be used, redistributed
and/or modified under the terms of the Perl Artistic License
(see http://www.perl.com/perl/misc/Artistic.html)