Following does not work. It should replace target and previous two words, to
wit:   word1 word2 Z

#code

$_ =  "word1 word2 word3 word4 cat";

s: \b.+\b{2}?cat :Z:xg;

print $_;

Here's one way to do what I think you want:

  $ perl -wle '$_="word1 word2 word3 word4 cat";'
  >  -e 's/\b(?:\w+ +){2}cat/Z/; print'
  word1 word2 Z
  $

Obligatory mention: see perlre.  

|>
|>  Assume you have a target word, e.g. "cat", and you want to extract
|>  that word and a certain number of words before it. How is one to do
|>  this in a non-literal manner with a regular expression which will
|>  support any number of pre-words to be extracted?
|>
|>  Following does not work. It should replace target and previous two
|>  words, to wit:   word1 word2 Z
|>
|>  code
|>
|>  word1 word2 word3 word4 cat";
|>
|>  s: \b.+\b{2}?cat :Z:xg;
|>
|>  The quantifier ({2}) is quantifying the atom `\b'.  I don't think
|>  that's what you meant.  The `?' following the quantifier {2} makes no
|>  sense, since the {2} is not allowed any latitude -- it forces exactly
|>  two.
|>

$_ = "aaahhh dog whale cat male xxx yyy";

s|[A-Za-z0-9\.]+ [A-Za-z0-9\.]+ cat [A-Za-z0-9\.]+ [A-Za-z0-9\.]+ |X|;

print $_;

=======

                         ^^^^^^^^
                         ^^^^^^^^
<off topic>
Be aware that someone out there (tucows, to be specific)
owns fake.com and has to handle (i.e., bounce) all of your
spam/misdirected replies.  If you want to use a fake email address,

see the email munging faq.
</off topic>

#!perl -w
use strict;

#!/usr/bin/perl -w
use strict;

$_ =  "word1 word2 word3 word4 cat";

s/(\w+\W+){2}cat/Z/xg;

print $_;

I tried to extend this to also include 2 words after the word, but this
mucks up the elegant code

===

$_ = "word1 word2 word3 word4 cat word5 word6 word7";

s/(\w+\W+){2}cat(\w+\W+){2}/Z/xg;

print $_;

===

s/(\s+\W+){2}cat(\W+\w+){2}/Z/g; # no x needed since no spaces in regex

  $_ =  'word1 word2 word3 word4 cat';
  s/(\w+\s+){2}cat/Z/g;
  print;

Output is 'word1 word2 Z'.

For a quoting guide:  http://www.netmeister.org/news/learn2quote2.html

(You do understand the purpose of the ()'s, right?  The {2} applies to
the entire sub expression within the ()'s.)

Rich

        $_ = 'dog cat mouse cat parrot';
        /((?:\S+\s+){2})cat\b/ and print $1;
-->
        'cat mouse'

I hope you like what it matched. I think not.

+++++++++++++++++++++++++++++++

Rich, I took your implicit suggestion to reverse the order of "\w\W", but
Bart pointed out a great counterexample which breaks the regex:

== START CODE ===

$string = "word1 word2 word3 cat word5 cat word7 word8 word9";

== END CODE =====

THIS SHOULD RETURN:

word2 word3 cat word5 cat
cat word5 cat word7 word8

BUT INSTEAD RETURNS:

/ (?: \w+ \W+ ){2} cat (?: \W+ \w+ ){2} /gx

and you will at least get the first match that you expect.

As for handling overlapping matches, here's one way to do it:

$string =~ m{
             (                         # start saving match
              \b                       # needed to limit back-track
              (?:\w+\W+){2}            # match two words
              cat
              (?:\W+\w+){2}            # match two words
              \b                       # needed to limit back-track
             )                         # ok, that's a match

             (?!)                      # force back-track for other matches
            }x;

Aren't experimental regex features fun!

#!/usr/bin/perl -w
use strict;

$_ =  "word1 word2 word3 word4 cat word5 cat word6 word7 word8";

s/(\w+\W+){2}cat(\W+\w+){2}/Z/;

print $_;

word1 word2 Z word6 word7 word8

Now the tricky part which Bart was probably pointing out is that after
you've captured the first cat, you're now past the second one.  You
somehow need to back up.  I'm not familiar with doing that in RE's, so I
won't offer a solution using RE's.  At this point, I'd personally use an
RE to split up the words and use an array and a simple algorithm to find
the matches:

#!/usr/bin/perl -wl
use strict;

my $b = 2; # number of before words
my $a = 2; # number of after words

   }

        my ($pre, $match, $post) = split /(cat)/, $_, 2;

These behave just like $`and $' but without overhead  for the other
regexes.

Now, continue matching with $pre:

        $pre =~ /((?:\S+\s+){0,2})$/;

This will match AT MOST 2 words at the end of the prefix.

If you want continue processing the string where you left of, continue
with $post.

|>  usr/bin/perl -wl
|>  use strict;
|>
|>  my $t =  "word1 word2 word3 cat word5 cat word7 word8 word9 cat word11";
|>  split(/\W+/, $t);
|>

|>  my $b = 2; # number of before words
|>  my $a = 2; # number of after words
|>





|>      }
|>   }

Much obliged to Rich, Bart, and Ren for their masterly attempts to solve
this problem. In my ignorance, I thought this was a short one-line solution.
I now see I have a lot of work to do.