filter::simple.3

视频监控网络部分的协议ddns,的模块的实现代码,请大家大胆指正.

\&    FILTER {
\&        s/BANG\es+BANG/die \*(AqBANG\*(Aq if \e$BANG/g;
\&    }
\&    "";    # or: 0
.Ve
.PP
or:
.PP
.Vb 4
\&    FILTER {
\&        s/BANG\es+BANG/die \*(AqBANG\*(Aq if \e$BANG/g;
\&    }
\&    { terminator => "" };
.Ve
.PP
\&\fBNote that, no matter what you set the terminator pattern to,
the actual terminator itself \f(BImust\fB be contained on a single source line.\fR
.Sh "All-in-one interface"
.IX Subsection "All-in-one interface"
Separating the loading of Filter::Simple:
.PP
.Vb 1
\&    use Filter::Simple;
.Ve
.PP
from the setting up of the filtering:
.PP
.Vb 1
\&    FILTER { ... };
.Ve
.PP
is useful because it allows other code (typically parser support code
or caching variables) to be defined before the filter is invoked.
However, there is often no need for such a separation.
.PP
In those cases, it is easier to just append the filtering subroutine and
any terminator specification directly to the \f(CW\*(C`use\*(C'\fR statement that loads
Filter::Simple, like so:
.PP
.Vb 3
\&    use Filter::Simple sub {
\&        s/BANG\es+BANG/die \*(AqBANG\*(Aq if \e$BANG/g;
\&    };
.Ve
.PP
This is exactly the same as:
.PP
.Vb 6
\&    use Filter::Simple;
\&    BEGIN {
\&        Filter::Simple::FILTER {
\&            s/BANG\es+BANG/die \*(AqBANG\*(Aq if \e$BANG/g;
\&        };
\&    }
.Ve
.PP
except that the \f(CW\*(C`FILTER\*(C'\fR subroutine is not exported by Filter::Simple.
.Sh "Filtering only specific components of source code"
.IX Subsection "Filtering only specific components of source code"
One of the problems with a filter like:
.PP
.Vb 1
\&    use Filter::Simple;
\&
\&    FILTER { s/BANG\es+BANG/die \*(AqBANG\*(Aq if \e$BANG/g };
.Ve
.PP
is that it indiscriminately applies the specified transformation to
the entire text of your source program. So something like:
.PP
.Vb 2
\&    warn \*(AqBANG BANG, YOU\*(AqRE DEAD\*(Aq;
\&    BANG BANG;
.Ve
.PP
will become:
.PP
.Vb 2
\&    warn \*(Aqdie \*(AqBANG\*(Aq if $BANG, YOU\*(AqRE DEAD\*(Aq;
\&    die \*(AqBANG\*(Aq if $BANG;
.Ve
.PP
It is very common when filtering source to only want to apply the filter
to the non-character-string parts of the code, or alternatively to \fIonly\fR
the character strings.
.PP
Filter::Simple supports this type of filtering by automatically
exporting the \f(CW\*(C`FILTER_ONLY\*(C'\fR subroutine.
.PP
\&\f(CW\*(C`FILTER_ONLY\*(C'\fR takes a sequence of specifiers that install separate
(and possibly multiple) filters that act on only parts of the source code.
For example:
.PP
.Vb 1
\&    use Filter::Simple;
\&
\&    FILTER_ONLY
\&        code      => sub { s/BANG\es+BANG/die \*(AqBANG\*(Aq if \e$BANG/g },
\&        quotelike => sub { s/BANG\es+BANG/CHITTY CHITTY/g };
.Ve
.PP
The \f(CW"code"\fR subroutine will only be used to filter parts of the source
code that are not quotelikes, \s-1POD\s0, or \f(CW\*(C`_\|_DATA_\|_\*(C'\fR. The \f(CW\*(C`quotelike\*(C'\fR
subroutine only filters Perl quotelikes (including here documents).
.PP
The full list of alternatives is:
.ie n .IP """code""" 4
.el .IP "\f(CW``code''\fR" 4
.IX Item """code"""
Filters only those sections of the source code that are not quotelikes, \s-1POD\s0, or
\&\f(CW\*(C`_\|_DATA_\|_\*(C'\fR.
.ie n .IP """code_no_comments""" 4
.el .IP "\f(CW``code_no_comments''\fR" 4
.IX Item """code_no_comments"""
Filters only those sections of the source code that are not quotelikes, \s-1POD\s0,
comments, or \f(CW\*(C`_\|_DATA_\|_\*(C'\fR.
.ie n .IP """executable""" 4
.el .IP "\f(CW``executable''\fR" 4
.IX Item """executable"""
Filters only those sections of the source code that are not \s-1POD\s0 or \f(CW\*(C`_\|_DATA_\|_\*(C'\fR.
.ie n .IP """executable_no_comments""" 4
.el .IP "\f(CW``executable_no_comments''\fR" 4
.IX Item """executable_no_comments"""
Filters only those sections of the source code that are not \s-1POD\s0, comments, or \f(CW\*(C`_\|_DATA_\|_\*(C'\fR.
.ie n .IP """quotelike""" 4
.el .IP "\f(CW``quotelike''\fR" 4
.IX Item """quotelike"""
Filters only Perl quotelikes (as interpreted by
\&\f(CW&Text::Balanced::extract_quotelike\fR).
.ie n .IP """string""" 4
.el .IP "\f(CW``string''\fR" 4
.IX Item """string"""
Filters only the string literal parts of a Perl quotelike (i.e. the 
contents of a string literal, either half of a \f(CW\*(C`tr///\*(C'\fR, the second
half of an \f(CW\*(C`s///\*(C'\fR).
.ie n .IP """regex""" 4
.el .IP "\f(CW``regex''\fR" 4
.IX Item """regex"""
Filters only the pattern literal parts of a Perl quotelike (i.e. the 
contents of a \f(CW\*(C`qr//\*(C'\fR or an \f(CW\*(C`m//\*(C'\fR, the first half of an \f(CW\*(C`s///\*(C'\fR).
.ie n .IP """all""" 4
.el .IP "\f(CW``all''\fR" 4
.IX Item """all"""
Filters everything. Identical in effect to \f(CW\*(C`FILTER\*(C'\fR.
.PP
Except for \f(CW\*(C`FILTER_ONLY code => sub {...}\*(C'\fR, each of
the component filters is called repeatedly, once for each component
found in the source code.
.PP
Note that you can also apply two or more of the same type of filter in
a single \f(CW\*(C`FILTER_ONLY\*(C'\fR. For example, here's a simple 
macro-preprocessor that is only applied within regexes,
with a final debugging pass that prints the resulting source code:
.PP
.Vb 6
\&    use Regexp::Common;
\&    FILTER_ONLY
\&        regex => sub { s/!\e[/[^/g },
\&        regex => sub { s/%d/$RE{num}{int}/g },
\&        regex => sub { s/%f/$RE{num}{real}/g },
\&        all   => sub { print if $::DEBUG };
.Ve
.Sh "Filtering only the code parts of source code"
.IX Subsection "Filtering only the code parts of source code"
Most source code ceases to be grammatically correct when it is broken up
into the pieces between string literals and regexes. So the \f(CW\*(Aqcode\*(Aq\fR
and \f(CW\*(Aqcode_no_comments\*(Aq\fR component filter behave slightly differently
from the other partial filters described in the previous section.
.PP
Rather than calling the specified processor on each individual piece of
code (i.e. on the bits between quotelikes), the \f(CW\*(Aqcode...\*(Aq\fR partial
filters operate on the entire source code, but with the quotelike bits
(and, in the case of \f(CW\*(Aqcode_no_comments\*(Aq\fR, the comments) \*(L"blanked out\*(R".
.PP
That is, a \f(CW\*(Aqcode...\*(Aq\fR filter \fIreplaces\fR each quoted string, quotelike,
regex, \s-1POD\s0, and _\|_DATA_\|_ section with a placeholder. The
delimiters of this placeholder are the contents of the \f(CW$;\fR variable
at the time the filter is applied (normally \f(CW"\e034"\fR). The remaining
four bytes are a unique identifier for the component being replaced.
.PP
This approach makes it comparatively easy to write code preprocessors
without worrying about the form or contents of strings, regexes, etc.
.PP
For convenience, during a \f(CW\*(Aqcode...\*(Aq\fR filtering operation, Filter::Simple
provides a package variable (\f(CW$Filter::Simple::placeholder\fR) that
contains a pre-compiled regex that matches any placeholder...and
captures the identifier within the placeholder. Placeholders can be
moved and re-ordered within the source code as needed.
.PP
In addition, a second package variable (\f(CW@Filter::Simple::components\fR)
contains a list of the various pieces of \f(CW$_\fR, as they were originally split
up to allow placeholders to be inserted.
.PP
Once the filtering has been applied, the original strings, regexes, \s-1POD\s0,
etc. are re-inserted into the code, by replacing each placeholder with
the corresponding original component (from \f(CW@components\fR). Note that
this means that the \f(CW@components\fR variable must be treated with extreme
care within the filter. The \f(CW@components\fR array stores the \*(L"back\-
translations\*(R" of each placeholder inserted into \f(CW$_\fR, as well as the
interstitial source code between placeholders. If the placeholder
backtranslations are altered in \f(CW@components\fR, they will be similarly
changed when the placeholders are removed from \f(CW$_\fR after the filter
is complete.
.PP
For example, the following filter detects concatenated pairs of
strings/quotelikes and reverses the order in which they are
concatenated:
.PP
.Vb 2
\&    package DemoRevCat;
\&    use Filter::Simple;
\&
\&    FILTER_ONLY code => sub {
\&        my $ph = $Filter::Simple::placeholder;
\&        s{ ($ph) \es* [.] \es* ($ph) }{ $2.$1 }gx
\&    };
.Ve
.PP
Thus, the following code:
.PP
.Vb 1
\&    use DemoRevCat;
\&
\&    my $str = "abc" . q(def);
\&
\&    print "$str\en";
.Ve
.PP
would become:
.PP
.Vb 1
\&    my $str = q(def)."abc";
\&
\&    print "$str\en";
.Ve
.PP
and hence print:
.PP
.Vb 1
\&    defabc
.Ve
.ie n .Sh "Using Filter::Simple with an explicit ""import"" subroutine"
.el .Sh "Using Filter::Simple with an explicit \f(CWimport\fP subroutine"
.IX Subsection "Using Filter::Simple with an explicit import subroutine"
Filter::Simple generates a special \f(CW\*(C`import\*(C'\fR subroutine for
your module (see \*(L"How it works\*(R") which would normally replace any
\&\f(CW\*(C`import\*(C'\fR subroutine you might have explicitly declared.
.PP
However, Filter::Simple is smart enough to notice your existing
\&\f(CW\*(C`import\*(C'\fR and Do The Right Thing with it.
That is, if you explicitly define an \f(CW\*(C`import\*(C'\fR subroutine in a package
that's using Filter::Simple, that \f(CW\*(C`import\*(C'\fR subroutine will still
be invoked immediately after any filter you install.
.PP
The only thing you have to remember is that the \f(CW\*(C`import\*(C'\fR subroutine
\&\fImust\fR be declared \fIbefore\fR the filter is installed. If you use \f(CW\*(C`FILTER\*(C'\fR
to install the filter:
.PP
.Vb 1
\&    package Filter::TurnItUpTo11;
\&
\&    use Filter::Simple;
\&
\&    FILTER { s/(\ew+)/\eU$1/ };
.Ve
.PP
that will almost never be a problem, but if you install a filtering
subroutine by passing it directly to the \f(CW\*(C`use Filter::Simple\*(C'\fR
statement:
.PP
.Vb 1
\&    package Filter::TurnItUpTo11;
\&
\&    use Filter::Simple sub{ s/(\ew+)/\eU$1/ };
.Ve
.PP
then you must make sure that your \f(CW\*(C`import\*(C'\fR subroutine appears before
that \f(CW\*(C`use\*(C'\fR statement.
.Sh "Using Filter::Simple and Exporter together"
.IX Subsection "Using Filter::Simple and Exporter together"
Likewise, Filter::Simple is also smart enough
to Do The Right Thing if you use Exporter:
.PP
.Vb 3
\&    package Switch;
\&    use base Exporter;
\&    use Filter::Simple;
\&
\&    @EXPORT    = qw(switch case);
\&    @EXPORT_OK = qw(given  when);
\&
\&    FILTER { $_ = magic_Perl_filter($_) }
.Ve
.PP
Immediately after the filter has been applied to the source,
Filter::Simple will pass control to Exporter, so it can do its magic too.
.PP
Of course, here too, Filter::Simple has to know you're using Exporter
before it applies the filter. That's almost never a problem, but if you're
nervous about it, you can guarantee that things will work correctly by
ensuring that your \f(CW\*(C`use base Exporter\*(C'\fR always precedes your
\&\f(CW\*(C`use Filter::Simple\*(C'\fR.
.Sh "How it works"
.IX Subsection "How it works"
The Filter::Simple module exports into the package that calls \f(CW\*(C`FILTER\*(C'\fR
(or \f(CW\*(C`use\*(C'\fRs it directly) \*(-- such as package \*(L"\s-1BANG\s0\*(R" in the above example \*(--
two automagically constructed
subroutines \*(-- \f(CW\*(C`import\*(C'\fR and \f(CW\*(C`unimport\*(C'\fR \*(-- which take care of all the
nasty details.
.PP
In addition, the generated \f(CW\*(C`import\*(C'\fR subroutine passes its own argument
list to the filtering subroutine, so the \s-1BANG\s0.pm filter could easily 
be made parametric:
.PP
.Vb 1
\&    package BANG;
\& 
\&    use Filter::Simple;
\&    
\&    FILTER {
\&        my ($die_msg, $var_name) = @_;
\&        s/BANG\es+BANG/die \*(Aq$die_msg\*(Aq if \e${$var_name}/g;
\&    };
\&
\&    # and in some user code:
\&
\&    use BANG "BOOM", "BAM";  # "BANG BANG" becomes: die \*(AqBOOM\*(Aq if $BAM
.Ve
.PP
The specified filtering subroutine is called every time a \f(CW\*(C`use BANG\*(C'\fR is
encountered, and passed all the source code following that call, up to
either the next \f(CW\*(C`no BANG;\*(C'\fR (or whatever terminator you've set) or the
end of the source file, whichever occurs first. By default, any \f(CW\*(C`no
BANG;\*(C'\fR call must appear by itself on a separate line, or it is ignored.
.SH "AUTHOR"
.IX Header "AUTHOR"
Damian Conway ([e-mail])
.SH "COPYRIGHT"
.IX Header "COPYRIGHT"
.Vb 3
\&    Copyright (c) 2000\-2001, Damian Conway. All Rights Reserved.
\&    This module is free software. It may be used, redistributed
\&    and/or modified under the same terms as Perl itself.
.Ve