What I'd recommend instead is to tokenize your text, that is split it up into chunks that are 1) either normal text or 2) your special comments or 3) opening or closing <a> tags.

Then iterate over all these chunks, and count the difference in the number of opening and closing anchor tags. While iterating over these tokens you construct an output string, and in that string it shouldn't be too hard to get the nesting of <a> tags correctly.

Thanks for assist Moritz

Im not sure how you would 'tokenize' it in the first place ? would that not have a regex as well ?

Its also worth commenting this isnt about a templating system, the raw html is generated by another host (which I have no control over) and just have that to work with ?

Im not sure how you would 'tokenize' it in the first place ? would that not have a regex as well ?

It sure would, but the point is that it would need one regexp per possible token type, not one huge regex that solves the whole problem.

Usually I use the tokenizer from Math::Expression::Evaluator::Lexer (don't let the name fool you; it's good for more than mathematical expressions), from which you could draw inspiration.

And don't use .* in your regexes, that's almost always an error. See Death to Dot Star!.

get yourself a html parser, and use it :)

Ah well. Why do you use such a complicated templating in the first place? Reach out for Template Toolkit, HTML::Template or some such.

You could use HTML::Parser to achieve what you want. That module tokenizes your HTML and provides you with callbacks for comments, opening tags, closing tags, plain text and much more. In those callbacks, you can track the state of your opening/closing tags depending on whether there's content found to be substituted.

But first, some sanitizing:

<!-- headerStandard.siteFeedbackLink.label --!>
[download]

should be

<!-- headerStandard.siteFeedbackLink.label -->
[download]

to be a well formed comment. But if you stick with that, remove at least the last '!' to make your (invalid) comment pairs into one comment:

<!-- foo.label --!>text<!-- foo.label -->
[download]

<a href="<!--foo.label --!>foo<!-- foo.label -->">
  blah blah <img src="bar.jpg" alt="<!-- bar.label --!>bar<!-- bar.lab
+el -->" />
</a>
[download]

which can be solved using a stack of replacement links and have $pending below as a pointer to it. But you should really, really switch to a seasoned templating system!

use HTML::Parser;

use warnings;
use strict;

my $p = HTML::Parser->new(
    api_version => 3,
    start_h   => [\&start, 'tagname, attr, attrseq, text'],
    end_h     => [\&end,   'tagname, text'],
    comment_h => [\&comm,  'text' ],
    default_h => [ sub {print shift}, 'text'],
);
$p->unbroken_text(1);

my $file = shift;
$p->parse_file($file);

my ($pending, $link);

sub start {
    my($tag, $attr, $attrseq, $text) = @_;
    for my $k (keys %$attr) {
        if ($attr->{$k} =~ /\!/) {
            ($attr->{$k},$link) = transform_comments($attr->{$k});
        }
    }
    $pending++;
    my $a = join ' ',
          map {
            $_ eq '/' ? $_ :
            "$_=\"$attr->{$_}\""
          } @$attrseq;
    print "<$tag", $a ? " $a>" : '>';
}
sub end {
    my ($tag,$text) = @_;
    print $text;
    if ($pending) {
        print $link;
        $pending = $link = '';
    }
}
sub comm {
    my $text;
    ($text,$link) = transform_comments($_[0]);
    print $text;
    print $link unless $pending;
}

sub transform_comments {
    my $str = shift;
    if ($str =~ /(\S+) --!>([^<]+?)<!-- (\1)/) {
        my ($key,$text) = ($1,$2);
        # return value of hash and link
        my $val  = "fake-$text-translated";
        my $link = '<a href=\'foo\'>foo</a>';
        return $val,$link;
    }
    $str;
}
[download]

Update: seeing your answer to moritz above - well, then at least it isn't your fault ;-)

For the above code to work, you'll need to sanitize the comments with e.g.

perl -pi -e 's/(<!-- \S+ --!>[^<]+?<!-- \S+ --)!>/$1>/g' $file
[download]

since HTML::Parser won't recognize the comments otherwise.

Thanks Shmem for a excellent post

It isnt a templating system :) think of it as a filter, the actual real html is generated from a java host and I have to intercept it and transform it slightly to add these extra tags . So parsing the html seems a much more reasonable approach so appreciate your help

hi you may give "Recursive Search and Replacement" a try visit http://freshmeat.net/projects/sandr gr33tz f.c.