The eval function with quoted argument traps compile errors. You can examine the error messages in the perlvar $@. No other special magic is needed. This is not true of eval BLOCK.

Update: <shrug>If you want to avoid runtime on your eval string, just wrap it in a conditional:

$ 
$ perl -Mstrict -e'$_="printed\n";my$foo=q(print);eval"if(\$^C){$foo}"
+;print $@ if $@' -- #no compile or run error
$ 
$ perl -Mstrict -e'$_="printed\n";my$foo=q(quux);eval"if(\$^C){$foo}";
+print $@ if $@' -- # compile error
Bareword "quux" not allowed while "strict subs" in use at (eval 1) lin
+e 1.
$ 
$ perl -Mstrict -e'$_="printed\n";my$foo=q(&quux);eval"if(\$^C){$foo}"
+;print $@ if $@' -- # runtime error 
$ 
$ perl -Mstrict -e '$_="printed\n";my$foo=q(print);eval"$foo";print $@
+ if $@' -- # conditional removed, no errors
printed
$
[download]

After Compline,
Zaxo

the only difference is perl will execute whatever code, thus creating any files, emailing /etc/passwd to somebody, or anything else. the dude just ought to run perl -c on the file without reading it.

Consider:

#!/usr/bin/perl
BEGIN { print "rm -rf /" }
[download]

Guess what happens when you run perl -c on this.

Now just imagine if that weren't just a print statement...

Update: I thought it was discussed here before, but I can't seem to find where. IIRC, the verdict was, basically, that there's just not a way to get arbitrary code syntax checked w/o (at least the possbility of) running some of it.

bbfu
Seasons don't fear The Reaper.
Nor do the wind, the sun, and the rain.
We can be like they are.

eval "return; $code";

But see discussion elsewhere in the thread.

The reader did not realize that perl -c does not provide a safe way to test syntactical correctness. There is no way to do that in Perl.

For instance suppose that it does a use. There is no way to know if later code is syntactically correct without running the used module. (For instance what functions are exported? This affects what will be trapped as a bareword under strict, and what will not.) But when you do that, the module could do absolutely anything it wanted to.

But safety wasn't the question - merely how to emulate perl -c...

If you want it safe from malicious intent, we all know you're basically screwed with Perl. You can't not have it execute use bits, because many imports affect the compilation, like use constant. So either you test the compilation or you don't. I believe the author asked to do so.

Just a wild thought but couldn't you eval the creation of an anonymous subroutine, check the $@ for errors and if none, invoke the subroutine - for example -

$cmd = "sub{ prin 'Howdy'; }";
$sub = eval $cmd;
print "Error: ", $@, "\n" if $@;
&$sub unless $@;
[download]

-derby

eval "return; $code";
[download]

So you trust $code not to contain BEGIN or use then? That wasn't clear from the discussion.

-- Randal L. Schwartz, Perl hacker

++ vs lbh qrpbqrq guvf hfvat n ge va Crey :)
Nabgure bar vs lbh qvq fb jvgubhg ernqvat n znahny svefg.
-- vs lbh hfrq OFQ pnrfne ;)
    - Whreq