When you add the eval, it evaluates the regular expression as a string. This will likely remove one layer of backslashes ("escapes").

I wonder where you got the idea of wrapping eval around a regular expression definition from and why you think it would change the program outcome to one you expect?

I wonder where you got the idea of wrapping eval around a regular expression definition from...

I got the idea from an online O'Reilly book about "Mastering Perl" here: https://www.oreilly.com/library/view/mastering-perl/9780596527242/ch02.html

Here is the code example that I had seen on that page:

#!/usr/bin/perl
# perl-grep2.pl

my $pattern = shift @ARGV;

my $regex = eval { qr/$pattern/ };
die "Check your pattern! $@" if $@;

while( <> )
        {
        print if m/$regex/;
        }
[download]

I didn't know why my code had had issues to begin with, so when I saw that code example, I thought perhaps I had not used the correct syntax for this usage, and tried it the way they had it. I didn't have anything to lose in trying, but the result was not an improvement.

Blessings,

~Polyglot~

Note how that code uses the block form of eval, eval { ... }, not the string form eval qr//.

That eval is only there to "protect" you against errors in your regular expression. I'm not sure what the use is in that program as it immediately exits anyway.

You are at least getting tripped up by not understanding the two forms of eval and how they differ. String-eval should rarely be used and regular expressions are not one of these rare cases.

Those eval make no sense and you're missing the /x. You simply want

my $nfw_oang = qr%    
    (?!\p{IsOang}(?!
        (?:\p{InThaiFinCons}){1,2}    
        (?![\p{InThaiCompVowel}\p{InThaiPostVowel}\p{InThaiTone}])
        (?:\p{InThaiMute})
    ))
%x;
[download]

And given that (?![\p{X}\p{Y}\p{Z}])\p{W} can be written as (?[ \p{W} - [\p{X}\p{Y}\p{Z}] ]) or (?[ \p{W} - \p{X} - \p{Y} - \p{Z} ]), you could use

my $nfw_oang = qr%    
   (?!
      \p{IsOang}
      (?! (?:\p{InThaiFinCons}){1,2}
          (?[
             \p{InThaiMute}
             - \p{InThaiCompVowel}
             - \p{InThaiPostVowel}
             - \p{InThaiTone}
          ])
      )
   )
%x;
[download]

That said, you might want to look into (?(DEFINE)...).

/
   ...
   (?&NFW_OANG)
   ...
   (?&INITIAL_CONSONANT)
   ...

   (?(DEFINE)
      # NOT FOLLOWED BY O-ANG WITHOUT A THAI MUTE/CONSONANT ENDING
      (?<NFW_OANG> (?! (?&OANG) ) )

      # O-ANG WITHOUT A THAI MUTE/CONSONANT ENDING
      (?<OANG>
         \p{IsOang}
         (?! (?:\p{InThaiFinCons}){1,2}
             (?[
                \p{InThaiMute}
                - \p{InThaiCompVowel}
                - \p{InThaiPostVowel}
                - \p{InThaiTone}
             ])
         )
      )

      # INITIAL CONSONANT(S)
      (?<INITIAL_CONSONANT>
         (?: \p{InThaiDualC1} \p{InThaiDualC2}
         |   \p{InThaiCons}
         )
      )
/x
[download]

Either it does not succeed (no matches at all), as it did before I had replaced the code blocks with the variables for them, or it matches more than it was expected to--depending on whether I have added the "eval" or not

This is one of the problems when you try to do everything in a single match. I mean, there are times when you do want a single match, but you need to consider what you want the regex engine to do when it encounters something that isn't matched. So, for instance, maybe you need some sort of catch-all that returns an "error token" before resuming trying to match the rest.

In many cases, when parsing things, I desire the regex to give me as many parse tokens as it was able to create and then tell me where the error is, so that I can report the error to the user with some context information. The easiest way to accomplish that is with the /gc regex flag and then the \G marker at the start of the regex to pick up where you left off. The location in the string is tracked per-string, and you can inspect it with the pos keyword.

my @tokens;
while ($input =~ /\G( pattern...  )/gcx) {
  push @tokens, $1;
}
if (pos $input < length $input) {
  say "Parse error at ....";
}
[download]