Assemble multiple Regular Expressions into a single RE
Switch branches/tags
Nothing to show
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Failed to load latest commit information.


This file is the README for Regexp::Assemble version 0.35


perl Makefile.PL
make test
make install


This module requires the following modules for thorough testing:


The test suite will make allowances for their eventual absence.

It can also make use of Devel::Cover if available.


This is a pure-Perl module. The following one-liner should print
out the canonical path of the file:

  perl -MRegexp::Assemble -le 'print $INC{"Regexp/"}'

Just delete this file. There is also the question of the man page.
Finding that is left as an exercise to the reader.


use Regexp::Assemble;

my $ra = Regexp::Assemble->new;
$ra->add( 'ab+c' );
$ra->add( 'ab+\\d*\\s+c' );
$ra->add( 'a\\w+\\d+' );
$ra->add( 'a\\d+' );
print $ra->re; # prints (?:a(?:b+(?:\d*\s+)?c|(?:\w+)?\d+))


my $ra = Regexp::Assemble->new
    ->add( 'foo', 'bar', 'baz', 'foom' );

print "$_ matches\n" if /$ra/
    for (qw/word more stuff food rabble bark/);


use Regexp::Assemble;
my @word = qw/flip flop slip slop/;

print Regexp::Assemble->new->add(@word)->as_string;
    # produces [fs]l[io]p

print Regexp::Assemble->new->add(@word)->reduce(0)->as_string;
    # produces (?:fl(?:ip|op)|sl(?:ip|op))

See the ./eg directory for some example scripts.


If you want to match things with exceptions, you can use a two
stage process to build a pattern with negative lookbehind. Consider
the following script:

== example begin ==
use Regexp::Assemble;

my $set = [
        accept => [qw[ ]],
        refuse => [qw[ ^media video ]],
        accept => [qw[ ]],

my $ra = Regexp::Assemble->new;

for my $s( @$set ) {
    my $refuse = do {
        if( not exists $s->{refuse} ) {
        else {
            . Regexp::Assemble->new->add( @{$s->{refuse}} )->as_string
            . ')'
    $ra->add( map { s/\./\\./g; "$refuse$_\$" } @{$s->{accept}} );

my $re = $ra->re;

print $ra->as_string, "\n";

while( <> ) {
    print "\t", (/$re/ ? 'yep' : 'nope'), "\n";

== example end ==

and a datafile to run it on:

== data begin ==
== data end ==

This lets us match arbitrary hosts within a domain, but at the same
time excluding a subset of hosts that we wish to ignore.


Regexp::Assemble can emit regular expressions that, when used correctly,
can let you determine which original pattern gave rise to the match.
This technique is known as tracking.

== example begin ==

use strict;
use Regexp::Assemble;

my $dispatch = {
    'a-(\\d+)'        => sub { my $v = shift; print "speed $v->[1]\n"; },
    'a-(\\d+)-(\\d+)' => sub { my $v = shift; print "pressure $v->[1] over $v->[2]\n"; },
    'a-(\\w+)-(\\w+)' => sub { my $v = shift; print "message $v->[1] from $v->[2]\n"; },

my $re = Regexp::Assemble->new( track => 1 )->add( keys %$dispatch );

while( <> ) {
    if( $re->match($_) ) {
        $dispatch->{ $re->matched }( $re->mvar() );
    else {
        last if /q/;
        print "\tignored\n";

== example end ==

Run this and enter lines like a-234, a-654, a-345-345, a-dog-cat and so
on. When the pattern matches a string, you can retrieve the pattern
that caused the match to occur, and dispatch it to a routine that knows
what to do about it. You can retrieve captured values too. In the above
example, just remember that $v->[1] eq $1. $v->[0], a.k.a $re->mvar(0)
happens to be the the same as the input parameter to match (although
this is worked out from first principles, more or less, not simply by
copying the parameter).

I initially hoped that $^R would handle this sort of stuff for me, but
there's a bug. Consider the following pattern:

    a(?{1}) (?: b(?{2}) )?

(whitespace added for clarity). This pattern will match both the strings
'a' and 'ab', however, in both cases, $^R will be set to 1 aftewards. I
would have hoped that after matching 'ab', that $^R would be set to 2.

As of perl 5.9.5, this bug has been corrected in the regular expression
engine, thanks to Yves Orton. Version 0.29 takes this into account, and
as a result re 'eval' is no longer required in Perl 5.10.


Consider a simple pattern 'costructive' we want to use to match against
strings. This pattern is split into tokens, and is stored in a list:

  [c o n s t r u c t i v e]

At this point, if we want to produce a regular expression, we only need
to join it up again:

   my $pattern = join( '' => @path);
   my $re = qr/$pattern/;

Consider a second pattern 'containment'. Split into a list gives:

  [c o n t a i n m e n t]

We then have to merge this second path into the first path. At some
point, the paths diverge. The first element path the point of
divergence in the first path is replace by a node (a hash) and the two
different paths carry on from there:

  [c o n
        |s => [s t r u c t i v e]
        \t => [t a i n m e n t]

And then 'confinement':

  [c o n
        |s => [s t r u c t i v e]
        |t => [t a i n m e n t]
        \f => [f i n e m e n t]

What happens if we add a path that runs out in the middle of a
previous path?  We add a node, and a "null-path" to indicate that
the path can both continue on, and can also stop here:

Add 'construct':

  [c o n
        |s => [s t r u c t
        |                 | '' => undef
        |                 \ i => [i v e]
        |     ]
        |t => [t a i n m e n t]
        \f => [f i n e m e n t]

It should be obvious to see how the contruct branch will produce the
pattern /construct(?:ive)?/ . Or for a longer path 'constructively':

  [c o n
        |s => [s t r u c t
        |                 | '' => undef
        |                 \ i => [i v e
        |                              | '' => undef
        |                              \ l => [l y]
        |                        ]
        |     ]
        |t => [t a i n m e n t]
        \f => [f i n e m e n t]

This is the state of the internal structure before reduction. When
traversed it will produce a valid regular expression.

The trick is how to perform the reduction. The key insight is to note
that for any part of the trunk where the sibling paths do not end in
a node, it it possible to reverse them, and insert them into their
own R::A object and see what comes out:

  [t a i n m e n t] =>
  [t n e m n i a t]

  [f i n e m e n t] =>
  [t n e m e n i f]


  [t n e m
          | n => [n i a t]
          \ e => [e n i f]

When the algorithm visits the other path (s => [s t r u c t ...]),
it behaves differently. When a null path is seen, no reduction is
performed at that node level. The resulting path would otherwise
begin to admit matches that are are not permitted by any of the
initial patterns. For instance, with bat, cat, and catty, you can
hardly try to merge 'bat' and 'cat' to produce [bc]at, otherwise the
resulting pattern would become [bc]at(ty)?, and that would incorrectly
match 'batty'.

After having visited the s, t, and f paths, the
result is that t and f were reduced, and s failed. We therefore
unreverse everything, and signal that this node cannot participate in
any more reduction (the failures percolate up the tree back to the

Unreversing the t, f reduction gives:

  [ t => [t a i n] \
    f => [f i n e] | m e n t ]

When all is said and done, the final result gives

  [c o n
        |s => [s t r u c t
        |                 | '' => undef
        |                 \ i => [i v e
        |                              | '' => undef
        |                              \ l => [l y]
        |                        ]
        |     ]
        [ t => [t a i n]
          f => [f i n e] m e n t ]

When this data structure is traversed to build the pattern, it gives


NB: The capturing syntax is used here, instead of the grouping
syntax for readability issues only.

On the other hand, if the s path contained only [s t r u c t], then
the reduction would have gone succeeded. We would have a common
head [t], shared by all three paths.

    | c => [c u r t s]
    \ n => [n e m
                 | n => [n i a t]
                 \ e => [e n i f]

And then consider that the path [c o u r t] had also been added to
the object. We would then be able to reduce the t from the above
reduction, and the t in [c o u r t]

  [c o
      | n => [n
      |        | s => [s t r u c t]
      |        | t => [t a i n m e n t]
      |        \ f => [f i n e m e n t]
      |      ]
      \ u => [u r t]


  [c o
      | n => [n
      |        | s => [s t r u c]
      |        \ f => [
      |                 f => [f i n e]
      |                 t => [t a i n]
      |                 m e n
      |               ]
      |      ]
      \ u => [u r]

(Here ends my ASCII art talents).

The above structure would give


In a nutshell, that's it. Seems like the code would be simple, huh?
It turns out that no, there are lots of fiddly edge cases,
especially sets of paths are the same as other sets of paths
except for an optional sub-path. The canonical example that the
test suite deals with is:

  showeriness, showerless, showiness, showless.

The final pattern is


If there are bugs to be found, it will be in cases that are even
more pathological than this, e.g., something like:


(although the above actually *does* work, I tried it)


The code has been heavily tested using an approach based on
combinatoric lists known as power sets. For instance, the power
set of (a,b,c,d) is (assuming a join() on the results):

 a ab abc abcd abd ac acd ad b bc bcd bd c cd d

(along with the empty set). The power set of N elements contains
2**N elements. (or 2**N-1 of we exclude the empty set).

The testing approach was then to take the power set of the above
power set and produce regular expressions from each element.

For instance, at some point, we would encounter the set

  abc ac bcd cd d

From this we generate the pattern (?:(?:b?c)?d|ab?c). Once we have
this pattern, we go back and check that it does in fact match the
above 5 elements, and furthermore, that it does *not match* the
remaining 10 elements of the power set not used in this iteration.

And yes, that shook out a couple of bugs.

As of this time, the following search space has been examined

a b c         - complete
a b c d       - complete
a b c d e     - runs of 1-11, 20-31 complete, 12-17 partial
a b c d e f   - runs of 1-5, 61-63 complete
a b c d e f g - runs of 1-4, 125-127 complete

The code for this is in the eg/stress-test script. Note: it can use
months of CPU time if you're not careful. It requires the following



When tracking is in use, no reduction is performed.

Pretty-printed (indented), and tracking is handled merely by calling
different output routines. Each routine emits things in a different
way, but the underlying structure remains the same. Which is one
reason why you can't have pretty-printed tracked patterns (Well you
can, but I haven't written the routine that would do so).

Zero-width lookahead assertions can be added to the pattern. This may
be a win, but it may also slow things down.


If you are curious, you can dump out the internal data struct with
the following:

  use Data::Dumper;
  $Data::Dumper::Terse     = 0;
  $Data::Dumper::Indent    = 0;
  $Data::Dumper::Quotekeys = 0;
  $Data::Dumper::Pair      = '=>';

  print Dumper($r->_path);

A more compact representation can be obtained with

  print $r->dump;

All that said, I'm now reasonably confident that it deals
correctly with pretty much anything you're likely to throw at it.

Two recent bugs were easy to spot in the code, and the fix was a
couple of lines. Adding lookahead assertion was pretty simple to,
even if it did result in a certain amount of code factoring. So I
think that in general the structure of the code is a good one.

The eg/debugging script offers a good strategy for dealing with
assemblies that give rise to uncompilable patterns.


This module is under active development. The module is managed in
a Subversion repository, and thus, the latest working copy is
available at


David Landgren

I do appreciate getting e-mail, especially about Perl. Please keep in
mind that I get a lot of spam, and take drastic measures to reduce the
flow. One of the measures involves a gigantic regular expression that
contains many thousands of patterns that match hostnames of dynamic
dialup/residential/home IP addresses. That pattern is of course built
with this module.

It would be ironic if I rejected your mail coming from such an address.
Please use your ISP's outbound MX, or pay what it takes to get your
reverse DNS changed to something else.


This module is copyright (C) David Landgren 2004-2008.
All rights reserved.


This library is free software; you can redistribute it and/or modify
it under the same terms as Perl itself.