> with-g and without-g cases separately, depending on whether or not $flags =~ s/g// succeeds.

That's reasonable, because /g is not a simple modifier changing the match-rules, it turns the "replace" into a different "replace_all" command with very different behavior.

Cheers Rolf
_{(addicted to the Perl Programming Language :)
Wikisyntax for the Monastery}

but I am going to take a deep breath and code up the with-g and without-g cases separately

What is the obsession of people to try and solve a complex problem like this in a single line of code, just because it can be done in one line of code in a perl script? I don't mean you specifically, but in general, like apparently most people who replied to this thread.

Splitting this up in two parts makes sense, using /g is not a modifier of the pattern (as it is in several other languages), but of the substitution. Something like this looks acceptable to me as the (obvious) redundancy is actually quite limited:

    if($flages =~ s/g//) {
        s/(?:$flags)$pattern/replacement($replacement)/ge;
    }
    else {
        s/(?:$flags)$pattern/replacement($replacement)/e;
    }
[download]

where you still have to provide the sub replacement.

Other flags cannot really coded this way, but there's no need to provide for /o or /r at all, and allowing people to use /e flag in a config file, simply looks dangerous to me. If people would really want to use /e, it likely would be for just a handful of specific cases, and you can instead code a simpler solution for those cases (for the user, not necessarily for you) explicitly in your script, than having them write convoluted perl code.

That real danger of allowing ordinary users to run arbitrary code, is also why I really don't like use of eval. It also enforces taking special care to be taken when writing the sub replacement. You can mitigate the danger by using a module like String::Interpolate, to embed captured values while disallowing access to the rest of the intestines of the script. .

Well, this gets me much of what I need ... but I can't get back-references, either with $1 or \1. In either case, they appear as literals. Any ideas, other than eval?

> but I can't get back-references,

This works for me

  DB<44> $pat='(x)\1'

  DB<45> $mod='i'

  DB<46> 'xX' =~ /(?$mod)$pat/; say "$&:$1"
xX:x

  DB<47>
[download]

Cheers Rolf
_{(addicted to the Perl Programming Language :)
Wikisyntax for the Monastery}

depending on whether or not $flags =~ s/g// succeeds

Testing $flags =~ /g/; is simpler.

Simpler, but doesn't quite do what I need. I want to supply the remaining flags, once g has been removed, in the (?$flags:...) part of the expression. And I need to remove the g so that I don't get flooded with noisy console warnings about how it's being ignored.

Even string eval doesn't help, as plain interpolation of the $replacement can break if it contains a slash

My first thought was to use eval but I hit a brick wall when I tried...
I was thinking of first changing a slash in $replacement for a double slash then using eval to do the substitution but I got stuck getting the result of the substitution.

$replacement =~ s/\\/\\\\/g;
$string =~ eval "s/\$pattern/\$replacement/$flags";
[download]