Seth Woolley's Man Viewer

re(3)                  Perl Programmers Reference Guide                  re(3)



NAME
       re - Perl pragma to alter regular expression behaviour

SYNOPSIS
           use re 'taint';
           ($x) = ($^X =~ /^(.*)$/s);     # $x is tainted here

           $pat = '(?{ $foo = 1 })';
           use re 'eval';
           /foo${pat}bar/;                # won't fail (when not under -T switch(1,n))

           {
               no re 'taint';             # the default
               ($x) = ($^X =~ /^(.*)$/s); # $x is not tainted here

               no re 'eval';              # the default
               /foo${pat}bar/;            # disallowed (with or without -T switch(1,n))
           }

           use re 'debug';                # NOT lexically scoped (as others are)
           /^(.*)$/s;                     # output debugging info(1,5,n) during
                                          #     compile and run time(1,2,n)

           use re 'debugcolor';           # same as 'debug', but with colored output
           ...

       (We use $^X in(1,8) these examples because it's tainted by default.)

DESCRIPTION
       When "use re 'taint'" is in(1,8) effect, and a tainted string(3,n) is the target
       of a regex(3,7), the regex(3,7) memories (or values returned by the m// operator
       in(1,8) list context) are tainted.  This feature is useful when regex(3,7) opera-
       tions on tainted data aren't meant to extract safe substrings, but to
       perform other transformations.

       When "use re 'eval'" is in(1,8) effect, a regex(3,7) is allowed to contain "(?{
       ... })" zero-width assertions even if(3,n) regular expression contains vari-
       able interpolation.  That is normally disallowed, since it is a poten-
       tial security risk.  Note that this pragma is ignored when the regular
       expression is obtained from tainted data, i.e.  evaluation is always
       disallowed with tainted regular expresssions.  See "(?{ code })" in(1,8)
       perlre.

       For the purpose of this pragma, interpolation of precompiled regular
       expressions (i.e., the result of "qr//") is not considered variable
       interpolation.  Thus:

           /foo${pat}bar/

       is allowed if(3,n) $pat is a precompiled regular expression, even if(3,n) $pat
       contains "(?{ ... })" assertions.

       When "use re 'debug'" is in(1,8) effect, perl emits debugging messages when
       compiling and using regular expressions.  The output is the same as
       that obtained by running a "-DDEBUGGING"-enabled perl interpreter with
       the -Dr switch. It may be quite voluminous depending on the complexity
       of the match.  Using "debugcolor" instead of "debug" enables a form of
       output that can be used to get a colorful display on terminals that
       understand termcap color sequences.  Set $ENV{PERL_RE_TC} to a comma-
       separated list of "termcap" properties to use for highlighting strings
       on/off, pre-point part on/off.  See "Debugging regular expressions" in(1,8)
       perldebug for additional info.

       The directive "use re 'debug'" is not lexically scoped, as the other
       directives are.  It has both compile-time and run-time effects.

       See "Pragmatic Modules" in(1,8) perlmodlib.



perl v5.8.5                       2001-09-21                             re(3)