use strict;
use warnings;
use 5.010;

my $string = 'foobar';

while ($string =~ s/\G.*?\K[aeiou]/\U$&/si) {
    say $&;
} continue {
    pos($string) = $+[-1];
}
say $string;
[download]

The trick is to manually set pos, and then use \G in the regex to anchor to that position. But since you want to match anything after that (and not just exactly at the current position), you need a .*? (and the /s modifier if newlines are in the string).

Now it matches too much text, but the \K assertion cuts off the start of the match, making $& what it should be.

\K requires perl 5.10.0, but since that's the third-oldest major perl 5 release, that shouldn't be a problem. It's not 1995 after all :-)

Insert generic warning about the runtime overhead of $& here, and how it's better to extract it with substr, @+ and @-.

Is there a way ... without using the /e modifier ...

Just as a matter of curiosity, what is the reason for this requirement? I can imagine one would not want to 'go outside' the regex engine due to performance considerations, but the use of a  while loop seems acceptable to alafarm, so why not use the nifty little /e gadget?

1 while s/this(?{print"$&,$-[0]\n"})/that/;
[download]

my $new = '';
for (;;) {                       # or: for ($orig)
   if (/\G(.*?)(this)/sgc) {
       say "Matched $2 at $-[2]";
       $new .= $1 . 'that';
       redo;
   } else {
       /\G(.*)/sgc;
       $new .= substr($_, pos);
       last;
   }
}
[download]

... perl substitutions ... are kept as lists in separate files and are read in by a processing engine, which then essentially does this: eval $mySubstitution. We now need to keep track of what was matched and their positions in the document.

I think the approaches based on \G already posted will serve perfectly well. However, I cannot help thinking the original eval-based process (insofar as I understand it) could easily be extended.

I imagine the process described above as in the first code sequence below: regex strings and replacement strings wind up in an array or arrays; a loop works through the array(s) eval-ing a  s/// statement for each substitution.

This could easily be extended as in the second code sequence below. No change whatsoever to either regex string or replacement string seems necessary.

>perl -wMstrict -le
"my @search  = qw(foo fee fie  foe );
 my @replace = qw(bar fum \u$& \U$&);
 ;;
 my $document = 'the foo is fee and fie-foe.';
 ;;
 while (my ($i, $rx) = each @search) {
   eval qq{ \$document =~ s{$rx}{$replace[$i]}g };
   }
 print qq{'$document'};
 ;;
 $document = 'all foo are fee or fie/foe';
 ;;
 my @replaced;
 while (my ($i, $rx) = each @search) {
   eval qq{
     \$document =~
       s{$rx}
        { push \@replaced, [\$&,\$-[0],\$+[0]]; qq{$replace[$i]} }eg
     };
   }
 print qq{'$document'};
 use Data::Dumper;
 print Dumper \@replaced;
"
'the bar is fum and Fie-FOE.'
'all bar are fum or Fie/FOE'
$VAR1 = [
          [
            'foo',
            '4',
            '7'
          ],
          [
            'fee',
            '12',
            '15'
          ],
          [
            'fie',
            '19',
            '22'
          ],
          [
            'foe',
            '23',
            '26'
          ]
        ];
[download]

while (s/this/that/g) {
    push @matches, $&;
}
[download]

while (s/this/that/gp) {
    push @matches, ${^MATCH};
}
[download]

Update: Thought it was m//g.