| 6,12 → 6,6 |
|---|
| * |
| * PHP versions 4 and 5 |
| * |
| * LICENSE: This source file is subject to version 3.0 of the PHP license |
| * that is available through the world-wide-web at the following URI: |
| * http://www.php.net/license/3_0.txt. If you did not receive a copy of |
| * the PHP License and are unable to obtain it through the web, please |
| * send a note to license@php.net so we can mail you a copy immediately. |
| * |
| * @category pear |
| * @package PEAR |
| * @author Sterling Hughes <sterling@php.net> |
| 18,9 → 12,8 |
|---|
| * @author Stig Bakken <ssb@php.net> |
| * @author Tomas V.V.Cox <cox@idecnet.com> |
| * @author Greg Beaver <cellog@php.net> |
| * @copyright 1997-2006 The PHP Group |
| * @license http://www.php.net/license/3_0.txt PHP License 3.0 |
| * @version CVS: $Id: PEAR.php,v 1.101 2006/04/25 02:41:03 cellog Exp $ |
| * @copyright 1997-2010 The Authors |
| * @license http://opensource.org/licenses/bsd-license.php New BSD License |
| * @link http://pear.php.net/package/PEAR |
| * @since File available since Release 0.1 |
| */ |
| 39,8 → 32,6 |
|---|
| */ |
| define('PEAR_ERROR_EXCEPTION', 32); |
| /**#@-*/ |
| define('PEAR_ZE2', (function_exists('version_compare') && |
| version_compare(zend_version(), "2-dev", "ge"))); |
| |
| if (substr(PHP_OS, 0, 3) == 'WIN') { |
| define('OS_WINDOWS', true); |
| 52,15 → 43,6 |
|---|
| define('PEAR_OS', 'Unix'); // blatant assumption |
| } |
| |
| // instant backwards compatibility |
| if (!defined('PATH_SEPARATOR')) { |
| if (OS_WINDOWS) { |
| define('PATH_SEPARATOR', ';'); |
| } else { |
| define('PATH_SEPARATOR', ':'); |
| } |
| } |
| |
| $GLOBALS['_PEAR_default_error_mode'] = PEAR_ERROR_RETURN; |
| $GLOBALS['_PEAR_default_error_options'] = E_USER_NOTICE; |
| $GLOBALS['_PEAR_destructor_object_list'] = array(); |
| 92,8 → 74,8 |
|---|
| * @author Tomas V.V. Cox <cox@idecnet.com> |
| * @author Greg Beaver <cellog@php.net> |
| * @copyright 1997-2006 The PHP Group |
| * @license http://www.php.net/license/3_0.txt PHP License 3.0 |
| * @version Release: 1.5.1 |
| * @license http://opensource.org/licenses/bsd-license.php New BSD License |
| * @version Release: 1.10.1 |
| * @link http://pear.php.net/package/PEAR |
| * @see PEAR_Error |
| * @since Class available since PHP 4.0.2 |
| 101,8 → 83,6 |
|---|
| */ |
| class PEAR |
| { |
| // {{{ properties |
| |
| /** |
| * Whether to enable internal debug messages. |
| * |
| 153,10 → 133,18 |
|---|
| */ |
| var $_expected_errors = array(); |
| |
| // }}} |
| /** |
| * List of methods that can be called both statically and non-statically. |
| * @var array |
| */ |
| protected static $bivalentMethods = array( |
| 'setErrorHandling' => true, |
| 'raiseError' => true, |
| 'throwError' => true, |
| 'pushErrorHandling' => true, |
| 'popErrorHandling' => true, |
| ); |
| |
| // {{{ constructor |
| |
| /** |
| * Constructor. Registers this object in |
| * $_PEAR_destructor_object_list for destructor emulation if a |
| 167,15 → 155,17 |
|---|
| * @access public |
| * @return void |
| */ |
| function PEAR($error_class = null) |
| function __construct($error_class = null) |
| { |
| $classname = strtolower(get_class($this)); |
| if ($this->_debug) { |
| print "PEAR constructor called, class=$classname\n"; |
| } |
| |
| if ($error_class !== null) { |
| $this->_error_class = $error_class; |
| } |
| |
| while ($classname && strcasecmp($classname, "pear")) { |
| $destructor = "_$classname"; |
| if (method_exists($this, $destructor)) { |
| 192,8 → 182,17 |
|---|
| } |
| } |
| |
| // }}} |
| // {{{ destructor |
| /** |
| * Only here for backwards compatibility. |
| * E.g. Archive_Tar calls $this->PEAR() in its constructor. |
| * |
| * @param string $error_class Which class to use for error objects, |
| * defaults to PEAR_Error. |
| */ |
| public function PEAR($error_class = null) |
| { |
| self::__construct($error_class); |
| } |
| |
| /** |
| * Destructor (the emulated type of...). Does nothing right now, |
| 212,9 → 211,32 |
|---|
| } |
| } |
| |
| // }}} |
| // {{{ getStaticProperty() |
| public function __call($method, $arguments) |
| { |
| if (!isset(self::$bivalentMethods[$method])) { |
| trigger_error( |
| 'Call to undefined method PEAR::' . $method . '()', E_USER_ERROR |
| ); |
| } |
| return call_user_func_array( |
| array(get_class(), '_' . $method), |
| array_merge(array($this), $arguments) |
| ); |
| } |
| |
| public static function __callStatic($method, $arguments) |
| { |
| if (!isset(self::$bivalentMethods[$method])) { |
| trigger_error( |
| 'Call to undefined method PEAR::' . $method . '()', E_USER_ERROR |
| ); |
| } |
| return call_user_func_array( |
| array(get_class(), '_' . $method), |
| array_merge(array(null), $arguments) |
| ); |
| } |
| |
| /** |
| * If you have a class that's mostly/entirely static, and you need static |
| * properties, you can use this method to simulate them. Eg. in your method(s) |
| 221,37 → 243,35 |
|---|
| * do this: $myVar = &PEAR::getStaticProperty('myclass', 'myVar'); |
| * You MUST use a reference, or they will not persist! |
| * |
| * @access public |
| * @param string $class The calling classname, to prevent clashes |
| * @param string $var The variable to retrieve. |
| * @return mixed A reference to the variable. If not set it will be |
| * auto initialised to NULL. |
| */ |
| function &getStaticProperty($class, $var) |
| public static function &getStaticProperty($class, $var) |
| { |
| static $properties; |
| if (!isset($properties[$class])) { |
| $properties[$class] = array(); |
| } |
| |
| if (!array_key_exists($var, $properties[$class])) { |
| $properties[$class][$var] = null; |
| } |
| |
| return $properties[$class][$var]; |
| } |
| |
| // }}} |
| // {{{ registerShutdownFunc() |
| |
| /** |
| * Use this function to register a shutdown method for static |
| * classes. |
| * |
| * @access public |
| * @param mixed $func The function name (or array of class/method) to call |
| * @param mixed $args The arguments to pass to the function |
| * |
| * @return void |
| */ |
| function registerShutdownFunc($func, $args = array()) |
| public static function registerShutdownFunc($func, $args = array()) |
| { |
| // if we are called statically, there is a potential |
| // that no shutdown func is registered. Bug #6445 |
| 262,9 → 282,6 |
|---|
| $GLOBALS['_PEAR_shutdown_funcs'][] = array($func, $args); |
| } |
| |
| // }}} |
| // {{{ isError() |
| |
| /** |
| * Tell whether a value is a PEAR error. |
| * |
| 273,26 → 290,24 |
|---|
| * only if $code is a string and |
| * $obj->getMessage() == $code or |
| * $code is an integer and $obj->getCode() == $code |
| * @access public |
| * |
| * @return bool true if parameter is an error |
| */ |
| function isError($data, $code = null) |
| public static function isError($data, $code = null) |
| { |
| if (is_a($data, 'PEAR_Error')) { |
| if (is_null($code)) { |
| return true; |
| } elseif (is_string($code)) { |
| return $data->getMessage() == $code; |
| } else { |
| return $data->getCode() == $code; |
| } |
| if (!is_a($data, 'PEAR_Error')) { |
| return false; |
| } |
| return false; |
| |
| if (is_null($code)) { |
| return true; |
| } elseif (is_string($code)) { |
| return $data->getMessage() == $code; |
| } |
| |
| return $data->getCode() == $code; |
| } |
| |
| // }}} |
| // {{{ setErrorHandling() |
| |
| /** |
| * Sets how errors generated by this object should be handled. |
| * Can be invoked both in objects and statically. If called |
| 300,6 → 315,9 |
|---|
| * PEAR objects. If called in an object, setErrorHandling sets |
| * the default behaviour for that object. |
| * |
| * @param object $object |
| * Object the method was called on (non-static mode) |
| * |
| * @param int $mode |
| * One of PEAR_ERROR_RETURN, PEAR_ERROR_PRINT, |
| * PEAR_ERROR_TRIGGER, PEAR_ERROR_DIE, |
| 331,12 → 349,12 |
|---|
| * |
| * @since PHP 4.0.5 |
| */ |
| |
| function setErrorHandling($mode = null, $options = null) |
| { |
| if (isset($this) && is_a($this, 'PEAR')) { |
| $setmode = &$this->_default_error_mode; |
| $setoptions = &$this->_default_error_options; |
| protected static function _setErrorHandling( |
| $object, $mode = null, $options = null |
| ) { |
| if ($object !== null) { |
| $setmode = &$object->_default_error_mode; |
| $setoptions = &$object->_default_error_options; |
| } else { |
| $setmode = &$GLOBALS['_PEAR_default_error_mode']; |
| $setoptions = &$GLOBALS['_PEAR_default_error_options']; |
| 369,9 → 387,6 |
|---|
| } |
| } |
| |
| // }}} |
| // {{{ expectError() |
| |
| /** |
| * This method is used to tell which errors you expect to get. |
| * Expected errors are always returned with error mode |
| 394,12 → 409,9 |
|---|
| } else { |
| array_push($this->_expected_errors, array($code)); |
| } |
| return sizeof($this->_expected_errors); |
| return count($this->_expected_errors); |
| } |
| |
| // }}} |
| // {{{ popExpect() |
| |
| /** |
| * This method pops one element off the expected error codes |
| * stack. |
| 411,9 → 423,6 |
|---|
| return array_pop($this->_expected_errors); |
| } |
| |
| // }}} |
| // {{{ _checkDelExpect() |
| |
| /** |
| * This method checks unsets an error code if available |
| * |
| 425,8 → 434,7 |
|---|
| function _checkDelExpect($error_code) |
| { |
| $deleted = false; |
| |
| foreach ($this->_expected_errors AS $key => $error_array) { |
| foreach ($this->_expected_errors as $key => $error_array) { |
| if (in_array($error_code, $error_array)) { |
| unset($this->_expected_errors[$key][array_search($error_code, $error_array)]); |
| $deleted = true; |
| 437,12 → 445,10 |
|---|
| unset($this->_expected_errors[$key]); |
| } |
| } |
| |
| return $deleted; |
| } |
| |
| // }}} |
| // {{{ delExpect() |
| |
| /** |
| * This method deletes all occurences of the specified element from |
| * the expected error codes stack. |
| 455,35 → 461,27 |
|---|
| function delExpect($error_code) |
| { |
| $deleted = false; |
| |
| if ((is_array($error_code) && (0 != count($error_code)))) { |
| // $error_code is a non-empty array here; |
| // we walk through it trying to unset all |
| // values |
| foreach($error_code as $key => $error) { |
| if ($this->_checkDelExpect($error)) { |
| $deleted = true; |
| } else { |
| $deleted = false; |
| } |
| // $error_code is a non-empty array here; we walk through it trying |
| // to unset all values |
| foreach ($error_code as $key => $error) { |
| $deleted = $this->_checkDelExpect($error) ? true : false; |
| } |
| |
| return $deleted ? true : PEAR::raiseError("The expected error you submitted does not exist"); // IMPROVE ME |
| } elseif (!empty($error_code)) { |
| // $error_code comes alone, trying to unset it |
| if ($this->_checkDelExpect($error_code)) { |
| return true; |
| } else { |
| return PEAR::raiseError("The expected error you submitted does not exist"); // IMPROVE ME |
| } |
| } else { |
| // $error_code is empty |
| return PEAR::raiseError("The expected error you submitted is empty"); // IMPROVE ME |
| |
| return PEAR::raiseError("The expected error you submitted does not exist"); // IMPROVE ME |
| } |
| |
| // $error_code is empty |
| return PEAR::raiseError("The expected error you submitted is empty"); // IMPROVE ME |
| } |
| |
| // }}} |
| // {{{ raiseError() |
| |
| /** |
| * This method is a wrapper that returns an instance of the |
| * configured error class with this object's default error |
| 516,12 → 514,12 |
|---|
| * @param bool $skipmsg If true, raiseError will only pass error codes, |
| * the error message parameter will be dropped. |
| * |
| * @access public |
| * @return object a PEAR error object |
| * @see PEAR::setErrorHandling |
| * @since PHP 4.0.5 |
| */ |
| function &raiseError($message = null, |
| protected static function _raiseError($object, |
| $message = null, |
| $code = null, |
| $mode = null, |
| $options = null, |
| 538,19 → 536,26 |
|---|
| $message = $message->getMessage(); |
| } |
| |
| if (isset($this) && isset($this->_expected_errors) && sizeof($this->_expected_errors) > 0 && sizeof($exp = end($this->_expected_errors))) { |
| if ( |
| $object !== null && |
| isset($object->_expected_errors) && |
| count($object->_expected_errors) > 0 && |
| count($exp = end($object->_expected_errors)) |
| ) { |
| if ($exp[0] == "*" || |
| (is_int(reset($exp)) && in_array($code, $exp)) || |
| (is_string(reset($exp)) && in_array($message, $exp))) { |
| (is_string(reset($exp)) && in_array($message, $exp)) |
| ) { |
| $mode = PEAR_ERROR_RETURN; |
| } |
| } |
| |
| // No mode given, try global ones |
| if ($mode === null) { |
| // Class error handler |
| if (isset($this) && isset($this->_default_error_mode)) { |
| $mode = $this->_default_error_mode; |
| $options = $this->_default_error_options; |
| if ($object !== null && isset($object->_default_error_mode)) { |
| $mode = $object->_default_error_mode; |
| $options = $object->_default_error_options; |
| // Global error handler |
| } elseif (isset($GLOBALS['_PEAR_default_error_mode'])) { |
| $mode = $GLOBALS['_PEAR_default_error_mode']; |
| 560,47 → 565,50 |
|---|
| |
| if ($error_class !== null) { |
| $ec = $error_class; |
| } elseif (isset($this) && isset($this->_error_class)) { |
| $ec = $this->_error_class; |
| } elseif ($object !== null && isset($object->_error_class)) { |
| $ec = $object->_error_class; |
| } else { |
| $ec = 'PEAR_Error'; |
| } |
| |
| if ($skipmsg) { |
| $a = &new $ec($code, $mode, $options, $userinfo); |
| return $a; |
| $a = new $ec($code, $mode, $options, $userinfo); |
| } else { |
| $a = &new $ec($message, $code, $mode, $options, $userinfo); |
| return $a; |
| $a = new $ec($message, $code, $mode, $options, $userinfo); |
| } |
| |
| return $a; |
| } |
| |
| // }}} |
| // {{{ throwError() |
| |
| /** |
| * Simpler form of raiseError with fewer options. In most cases |
| * message, code and userinfo are enough. |
| * |
| * @param string $message |
| * @param mixed $message a text error message or a PEAR error object |
| * |
| * @param int $code a numeric error code (it is up to your class |
| * to define these if you want to use codes) |
| * |
| * @param string $userinfo If you need to pass along for example debug |
| * information, this parameter is meant for that. |
| * |
| * @return object a PEAR error object |
| * @see PEAR::raiseError |
| */ |
| function &throwError($message = null, |
| $code = null, |
| $userinfo = null) |
| protected static function _throwError($object, $message = null, $code = null, $userinfo = null) |
| { |
| if (isset($this) && is_a($this, 'PEAR')) { |
| $a = &$this->raiseError($message, $code, null, null, $userinfo); |
| if ($object !== null) { |
| $a = &$object->raiseError($message, $code, null, null, $userinfo); |
| return $a; |
| } else { |
| $a = &PEAR::raiseError($message, $code, null, null, $userinfo); |
| return $a; |
| } |
| |
| $a = &PEAR::raiseError($message, $code, null, null, $userinfo); |
| return $a; |
| } |
| |
| // }}} |
| function staticPushErrorHandling($mode, $options = null) |
| public static function staticPushErrorHandling($mode, $options = null) |
| { |
| $stack = &$GLOBALS['_PEAR_error_handler_stack']; |
| $stack = &$GLOBALS['_PEAR_error_handler_stack']; |
| $def_mode = &$GLOBALS['_PEAR_default_error_mode']; |
| $def_options = &$GLOBALS['_PEAR_default_error_options']; |
| $stack[] = array($def_mode, $def_options); |
| 633,7 → 641,7 |
|---|
| return true; |
| } |
| |
| function staticPopErrorHandling() |
| public static function staticPopErrorHandling() |
| { |
| $stack = &$GLOBALS['_PEAR_error_handler_stack']; |
| $setmode = &$GLOBALS['_PEAR_default_error_mode']; |
| 669,8 → 677,6 |
|---|
| return true; |
| } |
| |
| // {{{ pushErrorHandling() |
| |
| /** |
| * Push a new error handler on top of the error handler options stack. With this |
| * you can easily override the actual error handler for some code and restore |
| 683,12 → 689,12 |
|---|
| * |
| * @see PEAR::setErrorHandling |
| */ |
| function pushErrorHandling($mode, $options = null) |
| protected static function _pushErrorHandling($object, $mode, $options = null) |
| { |
| $stack = &$GLOBALS['_PEAR_error_handler_stack']; |
| if (isset($this) && is_a($this, 'PEAR')) { |
| $def_mode = &$this->_default_error_mode; |
| $def_options = &$this->_default_error_options; |
| if ($object !== null) { |
| $def_mode = &$object->_default_error_mode; |
| $def_options = &$object->_default_error_options; |
| } else { |
| $def_mode = &$GLOBALS['_PEAR_default_error_mode']; |
| $def_options = &$GLOBALS['_PEAR_default_error_options']; |
| 695,8 → 701,8 |
|---|
| } |
| $stack[] = array($def_mode, $def_options); |
| |
| if (isset($this) && is_a($this, 'PEAR')) { |
| $this->setErrorHandling($mode, $options); |
| if ($object !== null) { |
| $object->setErrorHandling($mode, $options); |
| } else { |
| PEAR::setErrorHandling($mode, $options); |
| } |
| 704,9 → 710,6 |
|---|
| return true; |
| } |
| |
| // }}} |
| // {{{ popErrorHandling() |
| |
| /** |
| * Pop the last error handler used |
| * |
| 714,14 → 717,14 |
|---|
| * |
| * @see PEAR::pushErrorHandling |
| */ |
| function popErrorHandling() |
| protected static function _popErrorHandling($object) |
| { |
| $stack = &$GLOBALS['_PEAR_error_handler_stack']; |
| array_pop($stack); |
| list($mode, $options) = $stack[sizeof($stack) - 1]; |
| array_pop($stack); |
| if (isset($this) && is_a($this, 'PEAR')) { |
| $this->setErrorHandling($mode, $options); |
| if ($object !== null) { |
| $object->setErrorHandling($mode, $options); |
| } else { |
| PEAR::setErrorHandling($mode, $options); |
| } |
| 728,44 → 731,43 |
|---|
| return true; |
| } |
| |
| // }}} |
| // {{{ loadExtension() |
| |
| /** |
| * OS independant PHP extension load. Remember to take care |
| * OS independent PHP extension load. Remember to take care |
| * on the correct extension name for case sensitive OSes. |
| * |
| * @param string $ext The extension name |
| * @return bool Success or not on the dl() call |
| */ |
| function loadExtension($ext) |
| public static function loadExtension($ext) |
| { |
| if (!extension_loaded($ext)) { |
| // if either returns true dl() will produce a FATAL error, stop that |
| if ((ini_get('enable_dl') != 1) || (ini_get('safe_mode') == 1)) { |
| return false; |
| } |
| if (OS_WINDOWS) { |
| $suffix = '.dll'; |
| } elseif (PHP_OS == 'HP-UX') { |
| $suffix = '.sl'; |
| } elseif (PHP_OS == 'AIX') { |
| $suffix = '.a'; |
| } elseif (PHP_OS == 'OSX') { |
| $suffix = '.bundle'; |
| } else { |
| $suffix = '.so'; |
| } |
| return @dl('php_'.$ext.$suffix) || @dl($ext.$suffix); |
| if (extension_loaded($ext)) { |
| return true; |
| } |
| return true; |
| |
| // if either returns true dl() will produce a FATAL error, stop that |
| if ( |
| function_exists('dl') === false || |
| ini_get('enable_dl') != 1 |
| ) { |
| return false; |
| } |
| |
| if (OS_WINDOWS) { |
| $suffix = '.dll'; |
| } elseif (PHP_OS == 'HP-UX') { |
| $suffix = '.sl'; |
| } elseif (PHP_OS == 'AIX') { |
| $suffix = '.a'; |
| } elseif (PHP_OS == 'OSX') { |
| $suffix = '.bundle'; |
| } else { |
| $suffix = '.so'; |
| } |
| |
| return @dl('php_'.$ext.$suffix) || @dl($ext.$suffix); |
| } |
| |
| // }}} |
| } |
| |
| // {{{ _PEAR_call_destructors() |
| |
| function _PEAR_call_destructors() |
| { |
| global $_PEAR_destructor_object_list; |
| 773,9 → 775,13 |
|---|
| sizeof($_PEAR_destructor_object_list)) |
| { |
| reset($_PEAR_destructor_object_list); |
| if (PEAR::getStaticProperty('PEAR', 'destructlifo')) { |
| |
| $destructLifoExists = PEAR::getStaticProperty('PEAR', 'destructlifo'); |
| |
| if ($destructLifoExists) { |
| $_PEAR_destructor_object_list = array_reverse($_PEAR_destructor_object_list); |
| } |
| |
| while (list($k, $objref) = each($_PEAR_destructor_object_list)) { |
| $classname = get_class($objref); |
| while ($classname) { |
| 794,7 → 800,11 |
|---|
| } |
| |
| // Now call the shutdown functions |
| if (is_array($GLOBALS['_PEAR_shutdown_funcs']) AND !empty($GLOBALS['_PEAR_shutdown_funcs'])) { |
| if ( |
| isset($GLOBALS['_PEAR_shutdown_funcs']) && |
| is_array($GLOBALS['_PEAR_shutdown_funcs']) && |
| !empty($GLOBALS['_PEAR_shutdown_funcs']) |
| ) { |
| foreach ($GLOBALS['_PEAR_shutdown_funcs'] as $value) { |
| call_user_func_array($value[0], $value[1]); |
| } |
| 801,7 → 811,6 |
|---|
| } |
| } |
| |
| // }}} |
| /** |
| * Standard PEAR error class for PHP 4 |
| * |
| 813,8 → 822,8 |
|---|
| * @author Tomas V.V. Cox <cox@idecnet.com> |
| * @author Gregory Beaver <cellog@php.net> |
| * @copyright 1997-2006 The PHP Group |
| * @license http://www.php.net/license/3_0.txt PHP License 3.0 |
| * @version Release: 1.5.1 |
| * @license http://opensource.org/licenses/bsd-license.php New BSD License |
| * @version Release: 1.10.1 |
| * @link http://pear.php.net/manual/en/core.pear.pear-error.php |
| * @see PEAR::raiseError(), PEAR::throwError() |
| * @since Class available since PHP 4.0.2 |
| 821,8 → 830,6 |
|---|
| */ |
| class PEAR_Error |
| { |
| // {{{ properties |
| |
| var $error_message_prefix = ''; |
| var $mode = PEAR_ERROR_RETURN; |
| var $level = E_USER_NOTICE; |
| 831,9 → 838,6 |
|---|
| var $userinfo = ''; |
| var $backtrace = null; |
| |
| // }}} |
| // {{{ constructor |
| |
| /** |
| * PEAR_Error constructor |
| * |
| 854,7 → 858,7 |
|---|
| * @access public |
| * |
| */ |
| function PEAR_Error($message = 'unknown error', $code = null, |
| function __construct($message = 'unknown error', $code = null, |
| $mode = null, $options = null, $userinfo = null) |
| { |
| if ($mode === null) { |
| 864,12 → 868,16 |
|---|
| $this->code = $code; |
| $this->mode = $mode; |
| $this->userinfo = $userinfo; |
| if (!PEAR::getStaticProperty('PEAR_Error', 'skiptrace')) { |
| |
| $skiptrace = PEAR::getStaticProperty('PEAR_Error', 'skiptrace'); |
| |
| if (!$skiptrace) { |
| $this->backtrace = debug_backtrace(); |
| if (isset($this->backtrace[0]) && isset($this->backtrace[0]['object'])) { |
| unset($this->backtrace[0]['object']); |
| } |
| } |
| |
| if ($mode & PEAR_ERROR_CALLBACK) { |
| $this->level = E_USER_NOTICE; |
| $this->callback = $options; |
| 877,9 → 885,11 |
|---|
| if ($options === null) { |
| $options = E_USER_NOTICE; |
| } |
| |
| $this->level = $options; |
| $this->callback = null; |
| } |
| |
| if ($this->mode & PEAR_ERROR_PRINT) { |
| if (is_null($options) || is_int($options)) { |
| $format = "%s"; |
| 886,11 → 896,14 |
|---|
| } else { |
| $format = $options; |
| } |
| |
| printf($format, $this->getMessage()); |
| } |
| |
| if ($this->mode & PEAR_ERROR_TRIGGER) { |
| trigger_error($this->getMessage(), $this->level); |
| } |
| |
| if ($this->mode & PEAR_ERROR_DIE) { |
| $msg = $this->getMessage(); |
| if (is_null($options) || is_int($options)) { |
| 903,11 → 916,11 |
|---|
| } |
| die(sprintf($format, $msg)); |
| } |
| if ($this->mode & PEAR_ERROR_CALLBACK) { |
| if (is_callable($this->callback)) { |
| call_user_func($this->callback, $this); |
| } |
| |
| if ($this->mode & PEAR_ERROR_CALLBACK && is_callable($this->callback)) { |
| call_user_func($this->callback, $this); |
| } |
| |
| if ($this->mode & PEAR_ERROR_EXCEPTION) { |
| trigger_error("PEAR_ERROR_EXCEPTION is obsolete, use class PEAR_Exception for exceptions", E_USER_WARNING); |
| eval('$e = new Exception($this->message, $this->code);throw($e);'); |
| 914,8 → 927,23 |
|---|
| } |
| } |
| |
| // }}} |
| // {{{ getMode() |
| /** |
| * Only here for backwards compatibility. |
| * |
| * Class "Cache_Error" still uses it, among others. |
| * |
| * @param string $message Message |
| * @param int $code Error code |
| * @param int $mode Error mode |
| * @param mixed $options See __construct() |
| * @param string $userinfo Additional user/debug info |
| */ |
| public function PEAR_Error( |
| $message = 'unknown error', $code = null, $mode = null, |
| $options = null, $userinfo = null |
| ) { |
| self::__construct($message, $code, $mode, $options, $userinfo); |
| } |
| |
| /** |
| * Get the error mode from an error object. |
| 923,13 → 951,11 |
|---|
| * @return int error mode |
| * @access public |
| */ |
| function getMode() { |
| function getMode() |
| { |
| return $this->mode; |
| } |
| |
| // }}} |
| // {{{ getCallback() |
| |
| /** |
| * Get the callback function/method from an error object. |
| * |
| 936,14 → 962,11 |
|---|
| * @return mixed callback function or object/method array |
| * @access public |
| */ |
| function getCallback() { |
| function getCallback() |
| { |
| return $this->callback; |
| } |
| |
| // }}} |
| // {{{ getMessage() |
| |
| |
| /** |
| * Get the error message from an error object. |
| * |
| 955,10 → 978,6 |
|---|
| return ($this->error_message_prefix . $this->message); |
| } |
| |
| |
| // }}} |
| // {{{ getCode() |
| |
| /** |
| * Get error code from an error object |
| * |
| 970,9 → 989,6 |
|---|
| return $this->code; |
| } |
| |
| // }}} |
| // {{{ getType() |
| |
| /** |
| * Get the name of this error/exception. |
| * |
| 984,9 → 1000,6 |
|---|
| return get_class($this); |
| } |
| |
| // }}} |
| // {{{ getUserInfo() |
| |
| /** |
| * Get additional user-supplied information. |
| * |
| 998,9 → 1011,6 |
|---|
| return $this->userinfo; |
| } |
| |
| // }}} |
| // {{{ getDebugInfo() |
| |
| /** |
| * Get additional debug information supplied by the application. |
| * |
| 1012,9 → 1022,6 |
|---|
| return $this->getUserInfo(); |
| } |
| |
| // }}} |
| // {{{ getBacktrace() |
| |
| /** |
| * Get the call backtrace from where the error was generated. |
| * Supported with PHP 4.3.0 or newer. |
| 1034,9 → 1041,6 |
|---|
| return $this->backtrace[$frame]; |
| } |
| |
| // }}} |
| // {{{ addUserInfo() |
| |
| function addUserInfo($info) |
| { |
| if (empty($this->userinfo)) { |
| 1046,8 → 1050,10 |
|---|
| } |
| } |
| |
| // }}} |
| // {{{ toString() |
| function __toString() |
| { |
| return $this->getMessage(); |
| } |
| |
| /** |
| * Make a string representation of this object. |
| 1055,7 → 1061,8 |
|---|
| * @return string a string with an object summary |
| * @access public |
| */ |
| function toString() { |
| function toString() |
| { |
| $modes = array(); |
| $levels = array(E_USER_NOTICE => 'notice', |
| E_USER_WARNING => 'warning', |
| 1094,8 → 1101,6 |
|---|
| $this->error_message_prefix, |
| $this->userinfo); |
| } |
| |
| // }}} |
| } |
| |
| /* |
| 1105,4 → 1110,3 |
|---|
| * c-basic-offset: 4 |
| * End: |
| */ |
| ?> |