Then don't use a regex. Why does everyone think that all string manipulation should be handled with a regex?!? Use a simple character-by-character parser, noting state as you move through the string.

# UNTESTED !!!

my $in_quote = 0;
my $in_bold = 0;
my $final_string = '';
foreach my $char ( split //, $string ) {
    if ( $char eq "'" ) {
        $in_quote = 1 - $in_quote;
    }
    else if ( $char eq '*' && !$in_quote ) {
        $final_string .= '<';
        $final_string .= $in_bold ? '/' : '';
        $final_string .= 'b>';
        $in_bold = 1 - $in_bold;
    }
    else {
        $final_string .= $char;
    }
}
[download]

An easily extendable solution:

{
   for ($text) {  # Alias $_ to $text.
      /\G ``   (.*?) ``   /gcsx && do { print($1         ); redo };
      /\G \*\* (.*?) \*\* /gcsx && do { print("<b>$1</b>"); redo };

      /\G
         (
            .            # Catchall.

            (?:          # These four lines are optional.
               (?!``)    # They are here to speed things up
               (?!\*\*)  # by avoiding calling print for
            .)*          # single characters.
         )
      /gcsx && do { print($1); redo };
   }
}
[download]

Handles mismatched ** and `` by treating them as normal characters.

Update:

• Removed "\n"s from prints.
• Added /s option to regexps, since I'm guessing newlines are not special.
• The 1st .*? was ((?:(?!``).)*
• The 2nd .*? was ((?:(?!\*\*).)*

Tested:

Regexp::Common::balanced

First off, dragonchild's answer is well worth considering, and probably the better choice. But for the sake of interest... I think it may be possible to do this with a regex, provided the problem really is as simple as the way you have stated it and not complicated by additional nesting or somesuch. Something along these lines...

...might work. (No, lots of paretheses don't bother me. Yep, I knew a lisp variant before I learned Perl.) But dragonchild's solution is easier to read and maintain.

It doesn't work for the simple case "**bold**". I haven't tried anything else.

Yeah, I wasn't thinking and used the match variables as if there were only two sets of parens, rather than four. The updated version works for that simple case. However, I'd worry about unexpected data screwing it up potentially rather badly, and it only handles one type of quote mark; if you're allowed to have both single and double quote marks and nest them and escape quote marks within quotes with backslashes, stuff gets messy fast.

Alright, thanks all!

I've already thought of using "character-by-character parser" as dragonchild suggested, but I guess Perl scripts are just less sexy when you have to use techniques too common for other languages ;) . Just kidding; the truth is, as this is meant to be a really simple script (for personal use), regex seemed to be a good option: short and, well, usually simple. Of course, I'd choose char-by-char parsing over using overly-complicated regular expressions, so, anyway, thanks again.

sub boldify
{
    local $/ = undef;
    my $input = shift;
    my @parts = split /``/, $input;
    foreach my $i (0..scalar(@parts)) {
    $parts[$i] =~ s/\*\*(.+?)\*\*/<b>$1<\\b>/gs if ($i % 2 == 0);
    }
    return join '', @parts;
}
[download]

Here's a test:

Quite interesting, but I don't think it's flexible enough. For example, if later I decide that `` enclosed by spaces ( /\s``\s/ ) shouldn't be recognized as an "escape mark", well, how can we detect it?