If you're certain that there will be no code that can execute during the compile (a big assumtion... Have you considered use, modules, etc? How do you ensure it?), then why not just something like this:

$code = 'whatever';

eval qq(return 1; $code);

if($@) {
  chomp($@);
  print "Syntax error: `$@'\n";
} else {
  print "Syntax ok\n";
}
[download]

bbfu
Black flowers blossom
Fearless on my breath

my $snippet = ...
eval "if (0) { $snippet }";
die if $@;
[download]

bluto

why run without the external call? without your reasoning, it's hard for me to see why any of the solutions posted so far are better... they're full of caveats. if you use File::Temp and perl -c the file, it will work, and can even be configured to clean up after itself. to a user, it should look the same, except it's probably less of a maintenance headache.

~Particle *accelerates*

I guess there's nothing particularly wrong with the system call: indeed, in some ways it works better. For example, "use strict" doesn't work inside an eval.

One of the nice things about the 'eval "sub { $txt }"' approach is that it gives me a code ref that I can call later if I want. This means that I can have a two-pass approach: in the first I gather/check all my fragments; and in the second I run selected ones. This isn't my current plan, but is nice to have the flexibility.

--Dave

there's room for that here, as well. create a hash with nice names as keys, and filehandles or filenames or the code snippets themselves as values. you still have the two-pass approach, but if you write to disk and keep the filehandles or filenames around, you can always slurp them in quickly to run them. heck, you can do with them what you will.

~Particle *accelerates*

# Under Construction
[download]

You're probably aware of this already, but there will still be ways for sneaky programmers to get around restrictions like that. For instance:

my @backward_chars = ('e', 's', 'u');
my $watch_out = (reverse join "",@backward_chars) . " Data::Dumper;";
eval $watch_out;
my $x = Dumper([1,2,3]);
print $x;
[download]

I've managed to use Data::Dumper without "use" every appearing explicitly in the code.

Update: D'oh, I forgot to consider the all-important "wrap in an anonymous subroutine" part, which would seem to defer actual execution of the code. My bad.

        $perlmonks{seattlejohn} = 'John Clyman';

UPDATE: on second thought, I can't figure out how you would use B::Deparse intelligently, so don't pay much attention to my post :)

As far as I can tell, as you probably know, only perl can parse Perl. You might have a good shot at trying to use something crazy like B::Deparse (look in the USING B::Deparse AS A MODULE section), but even that's not going to successfully figure out the syntax of "all of perl."

Unless one of the considerably more knowledgable monks corrects me, and I hope they do, you are pretty much stuck with "perl -c" (though I would usually do "perl -wc" :)

There are intelligent ways to use B::Deparse but none of them apply to checking perl for syntactical correctness. The canonically correct way is to invoke the parser somehow whether through eval "sub { $code }" or through perl -c tempfile.txt.