Perché `$ @` non è affidabile?

Question

Mi sembra di ricordare che non è sicuro fidarsi del valore di $@ dopo un eval. Qualcosa su un gestore di segnale che ha la possibilità di impostare $@ prima di vederlo o qualcosa del genere. Sono anche troppo stanco e pigro in questo momento per rintracciare la vera ragione. Quindi, perché non è sicuro affidarsi a $@?

Answer 1

Il Try::Tiny perldoc ha la discussione definitiva del problema con $@:

There are a number of issues with eval.

Clobbering $@

When you run an eval block and it succeeds, $@ will be cleared, potentially clobbering an error that is currently being caught.

This causes action at a distance, clearing previous errors your caller may have not yet handled.

$@ must be properly localized before invoking eval in order to avoid this issue.

More specifically, $@ is clobbered at the beginning of the eval, which also makes it impossible to capture the previous error before you die (for instance when making exception objects with error stacks).

For this reason try will actually set $@ to its previous value (before the localization) in the beginning of the eval block.

Localizing $@ silently masks errors

Inside an eval block die behaves sort of like:

sub die { 
     $@ = $_[0]; 
     return_undef_from_eval(); 
} 

This means that if you were polite and localized $@ you can't die in that scope, or your error will be discarded (printing "Something's wrong" instead).

The workaround is very ugly:

my $error = do { 
     local $@; 
     eval { ... }; 
     $@; 
}; 

... 
die $error; 

$@ might not be a true value

This code is wrong:

if ($@) { 
     ... 
} 

because due to the previous caveats it may have been unset.

$@ could also be an overloaded error object that evaluates to false, but that's asking for trouble anyway.

The classic failure mode is:

sub Object::DESTROY { 
     eval { ... } 
} 

eval { 
     my $obj = Object->new; 

     die "foo"; 
}; 

if ($@) { 

} 

In this case since Object::DESTROY is not localizing $@ but still uses eval, it will set $@ to "".

The destructor is called when the stack is unwound, after die sets $@ to "foo at Foo.pm line 42\n", so by the time if ($@) is evaluated it has been cleared by eval in the destructor.

The workaround for this is even uglier than the previous ones. Even though we can't save the value of $@ from code that doesn't localize, we can at least be sure the eval was aborted due to an error:

my $failed = not eval { 
     ... 

     return 1; 
}; 

This is because an eval that caught a die will always return a false value.

Answer 2

Il Try::Tiny docs ha una buona lista di carenze eval/$@. Penso che potresti riferirti alla sezione Localizing $@ silently masks errors qui.

Answer 3

$@ ha gli stessi problemi che ogni variabile globale è: quando qualcos'altro imposta, è resettato attraverso l'intero programma. Qualsiasi eval potrebbe impostare $@. Anche se non vedi uno eval nelle vicinanze, non sai chi potrebbe chiamarne uno (subroutine, variabili legate e così via).