This sounds very much like an XY Problem. Can you give us a Short, Self-Contained, Correct Example to illustrate your immediate problem? In any event, is the following something like what you would want?

c:\@Work\Perl\monks>perl -wMstrict -le
"my $str = 'abc';
 while ($str =~ m/./gc) {
   printf qq{1: %d \n}, pos $str;
   }
 ;;
 printf qq{2: %d \n}, pos $str;
 print 'pos at end' if pos $str == length $str;
"
1: 1
1: 2
1: 3
2: 3
pos at end
[download]

print 'pos at end' if pos $str == length $str;

This if statement is true whether or not the previous regex matched $. And the regex engine will only match $ once. How does the regex engine know that it matched $? And can I get access to that information? I prefer to not call the regex engine again.

Using pos == length is sufficient. I was hoping there was a simpler call, something like pos() but for identifying whether $ was already matched. That would allow me to avoid two calls (length and pos) and instead call one function (perhaps eos($str)). I'm very sensitive to performance during parsing.

print 'pos at end' if pos $str == length $str;

This if statement is true whether or not the previous regex matched $.

I don't understand this. Can you give an example of a non-lookahead regex that matches to the end of a string and does not match at the end of the string, i.e. does not leave pos sitting beyond the end of the string (or pos == length)?

Using pos == length is sufficient. ... a simpler call ... avoid two calls ... and instead call one function ... I'm very sensitive to performance during parsing.

It sounds as if you may have an answer (even though I'm still a bit confused about the question). I imagine that Inline::C would allow you to define a single function to examine the internals of a string scalar and return info on pos versus length. Good luck :)

---

Give a man a fish:  <%-{-{-{-<

>>How does the regex engine know that it matched $?

Hi.

I think engine doesn't know. It knows e.g. that it matched a zero-length branch once. And it cancels to match second time the same place in order to avoid eternal matching.
I believe you can get similar results with regexes like these: m/.|(?:)/gc, m/.|(?=)|(?:)/gc...

Maybe I am simplistic, but this works:

my $str = "abc";
while ($str =~ m/.(?=.|$)/gc) {
    say "1: ", pos $str;
    }
while ($str =~ m/.(?=.|$)/gc) {
    say "2: ", pos $str;
    }
[download]

For your regex, just keeping track of last vs curr pos would seem to do it. $ matches when pos does not advance.

use warnings;
use strict;

my $str = "abc";
my $last_pos =0;
while ($str =~ m/.|$/gc) {
   my $curr_pos = pos($str);
   printf("1: %d", $curr_pos);
   ($curr_pos == $last_pos) ? print "  EOString\n" : print "\n";
   $last_pos = $curr_pos;
}
__END__
1: 1
1: 2
1: 3
1: 3  EOString
[download]