SET_ERROR_HANDLER(3)							 1						      SET_ERROR_HANDLER(3)

set_error_handler - Sets a user-defined error handler function

SYNOPSIS

       mixed set_error_handler (callable  $error_handler, [int	$error_types = E_ALL | E_STRICT])

DESCRIPTION

	Sets a user function ($error_handler) to handle errors in a script.

	This function can be used for defining your own way of handling errors during runtime, for example in applications in which you need to do
       cleanup of data/files when a critical error happens, or	when  you  need  to  trigger  an  error  under	certain  conditions  (using  trig-
       ger_error(3)).

	It  is	important  to  remember  that  the standard PHP error handler is completely bypassed for the error types specified by $error_types
       unless the callback function returns FALSE. error_reporting(3) settings will have no effect and your error handler will be  called  regard-
       less - however you are still able to read the current value of error_reporting and act appropriately. Of particular note is that this value
       will be 0 if the statement that caused the error was prepended by the @ error-control operator.

	Also note that it is your responsibility to die(3) if necessary. If the error-handler function returns,  script  execution  will  continue
       with the next statement after the one that caused an error.

	The following error types cannot be handled with a user defined function: E_ERROR, E_PARSE, E_CORE_ERROR, E_CORE_WARNING, E_COMPILE_ERROR,
       E_COMPILE_WARNING, and most of E_STRICT raised in the file where set_error_handler(3) is called.

	If errors occur before the script is executed (e.g. on file uploads) the custom error handler cannot be called since it is not	registered
       at that time.

PARAMETERS

	      o $error_handler
		-  A  callback with the following signature.  NULL may be passed instead, to reset this handler to its default state. Instead of a
		function name, an array containing an object reference and a method name can also be supplied.
		bool handler (int  $errno, string  $errstr, [string  $errfile], [int  $errline], [array  $errcontext])

		     o $errno
		       - The first parameter, $errno, contains the level of the error raised, as an integer.

		     o $errstr
		       - The second parameter, $errstr, contains the error message, as a string.

		     o $errfile
		       - The third parameter is optional, $errfile, which contains the filename that the error was raised in, as a string.

		     o $errline
		       - The fourth parameter is optional, $errline, which contains the line number the error was raised at, as an integer.

		     o $errcontext
		       - The fifth parameter is optional, $errcontext, which is an array that points to the active symbol table at the	point  the
		       error occurred. In other words, $errcontext will contain an array of every variable that existed in the scope the error was
		       triggered in. User error handler must not modify error context.

	       If the function returns FALSE then the normal error handler continues.

	      o $error_types
		- Can be used to mask the triggering of the $error_handler function just like  the  error_reporting  ini  setting  controls  which
		errors	are  shown.  Without  this  mask  set  the  $error_handler will be called for every error regardless to the setting of the
		error_reporting setting.

RETURN VALUES

	Returns a string containing the previously defined error handler (if any). If the built-in error handler is used NULL is  returned.   NULL
       is  also  returned  in  case  of an error such as an invalid callback. If the previous error handler was a class method, this function will
       return an indexed array with the class and the method name.

CHANGELOG

       +--------+---------------------------------------------------+
       |Version |						    |
       |	|						    |
       |	|		     Description		    |
       |	|						    |
       +--------+---------------------------------------------------+
       | 5.5.0	|						    |
       |	|						    |
       |	|	  $error_handler now accepts NULL.	    |
       |	|						    |
       | 5.2.0	|						    |
       |	|						    |
       |	|  The error handler must return FALSE to  populate |
       |	| $php_errormsg.				    |
       |	|						    |
       +--------+---------------------------------------------------+
EXAMPLES

       Example #1

	      Error handling with set_error_handler(3) and trigger_error(3)

	       The example below shows the handling of internal exceptions by triggering errors and handling them with a user defined function:

	      <?php
	      // error handler function
	      function myErrorHandler($errno, $errstr, $errfile, $errline)
	      {
		  if (!(error_reporting() & $errno)) {
		      // This error code is not included in error_reporting
		      return;
		  }

		  switch ($errno) {
		  case E_USER_ERROR:
		      echo "<b>My ERROR</b> [$errno] $errstr<br />
";
		      echo "  Fatal error on line $errline in file $errfile";
		      echo ", PHP " . PHP_VERSION . " (" . PHP_OS . ")<br />
";
		      echo "Aborting...<br />
";
		      exit(1);
		      break;

		  case E_USER_WARNING:
		      echo "<b>My WARNING</b> [$errno] $errstr<br />
";
		      break;

		  case E_USER_NOTICE:
		      echo "<b>My NOTICE</b> [$errno] $errstr<br />
";
		      break;

		  default:
		      echo "Unknown error type: [$errno] $errstr<br />
";
		      break;
		  }

		  /* Don't execute PHP internal error handler */
		  return true;
	      }

	      // function to test the error handling
	      function scale_by_log($vect, $scale)
	      {
		  if (!is_numeric($scale) || $scale <= 0) {
		      trigger_error("log(x) for x <= 0 is undefined, you used: scale = $scale", E_USER_ERROR);
		  }

		  if (!is_array($vect)) {
		      trigger_error("Incorrect input vector, array of values expected", E_USER_WARNING);
		      return null;
		  }

		  $temp = array();
		  foreach($vect as $pos => $value) {
		      if (!is_numeric($value)) {
			  trigger_error("Value at position $pos is not a number, using 0 (zero)", E_USER_NOTICE);
			  $value = 0;
		      }
		      $temp[$pos] = log($scale) * $value;
		  }

		  return $temp;
	      }

	      // set to the user defined error handler
	      $old_error_handler = set_error_handler("myErrorHandler");

	      // trigger some errors, first define a mixed array with a non-numeric item
	      echo "vector a
";
	      $a = array(2, 3, "foo", 5.5, 43.3, 21.11);
	      print_r($a);

	      // now generate second array
	      echo "----
vector b - a notice (b = log(PI) * a)
";
	      /* Value at position $pos is not a number, using 0 (zero) */
	      $b = scale_by_log($a, M_PI);
	      print_r($b);

	      // this is trouble, we pass a string instead of an array
	      echo "----
vector c - a warning
";
	      /* Incorrect input vector, array of values expected */
	      $c = scale_by_log("not array", 2.3);
	      var_dump($c); // NULL

	      // this is a critical error, log of zero or negative number is undefined
	      echo "----
vector d - fatal error
";
	      /* log(x) for x <= 0 is undefined, you used: scale = $scale" */
	      $d = scale_by_log($a, -2.5);
	      var_dump($d); // Never reached
	      ?>

	      The above example will output something similar to:

	      vector a
	      Array
	      (
		  [0] => 2
		  [1] => 3
		  [2] => foo
		  [3] => 5.5
		  [4] => 43.3
		  [5] => 21.11
	      )
	      ----
	      vector b - a notice (b = log(PI) * a)
	      <b>My NOTICE</b> [1024] Value at position 2 is not a number, using 0 (zero)<br />
	      Array
	      (
		  [0] => 2.2894597716988
		  [1] => 3.4341896575482
		  [2] => 0
		  [3] => 6.2960143721717
		  [4] => 49.566804057279
		  [5] => 24.165247890281
	      )
	      ----
	      vector c - a warning
	      <b>My WARNING</b> [512] Incorrect input vector, array of values expected<br />
	      NULL
	      ----
	      vector d - fatal error
	      <b>My ERROR</b> [256] log(x) for x <= 0 is undefined, you used: scale = -2.5<br />
		Fatal error on line 35 in file trigger_error.php, PHP 5.2.1 (FreeBSD)<br />
	      Aborting...<br />

SEE ALSO

       ErrorException, error_reporting(3), restore_error_handler(3), trigger_error(3), error level constants, information about the callback type.

PHP Documentation Group 												      SET_ERROR_HANDLER(3)