Letting the regex alternation do the heavy lifting seems to be a bit faster. Tested with a 1235 line C program cat'ed together 20 times.

use strict;
use warnings;

use Benchmark q{cmpthese};

my @prims = qw{ int char long double static };

my $inFile = q{xxx.c};
open my $inFH, q{<}, $inFile
   or die qq{open: $inFile: $!\n};
my $outFile = q{/dev/null};
open my $outFH, q{>}, $outFile
   or die qq{open: $outFile: $!\n};

cmpthese(
   -10,
   {
       JohnGG   => sub
          {
              seek $inFH, 0, 0;
              my $rxPrims = do
                 {
                     local $" = q{|};
                     qr{\b(@prims)\b};
                 };
              while ( <$inFH> )
              {
                  next unless my @found = m{$rxPrims}g;
                  print $outFH qq{Found @found on line $.\n};
              }
          },
       Narveson => sub
          {
              seek $inFH, 0, 0;
              while ( <$inFH> ) {
                  for my $word ( m{\b(\w+)\b}g ) {
                      if (grep {$word eq $_} @prims) {
                          print $outFH qq{Found $word on line $.\n};
                      }
                  }
              }
          },
   }
   );

close $inFH
   or die qq{close: $inFile: $!\n};
close $outFH
  or die qq{close: $outFile: $!\n};
[download]

The benchmark output.

           Rate Narveson   JohnGG
Narveson 1.39/s       --     -63%
JohnGG   3.78/s     173%       --
[download]

I hope this is of interest.

Cheers,

JohnGG