>Is there any particular reason why error_reporting() should return 0 if the 
statement that caused the error was prepended by the @ error-control operator?  

Well for one thing it's the quick 'n' dirty way to make the error handler function be quiet to implement the @ operator, and PHP usually chooses the quick 'n' dirty route.

I think it's right though. If you're @ing an expression, it's because you want to ignore errors in it. Such an error shouldn't be printed or logged except during debugging, because many PHP functions raise an error as part of their normal operation. Consider a call to fopen: Code is expected to look at the return value to see if the file opened successfully and handle it as necessary. In that case, it may not want the fopen error message to be printed/logged, since the user code may raise its own more specific error, or it might not be an error at all (if it was merely testing if the file could be opened in the given mode, or it can handle the intended file operation in another way).

Because @ applies to complete expressions (which can include calls of entire large functions and everything they do) it's sometimes too aggressive, in which case you'd want to disable @ by using a custom error handler function. Apart from that debugging case, when you can easily hard-wire an error reporting value into the handler function, you shouldn't really need to differentiate between the base error reporting value and the @ value. I'm curious why you want to.

Well, I am talking about the situations when external error handler is used.  
Suppose we want to catch any errors inside our script using a custom error 
handler function, but we also want to respect error_reporting settings provided 
by the configuration so as to show/log an error or not.  Suppose the current 
error_reporting level = E_ALL & ~E_DEPRECATED & ~E_NOTICE (22519), Now, inside 
our custom error handler function we would need to be logging all errors except 
deprecated and notice-level, so as to respect error_reporting setting.  It seems 
to be so simple:


function default_error_handler($errtype, $errstr, $errfile, $errline) {  
  if ((error_reporting() & $errtype) == 0) {
    return FALSE; // only handle errors specified by PHP configuration
  }  
  log_write(sprintf('Error: %s in %s at line %u',
    $errstr, $errfile, $errline));
  ... 
}

Unfortunately, since error_reporting() returns 0 for calls that were prepended 
by a '@', those errors will never get logged as we wanted.  Don't you think if 
we instruct PHP interpreter that we want to use our own error handler function, 
we would also like to control we might want to respect PHP error_reporting 
settings when displaying errors?  In my opinion, it makes logical sense.

The solution would be if there was a possibility to know that the failed 
statement was prepended with '@', so we could know what to do about it in our 
custom error handler, while error_reporting() would always return current level 
of error reporting?

Andrejs

There is actually a good technical reason for this, which is that internally the @ 
operator causes PHP to change the error_reporting value. In effect writing this:

@foo(42);

Really means this in effect on an engine level:

old_error_reporting = error_reporting(0);
foo(42);
error_reporting(old_error_reporting);

In theory it would be possible to expose the value of old_error_reporting to 
userspace when within a silence operator, but in practice, it would add complexity 
to the engine for little practical gain.

Closing won't fix.