There's nothing wrong with the piece of code you have provided (except that it does nothing and does not even compile because it's incomplete). To get an answer, you should have tried to obtain a minimal reproducting exemple, which would probably have shown you what was wrong in the process.

The issue probably comes from where you get your reference, if you have $ref = \SOMETHING where SOMETHING comes from a regex (the most obvious case being $ref = \$1;, running another match may change the value your reference points to. For exemple, the following code has a issue similar to yours, except it fails at the first run:

my $l_Name_ref;
for (qw/HELLO PERL MONKS/)
{
  /(.+)/;
  $l_Name_ref = \$1;
  if (defined($$l_Name_ref)) {
    print STDERR "1 $$l_Name_ref\n" if (defined($$l_Name_ref));
    print STDERR "2 $l_Name_ref\n";
    if ($$l_Name_ref =~ /^[a-zA-Z]\w+$/) {
      print STDERR "3 $l_Name_ref\n";
      print STDERR "4 $$l_Name_ref\n";
    }
  }
}
[download]

Edit: I changed my example, in the previous version I used @ARGV and shifted from it because of my first attempt at reproducing the defect but it did not make much sense in this last version.

Hello Eily, you wrote:

... if you have $ref = \SOMETHING where SOMETHING comes from a regex ..., running another match may change the value your reference points to.

Whow, I am impressed. Your guess is absolutely right. In fact the input to the method is coming from another regular expression. This is how I call my method:

$l_Value =~ s/([a-zA-Z]\w+)/${$o_Object->GetValue(\ $1)}/gs;
[download]

The regular expression searches for specific placeholders in a string, and tries to replace them with values returned by the method "GetValue".

sub GetValue {
  my $o_Object    = shift;
  my $l_Name_ref  = shift;
  my $l_Value     = undef;

  if (defined($$l_Name_ref)) {
  print STDERR "1 $$l_Name_ref\n" if (defined($$l_Name_ref));
  print STDERR "2 $l_Name_ref\n";
  if ($$l_Name_ref =~ /^[a-zA-Z]\w+$/) {
    print STDERR "3 $l_Name_ref\n";
    print STDERR "4 $$l_Name_ref\n";
    ...
  } else {
    ...
  }
  return \ $l_Value;
}
[download]

So running a regular expression on a reference, which point to a result of another regular expression should be avoided. The solution is to create a copy of the same data before running the next regular expression. Thank you for pointing this out.

Anonymous Monk is right, this most likely has something to do with what $l_Name_ref refers to. Most likely, this is a capture variable that then gets reset by the next match operation:

#!perl -w

sub foo {
    my( $ref )= @_;
    print "Before match: <$$ref>\n";
    'barring something else' =~ /bar/; # reset all capture variables
    print "After match: <$$ref>\n";

};

'blargh foo blargh' =~ /(foo)/;
foo( \$1 );

print "Attempt 2:\n";
'blargh foo blargh' =~ /(foo)/;
foo( \"$1" );

__END__
Before match: <foo>
Use of uninitialized value in concatenation (.) or string at q:\tmp.pl
+ line 7.
After match: <>
Before match: <foo>
After match: <foo>
[download]

I doubt that the intent is really to pass around a reference to $1, as that has the described side effects. It's likely better to pass a reference to a copy of $1, as in Attempt 2.

Excellent explanation! You can see the buggy code causing my problem in an answer above. Your example explains this phenomena short and precise. Thank you.

In general, it's a Good Idea to "capture the capture variables" immediately after a match in order to avoid these kinds of strange problems:

if ($string =~ m{ (foo|bar) (\d+) (w[ia]g) }xms) {
    my ($one, $two, $three) = ($1, $2, $3);
    do_something_with($one);
    ...
    }
[download]

or:

if (my ($one, $two, $three) = $string =~ m{ (foo|bar) (\d+) (w[ia]g) }
+xms) {
    do_something_with($one);
    ...
    }
[download]