The fundamental problem here lies in the differing NFA/DFA semantics. No, there is no easy way to convert one to the other.

As Mastering Regular Expressions explains so well, NFAs are a brute-force recursive search. If there is a combinatorial explosion of possible ways to start trying to match pattern to text (think about /^(\s*yada\s*)+$/ for a second) you get a situation where an NFA will hit exponential failure modes. (No, Perl didn't fail to see that there was no match, you just didn't let it work for enough years.) But since an NFA is a brute force search, just adjusting the search pattern lets you specify which alternatives come first, and whether this wildcard pattern is greedy while that one is not. Plus things like backreferences are easy to implement.

By contrast DFAs walk the string once, keeping track of all of the places they might be in the pattern at once. This is guaranteed to finish quickly, but good luck if you want to keep track of things like backreferences. (Well actually there are quadratic algorithms that will capture backreferences, but you cannot use them within the pattern.) By an implementation quirk, a DFA will always find the longest overall match. (They can also be designed the find the shortest, the Unix grep utility does this for speed.)

So NFAs and DFAs find different matches by default. NFAs offer more features and finer control. DFAs better guaranteed performance. If you understand all of that then you should be able to follow this explanation of the dangers that lie in wait for someone attempting a native conversion of flex to using Perl's RE engine.

Now in addition to the other ideas you have had (most of which will be workable, but will involve some learning) if you don't mind trying something which is possibly insane you could investigate whether Inline makes it feasible to use the Flex specification directly in Perl...

UPDATE
danger pointed out that I had said that a DFA was a brute force search when I clearly meant that an NFA was. Fixed.

Looking around a bit I'd recommend using Parse::RecDescent and taking 10 minutes to run through the regexes to make them Perl-compliant (change {h} to $h or $token{h}, for example). But none of that is based on a thorough understanding of the problem. ):

Good Idea. It was the first thing I thought of too. Unfortunately, it does not work... The documentation clearly states that Parse::RecDescent does not opperate like yacc. The first successful match terminates the search. Yacc uses the "prefer the longest match" to choose which rule to fire if there are multiple rules that match the incomming string. So the way the rules are set up in the flex code that he got will cause lots of problems. See my post in the main thread as to why.
---
Crulx
crulx@iaxs.net

%x comment
%%
        int line_num = 1;

"/*"         BEGIN(comment);


<comment>[^*\n]*        /* eat anything that's not a '*' */
<comment>"*"+[^*/\n]*   /* eat up '*'s not followed by '/'s */
<comment>\n             ++line_num;
<comment>"*"+"/"        BEGIN(INITIAL);
[download]

1. A system for maintaining which runstate we are in. That is what remembers that we are in the Comment state.
2. A system for matching the greediest RE in the list. That is what keeps

   <comment>[^*\n]*
   [download]

   from matching the * in */. The existance of that "*" + "/" rule.

"/*"         BEGIN(comment);
[download]

if ($bob =~ /^\/\*/) {
  $comment = 1;
}
[download]

Here is some perl code to do that flex code.

#!/usr/bin/perl
use strict;
my $bob = "/* THis ** comment** is\n\nMy\ngreatest\n Comment** */";
my $comment = 0;
my $line_num = 1;
while($bob) {
my @match_list;
print "STARTLOOP matching $bob\n";
if ($bob =~ /^\/\*/) {
  push @match_list,{rest=>$',code=>"\$comment=1",matched=>$&};
  print "start comment matched: $&\n";
}
if($comment && $bob =~ /^[^*\n]*/) {
  push @match_list,{rest=>$',code=>"",matched=>$&};
  print "not star matched: $&\n";
}
if($comment && $bob =~ /^\*[^*\n]*/) {
  push @match_list,{rest=>$',code=>"",matched=>$&};
 print "star with no slash matched: $&\n";
}
if($comment && $bob =~ /^\n/) {
  push @match_list,{rest=>$',code=>"++\$line_num;",matched=>$&};
  print "newline matched: $&\n";
}
if($comment && $bob =~ /^\*\//) {
  push @match_list,{rest=>$',code=>"\$comment=0",matched=>$&};
  print "end comment matched: $&\n";
}
my $max_length = 0;
my $match;
#should be priority queue.. but I'm too tired to
# use that module now...
foreach $match (@match_list) {
  if(length($match->{matched}) > $max_length) {
     $max_length = length($match->{matched});
  }
}
foreach $match (@match_list) {
  if(length($match->{matched}) == $max_length) {
    eval $match->{code};
    $bob = $match->{rest};
  }
}
}
print "line num is $line_num\n";
[download]

DFA's are just NFA's that just don't allow multiple moves from one state to another via the same character. It is hard to get an NFA in DFA form, but the converse is not true.

Hope this makes sense.
---
Crulx
crulx@iaxs.net