WebSVN – Applications.gtt – Diff – /trunk/bibliotheque/pear/PEAR/ErrorStack.php


<?php
/**
 * Error Stack Implementation
 * 
 * This is an incredibly simple implementation of a very complex error handling
 * facility.  It contains the ability
 * to track multiple errors from multiple packages simultaneously.  In addition,
 * it can track errors of many levels, save data along with the error, context
 * information such as the exact file, line number, class and function that
 * generated the error, and if necessary, it can raise a traditional PEAR_Error.
 * It has built-in support for PEAR::Log, to log errors as they occur
 * 
 * Since version 0.2alpha, it is also possible to selectively ignore errors,
 * through the use of an error callback, see {@link pushCallback()}
 * 
 * Since version 0.3alpha, it is possible to specify the exception class
 * returned from {@link push()}
 *
 * Since version PEAR1.3.2, ErrorStack no longer instantiates an exception class.  This can
 * still be done quite handily in an error callback or by manipulating the returned array
 * @category   Debugging
 * @package    PEAR_ErrorStack
 * @author     Greg Beaver <cellog@php.net>
 * @copyright  2004-2008 Greg Beaver
 * @license    http://opensource.org/licenses/bsd-license.php New BSD License
 
 * @link       http://pear.php.net/package/PEAR_ErrorStack
 */
 
/**
 * Singleton storage
 * 
 * Format:
 * <pre>
 * array(
 *  'package1' => PEAR_ErrorStack object,
 *  'package2' => PEAR_ErrorStack object,
 *  ...
 * )
 * </pre>
 * @access private
 * @global array $GLOBALS['_PEAR_ERRORSTACK_SINGLETON']
 */
$GLOBALS['_PEAR_ERRORSTACK_SINGLETON'] = array();
 
/**
 * Global error callback (default)
 * 
 * This is only used if set to non-false.  * is the default callback for
 * all packages, whereas specific packages may set a default callback
 * for all instances, regardless of whether they are a singleton or not.
 *
 * To exclude non-singletons, only set the local callback for the singleton
 * @see PEAR_ErrorStack::setDefaultCallback()
 * @access private
 * @global array $GLOBALS['_PEAR_ERRORSTACK_DEFAULT_CALLBACK']
 */
$GLOBALS['_PEAR_ERRORSTACK_DEFAULT_CALLBACK'] = array(
    '*' => false,
);
 
/**
 * Global Log object (default)
 * 
 * This is only used if set to non-false.  Use to set a default log object for
 * all stacks, regardless of instantiation order or location
 * @see PEAR_ErrorStack::setDefaultLogger()
 * @access private
 * @global array $GLOBALS['_PEAR_ERRORSTACK_DEFAULT_LOGGER']
 */
$GLOBALS['_PEAR_ERRORSTACK_DEFAULT_LOGGER'] = false;
 
/**
 * Global Overriding Callback
 * 
 * This callback will override any error callbacks that specific loggers have set.
 * Use with EXTREME caution
 * @see PEAR_ErrorStack::staticPushCallback()
 * @access private
 * @global array $GLOBALS['_PEAR_ERRORSTACK_DEFAULT_LOGGER']
 */
$GLOBALS['_PEAR_ERRORSTACK_OVERRIDE_CALLBACK'] = array();
 
/**#@+
 * One of four possible return values from the error Callback
 * @see PEAR_ErrorStack::_errorCallback()
 */
/**
 * If this is returned, then the error will be both pushed onto the stack
 * and logged.
 */
define('PEAR_ERRORSTACK_PUSHANDLOG', 1);
/**
 * If this is returned, then the error will only be pushed onto the stack,
 * and not logged.
 */
define('PEAR_ERRORSTACK_PUSH', 2);
/**
 * If this is returned, then the error will only be logged, but not pushed
 * onto the error stack.
 */
define('PEAR_ERRORSTACK_LOG', 3);
/**
 * If this is returned, then the error is completely ignored.
 */
define('PEAR_ERRORSTACK_IGNORE', 4);
/**
 * If this is returned, then the error is logged and die() is called.
 */
define('PEAR_ERRORSTACK_DIE', 5);
/**#@-*/
 
/**
 * Error code for an attempt to instantiate a non-class as a PEAR_ErrorStack in
 * the singleton method.
 */
define('PEAR_ERRORSTACK_ERR_NONCLASS', 1);
 
/**
 * Error code for an attempt to pass an object into {@link PEAR_ErrorStack::getMessage()}
 * that has no __toString() method
 */
define('PEAR_ERRORSTACK_ERR_OBJTOSTRING', 2);
/**
 * Error Stack Implementation
 *
 * Usage:
 * <code>
 * // global error stack
 * $global_stack = &PEAR_ErrorStack::singleton('MyPackage');
 * // local error stack
 * $local_stack = new PEAR_ErrorStack('MyPackage');
 * </code>
 * @author     Greg Beaver <cellog@php.net>
 * @version    1.10.1
 * @package    PEAR_ErrorStack
 * @category   Debugging
 * @copyright  2004-2008 Greg Beaver
 * @license    http://opensource.org/licenses/bsd-license.php New BSD License
 
 * @link       http://pear.php.net/package/PEAR_ErrorStack
 */
class PEAR_ErrorStack {
    /**
     * Errors are stored in the order that they are pushed on the stack.
     * @since 0.4alpha Errors are no longer organized by error level.
     * This renders pop() nearly unusable, and levels could be more easily
     * handled in a callback anyway
     * @var array
     * @access private
     */
    var $_errors = array();
 
    /**
     * Storage of errors by level.
     *
     * Allows easy retrieval and deletion of only errors from a particular level
     * @since PEAR 1.4.0dev
     * @var array
     * @access private
     */
    var $_errorsByLevel = array();
 
    /**
     * Package name this error stack represents
     * @var string
     * @access protected
     */
    var $_package;
    
    /**
     * Determines whether a PEAR_Error is thrown upon every error addition
     * @var boolean
     * @access private
     */
    var $_compat = false;
    
    /**
     * If set to a valid callback, this will be used to generate the error
     * message from the error code, otherwise the message passed in will be
     * used
     * @var false|string|array
     * @access private
     */
    var $_msgCallback = false;
    
    /**
     * If set to a valid callback, this will be used to generate the error
     * context for an error.  For PHP-related errors, this will be a file
     * and line number as retrieved from debug_backtrace(), but can be
     * customized for other purposes.  The error might actually be in a separate
     * configuration file, or in a database query.
     * @var false|string|array
     * @access protected
     */
    var $_contextCallback = false;
 
    /**
     * If set to a valid callback, this will be called every time an error
     * is pushed onto the stack.  The return value will be used to determine
     * whether to allow an error to be pushed or logged.
     *
     * The return value must be one an PEAR_ERRORSTACK_* constant
     * @see PEAR_ERRORSTACK_PUSHANDLOG, PEAR_ERRORSTACK_PUSH, PEAR_ERRORSTACK_LOG
     * @var false|string|array
     * @access protected
     */
    var $_errorCallback = array();
 
    /**
     * PEAR::Log object for logging errors
     * @var false|Log
     * @access protected
     */
    var $_logger = false;
 
    /**
     * Error messages - designed to be overridden
     * @var array
     * @abstract
     */
    var $_errorMsgs = array();
 
    /**
     * Set up a new error stack
     *
     * @param string   $package name of the package this error stack represents
     * @param callback $msgCallback callback used for error message generation
     * @param callback $contextCallback callback used for context generation,
     *                 defaults to {@link getFileLine()}
     * @param boolean  $throwPEAR_Error
     */
    function __construct($package, $msgCallback = false, $contextCallback = false,
                         $throwPEAR_Error = false)
    {
        $this->_package = $package;
        $this->setMessageCallback($msgCallback);
        $this->setContextCallback($contextCallback);
        $this->_compat = $throwPEAR_Error;
    }
    
    /**
     * Return a single error stack for this package.
     * 
     * Note that all parameters are ignored if the stack for package $package
     * has already been instantiated
     * @param string   $package name of the package this error stack represents
     * @param callback $msgCallback callback used for error message generation
     * @param callback $contextCallback callback used for context generation,
     *                 defaults to {@link getFileLine()}
     * @param boolean  $throwPEAR_Error
     * @param string   $stackClass class to instantiate
     *
     * @return PEAR_ErrorStack
     */
    public static function &singleton(
        $package, $msgCallback = false, $contextCallback = false,
        $throwPEAR_Error = false, $stackClass = 'PEAR_ErrorStack'
    ) {
        if (isset($GLOBALS['_PEAR_ERRORSTACK_SINGLETON'][$package])) {
            return $GLOBALS['_PEAR_ERRORSTACK_SINGLETON'][$package];
        }
        if (!class_exists($stackClass)) {
            if (function_exists('debug_backtrace')) {
                $trace = debug_backtrace();
            }
            PEAR_ErrorStack::staticPush('PEAR_ErrorStack', PEAR_ERRORSTACK_ERR_NONCLASS,
                'exception', array('stackclass' => $stackClass),
                'stack class "%stackclass%" is not a valid class name (should be like PEAR_ErrorStack)',
                false, $trace);
        }
        $GLOBALS['_PEAR_ERRORSTACK_SINGLETON'][$package] =
            new $stackClass($package, $msgCallback, $contextCallback, $throwPEAR_Error);
 
        return $GLOBALS['_PEAR_ERRORSTACK_SINGLETON'][$package];
    }
 
    /**
     * Internal error handler for PEAR_ErrorStack class
     * 
     * Dies if the error is an exception (and would have died anyway)
     * @access private
     */
    function _handleError($err)
    {
        if ($err['level'] == 'exception') {
            $message = $err['message'];
            if (isset($_SERVER['REQUEST_URI'])) {
                echo '<br />';
            } else {
                echo "\n";
            }
            var_dump($err['context']);
            die($message);
        }
    }
    
    /**
     * Set up a PEAR::Log object for all error stacks that don't have one
     * @param Log $log 
 
     */
    public static function setDefaultLogger(&$log)
    {
        if (is_object($log) && method_exists($log, 'log') ) {
            $GLOBALS['_PEAR_ERRORSTACK_DEFAULT_LOGGER'] = &$log;
        } elseif (is_callable($log)) {
            $GLOBALS['_PEAR_ERRORSTACK_DEFAULT_LOGGER'] = &$log;
        }
    }
    
    /**
     * Set up a PEAR::Log object for this error stack
     * @param Log $log 
     */
    function setLogger(&$log)
    {
        if (is_object($log) && method_exists($log, 'log') ) {
            $this->_logger = &$log;
        } elseif (is_callable($log)) {
            $this->_logger = &$log;
        }
    }
    
    /**
     * Set an error code => error message mapping callback
     * 
     * This method sets the callback that can be used to generate error
     * messages for any instance
     * @param array|string Callback function/method
     */
    function setMessageCallback($msgCallback)
    {
        if (!$msgCallback) {
            $this->_msgCallback = array(&$this, 'getErrorMessage');
        } else {
            if (is_callable($msgCallback)) {
                $this->_msgCallback = $msgCallback;
            }
        }
    }
    
    /**
     * Get an error code => error message mapping callback
     * 
     * This method returns the current callback that can be used to generate error
     * messages
     * @return array|string|false Callback function/method or false if none
     */
    function getMessageCallback()
    {
        return $this->_msgCallback;
    }
    
    /**
     * Sets a default callback to be used by all error stacks
     * 
     * This method sets the callback that can be used to generate error
     * messages for a singleton
     * @param array|string Callback function/method
     * @param string Package name, or false for all packages
 
     */
    public static function setDefaultCallback($callback = false, $package = false)
    {
        if (!is_callable($callback)) {
            $callback = false;
        }
        $package = $package ? $package : '*';
        $GLOBALS['_PEAR_ERRORSTACK_DEFAULT_CALLBACK'][$package] = $callback;
    }
    
    /**
     * Set a callback that generates context information (location of error) for an error stack
     * 
     * This method sets the callback that can be used to generate context
     * information for an error.  Passing in NULL will disable context generation
     * and remove the expensive call to debug_backtrace()
     * @param array|string|null Callback function/method
     */
    function setContextCallback($contextCallback)
    {
        if ($contextCallback === null) {
            return $this->_contextCallback = false;
        }
        if (!$contextCallback) {
            $this->_contextCallback = array(&$this, 'getFileLine');
        } else {
            if (is_callable($contextCallback)) {
                $this->_contextCallback = $contextCallback;
            }
        }
    }
    
    /**
     * Set an error Callback
     * If set to a valid callback, this will be called every time an error
     * is pushed onto the stack.  The return value will be used to determine
     * whether to allow an error to be pushed or logged.
     * 
     * The return value must be one of the ERRORSTACK_* constants.
     * 
     * This functionality can be used to emulate PEAR's pushErrorHandling, and
     * the PEAR_ERROR_CALLBACK mode, without affecting the integrity of
     * the error stack or logging
     * @see PEAR_ERRORSTACK_PUSHANDLOG, PEAR_ERRORSTACK_PUSH, PEAR_ERRORSTACK_LOG
     * @see popCallback()
     * @param string|array $cb
     */
    function pushCallback($cb)
    {
        array_push($this->_errorCallback, $cb);
    }
    
    /**
     * Remove a callback from the error callback stack
     * @see pushCallback()
     * @return array|string|false
     */
    function popCallback()
    {
        if (!count($this->_errorCallback)) {
            return false;
        }
        return array_pop($this->_errorCallback);
    }
    
    /**
     * Set a temporary overriding error callback for every package error stack
     *
     * Use this to temporarily disable all existing callbacks (can be used
     * to emulate the @ operator, for instance)
     * @see PEAR_ERRORSTACK_PUSHANDLOG, PEAR_ERRORSTACK_PUSH, PEAR_ERRORSTACK_LOG
     * @see staticPopCallback(), pushCallback()
     * @param string|array $cb
 
     */
    public static function staticPushCallback($cb)
    {
        array_push($GLOBALS['_PEAR_ERRORSTACK_OVERRIDE_CALLBACK'], $cb);
    }
    
    /**
     * Remove a temporary overriding error callback
     * @see staticPushCallback()
     * @return array|string|false
 
     */
    public static function staticPopCallback()
    {
        $ret = array_pop($GLOBALS['_PEAR_ERRORSTACK_OVERRIDE_CALLBACK']);
        if (!is_array($GLOBALS['_PEAR_ERRORSTACK_OVERRIDE_CALLBACK'])) {
            $GLOBALS['_PEAR_ERRORSTACK_OVERRIDE_CALLBACK'] = array();
        }
        return $ret;
    }
    
    /**
     * Add an error to the stack
     * 
     * If the message generator exists, it is called with 2 parameters.
     *  - the current Error Stack object
     *  - an array that is in the same format as an error.  Available indices
     *    are 'code', 'package', 'time', 'params', 'level', and 'context'
     * 
     * Next, if the error should contain context information, this is
     * handled by the context grabbing method.
     * Finally, the error is pushed onto the proper error stack
     * @param int    $code      Package-specific error code
     * @param string $level     Error level.  This is NOT spell-checked
     * @param array  $params    associative array of error parameters
     * @param string $msg       Error message, or a portion of it if the message
     *                          is to be generated
     * @param array  $repackage If this error re-packages an error pushed by
     *                          another package, place the array returned from
     *                          {@link pop()} in this parameter
     * @param array  $backtrace Protected parameter: use this to pass in the
     *                          {@link debug_backtrace()} that should be used
     *                          to find error context
     * @return PEAR_Error|array if compatibility mode is on, a PEAR_Error is also
     * thrown.  If a PEAR_Error is returned, the userinfo
     * property is set to the following array:
     * 
     * <code>
     * array(
     *    'code' => $code,
     *    'params' => $params,
     *    'package' => $this->_package,
     *    'level' => $level,
     *    'time' => time(),
     *    'context' => $context,
     *    'message' => $msg,
     * //['repackage' => $err] repackaged error array/Exception class
     * );
     * </code>
     * 
     * Normally, the previous array is returned.
     */
    function push($code, $level = 'error', $params = array(), $msg = false,
                  $repackage = false, $backtrace = false)
    {
        $context = false;
        // grab error context
        if ($this->_contextCallback) {
            if (!$backtrace) {
                $backtrace = debug_backtrace();
            }
            $context = call_user_func($this->_contextCallback, $code, $params, $backtrace);
        }
        
        // save error
        $time = explode(' ', microtime());
        $time = $time[1] + $time[0];
        $err = array(
                'code' => $code,
                'params' => $params,
                'package' => $this->_package,
                'level' => $level,
                'time' => $time,
                'context' => $context,
                'message' => $msg,
               );
 
        if ($repackage) {
            $err['repackage'] = $repackage;
        }
 
        // set up the error message, if necessary
        if ($this->_msgCallback) {
            $msg = call_user_func_array($this->_msgCallback,
                                        array(&$this, $err));
            $err['message'] = $msg;
        }        
        $push = $log = true;
        $die = false;
        // try the overriding callback first
        $callback = $this->staticPopCallback();
        if ($callback) {
            $this->staticPushCallback($callback);
        }
        if (!is_callable($callback)) {
            // try the local callback next
            $callback = $this->popCallback();
            if (is_callable($callback)) {
                $this->pushCallback($callback);
            } else {
                // try the default callback
                $callback = isset($GLOBALS['_PEAR_ERRORSTACK_DEFAULT_CALLBACK'][$this->_package]) ?
                    $GLOBALS['_PEAR_ERRORSTACK_DEFAULT_CALLBACK'][$this->_package] :
                    $GLOBALS['_PEAR_ERRORSTACK_DEFAULT_CALLBACK']['*'];
            }
        }
        if (is_callable($callback)) {
            switch(call_user_func($callback, $err)){
            	case PEAR_ERRORSTACK_IGNORE: 
            		return $err;
        		break;
            	case PEAR_ERRORSTACK_PUSH: 
            		$log = false;
        		break;
            	case PEAR_ERRORSTACK_LOG: 
            		$push = false;
        		break;
            	case PEAR_ERRORSTACK_DIE: 
            		$die = true;
        		break;
                // anything else returned has the same effect as pushandlog
            }
        }
        if ($push) {
            array_unshift($this->_errors, $err);
            if (!isset($this->_errorsByLevel[$err['level']])) {
                $this->_errorsByLevel[$err['level']] = array();
            }
            $this->_errorsByLevel[$err['level']][] = &$this->_errors[0];
        }
        if ($log) {
            if ($this->_logger || $GLOBALS['_PEAR_ERRORSTACK_DEFAULT_LOGGER']) {
                $this->_log($err);
            }
        }
        if ($die) {
            die();
        }
        if ($this->_compat && $push) {
            return $this->raiseError($msg, $code, null, null, $err);
        }
        return $err;
    }
    
    /**
     * Static version of {@link push()}
     * 
     * @param string $package   Package name this error belongs to
     * @param int    $code      Package-specific error code
     * @param string $level     Error level.  This is NOT spell-checked
     * @param array  $params    associative array of error parameters
     * @param string $msg       Error message, or a portion of it if the message
     *                          is to be generated
     * @param array  $repackage If this error re-packages an error pushed by
     *                          another package, place the array returned from
     *                          {@link pop()} in this parameter
     * @param array  $backtrace Protected parameter: use this to pass in the
     *                          {@link debug_backtrace()} that should be used
     *                          to find error context
     * @return PEAR_Error|array if compatibility mode is on, a PEAR_Error is also
     *                          thrown.  see docs for {@link push()}
 
     */
    public static function staticPush(
        $package, $code, $level = 'error', $params = array(),
        $msg = false, $repackage = false, $backtrace = false
    ) {
        $s = &PEAR_ErrorStack::singleton($package);
        if ($s->_contextCallback) {
            if (!$backtrace) {
                if (function_exists('debug_backtrace')) {
                    $backtrace = debug_backtrace();
                }
            }
        }
        return $s->push($code, $level, $params, $msg, $repackage, $backtrace);
    }
    
    /**
     * Log an error using PEAR::Log
     * @param array $err Error array
     * @param array $levels Error level => Log constant map
     * @access protected
     */
    function _log($err)
    {
        if ($this->_logger) {
            $logger = &$this->_logger;
        } else {
            $logger = &$GLOBALS['_PEAR_ERRORSTACK_DEFAULT_LOGGER'];
        }
        if (is_a($logger, 'Log')) {
            $levels = array(
                'exception' => PEAR_LOG_CRIT,
                'alert' => PEAR_LOG_ALERT,
                'critical' => PEAR_LOG_CRIT,
                'error' => PEAR_LOG_ERR,
                'warning' => PEAR_LOG_WARNING,
                'notice' => PEAR_LOG_NOTICE,
                'info' => PEAR_LOG_INFO,
                'debug' => PEAR_LOG_DEBUG);
            if (isset($levels[$err['level']])) {
                $level = $levels[$err['level']];
            } else {
                $level = PEAR_LOG_INFO;
            }
            $logger->log($err['message'], $level, $err);
        } else { // support non-standard logs
            call_user_func($logger, $err);
        }
    }
 
    
    /**
     * Pop an error off of the error stack
     * 
     * @return false|array
     * @since 0.4alpha it is no longer possible to specify a specific error
     * level to return - the last error pushed will be returned, instead
     */
    function pop()
    {
        $err = @array_shift($this->_errors);
        if (!is_null($err)) {
            @array_pop($this->_errorsByLevel[$err['level']]);
            if (!count($this->_errorsByLevel[$err['level']])) {
                unset($this->_errorsByLevel[$err['level']]);
            }
        }
        return $err;
    }
 
    /**
     * Pop an error off of the error stack, static method
     *
     * @param string package name
     * @return boolean
     * @since PEAR1.5.0a1
     */
    function staticPop($package)
    {
        if ($package) {
            if (!isset($GLOBALS['_PEAR_ERRORSTACK_SINGLETON'][$package])) {
                return false;
            }
            return $GLOBALS['_PEAR_ERRORSTACK_SINGLETON'][$package]->pop();
        }
    }
 
    /**
     * Determine whether there are any errors on the stack
     * @param string|array Level name.  Use to determine if any errors
     * of level (string), or levels (array) have been pushed
     * @return boolean
     */
    function hasErrors($level = false)
    {
        if ($level) {
            return isset($this->_errorsByLevel[$level]);
        }
        return count($this->_errors);
    }
    
    /**
     * Retrieve all errors since last purge
     * 
     * @param boolean set in order to empty the error stack
     * @param string level name, to return only errors of a particular severity
     * @return array
     */
    function getErrors($purge = false, $level = false)
    {
        if (!$purge) {
            if ($level) {
                if (!isset($this->_errorsByLevel[$level])) {
                    return array();
                } else {
                    return $this->_errorsByLevel[$level];
                }
            } else {
                return $this->_errors;
            }
        }
        if ($level) {
            $ret = $this->_errorsByLevel[$level];
            foreach ($this->_errorsByLevel[$level] as $i => $unused) {
                // entries are references to the $_errors array
                $this->_errorsByLevel[$level][$i] = false;
            }
            // array_filter removes all entries === false
            $this->_errors = array_filter($this->_errors);
            unset($this->_errorsByLevel[$level]);
            return $ret;
        }
        $ret = $this->_errors;
        $this->_errors = array();
        $this->_errorsByLevel = array();
        return $ret;
    }
    
    /**
     * Determine whether there are any errors on a single error stack, or on any error stack
     *
     * The optional parameter can be used to test the existence of any errors without the need of
     * singleton instantiation
     * @param string|false Package name to check for errors
     * @param string Level name to check for a particular severity
     * @return boolean
 
     */
    public static function staticHasErrors($package = false, $level = false)
    {
        if ($package) {
            if (!isset($GLOBALS['_PEAR_ERRORSTACK_SINGLETON'][$package])) {
                return false;
            }
            return $GLOBALS['_PEAR_ERRORSTACK_SINGLETON'][$package]->hasErrors($level);
        }
        foreach ($GLOBALS['_PEAR_ERRORSTACK_SINGLETON'] as $package => $obj) {
            if ($obj->hasErrors($level)) {
                return true;
            }
        }
        return false;
    }
    
    /**
     * Get a list of all errors since last purge, organized by package
     * @since PEAR 1.4.0dev BC break! $level is now in the place $merge used to be
     * @param boolean $purge Set to purge the error stack of existing errors
     * @param string  $level Set to a level name in order to retrieve only errors of a particular level
     * @param boolean $merge Set to return a flat array, not organized by package
     * @param array   $sortfunc Function used to sort a merged array - default
     *        sorts by time, and should be good for most cases
     *
     * @return array 
     */
    public static function staticGetErrors(
        $purge = false, $level = false, $merge = false,
        $sortfunc = array('PEAR_ErrorStack', '_sortErrors')
    ) {
        $ret = array();
        if (!is_callable($sortfunc)) {
            $sortfunc = array('PEAR_ErrorStack', '_sortErrors');
        }
        foreach ($GLOBALS['_PEAR_ERRORSTACK_SINGLETON'] as $package => $obj) {
            $test = $GLOBALS['_PEAR_ERRORSTACK_SINGLETON'][$package]->getErrors($purge, $level);
            if ($test) {
                if ($merge) {
                    $ret = array_merge($ret, $test);
                } else {
                    $ret[$package] = $test;
                }
            }
        }
        if ($merge) {
            usort($ret, $sortfunc);
        }
        return $ret;
    }
    
    /**
     * Error sorting function, sorts by time
     * @access private
     */
    public static function _sortErrors($a, $b)
    {
        if ($a['time'] == $b['time']) {
            return 0;
        }
        if ($a['time'] < $b['time']) {
            return 1;
        }
        return -1;
    }
 
    /**
     * Standard file/line number/function/class context callback
     *
     * This function uses a backtrace generated from {@link debug_backtrace()}
     * and so will not work at all in PHP < 4.3.0.  The frame should
     * reference the frame that contains the source of the error.
     * @return array|false either array('file' => file, 'line' => line,
     *         'function' => function name, 'class' => class name) or
     *         if this doesn't work, then false
     * @param unused
     * @param integer backtrace frame.
     * @param array Results of debug_backtrace()
 
     */
    public static function getFileLine($code, $params, $backtrace = null)
    {
        if ($backtrace === null) {
            return false;
        }
        $frame = 0;
        $functionframe = 1;
        if (!isset($backtrace[1])) {
            $functionframe = 0;
        } else {
            while (isset($backtrace[$functionframe]['function']) &&
                  $backtrace[$functionframe]['function'] == 'eval' &&
                  isset($backtrace[$functionframe + 1])) {
                $functionframe++;
            }
        }
        if (isset($backtrace[$frame])) {
            if (!isset($backtrace[$frame]['file'])) {
                $frame++;
            }
            $funcbacktrace = $backtrace[$functionframe];
            $filebacktrace = $backtrace[$frame];
            $ret = array('file' => $filebacktrace['file'],
                         'line' => $filebacktrace['line']);
            // rearrange for eval'd code or create function errors
            if (strpos($filebacktrace['file'], '(') && 
            	  preg_match(';^(.*?)\((\d+)\) : (.*?)\\z;', $filebacktrace['file'],
                  $matches)) {
                $ret['file'] = $matches[1];
                $ret['line'] = $matches[2] + 0;
            }
            if (isset($funcbacktrace['function']) && isset($backtrace[1])) {
                if ($funcbacktrace['function'] != 'eval') {
                    if ($funcbacktrace['function'] == '__lambda_func') {
                        $ret['function'] = 'create_function() code';
                    } else {
                        $ret['function'] = $funcbacktrace['function'];
                    }
                }
            }
            if (isset($funcbacktrace['class']) && isset($backtrace[1])) {
                $ret['class'] = $funcbacktrace['class'];
            }
            return $ret;
        }
        return false;
    }
    
    /**
     * Standard error message generation callback
     * 
     * This method may also be called by a custom error message generator
     * to fill in template values from the params array, simply
     * set the third parameter to the error message template string to use
     * 
     * The special variable %__msg% is reserved: use it only to specify
     * where a message passed in by the user should be placed in the template,
     * like so:
     * 
     * Error message: %msg% - internal error
     * 
     * If the message passed like so:
     * 
     * <code>
     * $stack->push(ERROR_CODE, 'error', array(), 'server error 500');
     * </code>
     * 
     * The returned error message will be "Error message: server error 500 -
     * internal error"
     * @param PEAR_ErrorStack
     * @param array
     * @param string|false Pre-generated error message template
     *
     * @return string
     */
    public static function getErrorMessage(&$stack, $err, $template = false)
    {
        if ($template) {
            $mainmsg = $template;
        } else {
            $mainmsg = $stack->getErrorMessageTemplate($err['code']);
        }
        $mainmsg = str_replace('%__msg%', $err['message'], $mainmsg);
        if (is_array($err['params']) && count($err['params'])) {
            foreach ($err['params'] as $name => $val) {
                if (is_array($val)) {
                    // @ is needed in case $val is a multi-dimensional array
                    $val = @implode(', ', $val);
                }
                if (is_object($val)) {
                    if (method_exists($val, '__toString')) {
                        $val = $val->__toString();
                    } else {
                        PEAR_ErrorStack::staticPush('PEAR_ErrorStack', PEAR_ERRORSTACK_ERR_OBJTOSTRING,
                            'warning', array('obj' => get_class($val)),
                            'object %obj% passed into getErrorMessage, but has no __toString() method');
                        $val = 'Object';
                    }
                }
                $mainmsg = str_replace('%' . $name . '%', $val, $mainmsg);
            }
        }
        return $mainmsg;
    }
    
    /**
     * Standard Error Message Template generator from code
     * @return string
     */
    function getErrorMessageTemplate($code)
    {
        if (!isset($this->_errorMsgs[$code])) {
            return '%__msg%';
        }
        return $this->_errorMsgs[$code];
    }
    
    /**
     * Set the Error Message Template array
     * 
     * The array format must be:
     * <pre>
     * array(error code => 'message template',...)
     * </pre>
     * 
     * Error message parameters passed into {@link push()} will be used as input
     * for the error message.  If the template is 'message %foo% was %bar%', and the
     * parameters are array('foo' => 'one', 'bar' => 'six'), the error message returned will
     * be 'message one was six'
     * @return string
     */
    function setErrorMessageTemplate($template)
    {
        $this->_errorMsgs = $template;
    }
    
    
    /**
     * emulate PEAR::raiseError()
     * 
     * @return PEAR_Error
     */
    function raiseError()
    {
        require_once 'PEAR.php';
        $args = func_get_args();
        return call_user_func_array(array('PEAR', 'raiseError'), $args);
    }
}
$stack = &PEAR_ErrorStack::singleton('PEAR_ErrorStack');
$stack->pushCallback(array('PEAR_ErrorStack', '_handleError'));
?>

Rev 94	Rev 187
1	`<?php`	1	`<?php`
2	`/**`	2	`/**`
3	`* Error Stack Implementation`	3	`* Error Stack Implementation`
4	`*`	4	`*`
5	`* This is an incredibly simple implementation of a very complex error handling`	5	`* This is an incredibly simple implementation of a very complex error handling`
6	`* facility. It contains the ability`	6	`* facility. It contains the ability`
7	`* to track multiple errors from multiple packages simultaneously. In addition,`	7	`* to track multiple errors from multiple packages simultaneously. In addition,`
8	`* it can track errors of many levels, save data along with the error, context`	8	`* it can track errors of many levels, save data along with the error, context`
9	`* information such as the exact file, line number, class and function that`	9	`* information such as the exact file, line number, class and function that`
10	`* generated the error, and if necessary, it can raise a traditional PEAR_Error.`	10	`* generated the error, and if necessary, it can raise a traditional PEAR_Error.`
11	`* It has built-in support for PEAR::Log, to log errors as they occur`	11	`* It has built-in support for PEAR::Log, to log errors as they occur`
12	`*`	12	`*`
13	`* Since version 0.2alpha, it is also possible to selectively ignore errors,`	13	`* Since version 0.2alpha, it is also possible to selectively ignore errors,`
14	`* through the use of an error callback, see {@link pushCallback()}`	14	`* through the use of an error callback, see {@link pushCallback()}`
15	`*`	15	`*`
16	`* Since version 0.3alpha, it is possible to specify the exception class`	16	`* Since version 0.3alpha, it is possible to specify the exception class`
17	`* returned from {@link push()}`	17	`* returned from {@link push()}`
18	`*`	18	`*`
19	`* Since version PEAR1.3.2, ErrorStack no longer instantiates an exception class. This can`	19	`* Since version PEAR1.3.2, ErrorStack no longer instantiates an exception class. This can`
20	`* still be done quite handily in an error callback or by manipulating the returned array`	20	`* still be done quite handily in an error callback or by manipulating the returned array`
21	`* @category Debugging`	21	`* @category Debugging`
22	`* @package PEAR_ErrorStack`	22	`* @package PEAR_ErrorStack`
23	`* @author Greg Beaver <cellog@php.net>`	23	`* @author Greg Beaver <cellog@php.net>`
24	`* @copyright 2004-2006 Greg Beaver`	24	`* @copyright 2004-2008 Greg Beaver`
25	`* @license http://www.php.net/license/3_0.txt PHP License 3.0`	25	`* @license http://opensource.org/licenses/bsd-license.php New BSD License`
26	`* @version CVS: $Id: ErrorStack.php,v 1.26 2006/10/31 02:54:40 cellog Exp $`	-
27	`* @link http://pear.php.net/package/PEAR_ErrorStack`	26	`* @link http://pear.php.net/package/PEAR_ErrorStack`
28	`*/`	27	`*/`
29		28
30	`/**`	29	`/**`
31	`* Singleton storage`	30	`* Singleton storage`
32	`*`	31	`*`
33	`* Format:`	32	`* Format:`
34	`* <pre>`	33	`* <pre>`
35	`* array(`	34	`* array(`
36	`* 'package1' => PEAR_ErrorStack object,`	35	`* 'package1' => PEAR_ErrorStack object,`
37	`* 'package2' => PEAR_ErrorStack object,`	36	`* 'package2' => PEAR_ErrorStack object,`
38	`* ...`	37	`* ...`
39	`* )`	38	`* )`
40	`* </pre>`	39	`* </pre>`
41	`* @access private`	40	`* @access private`
42	`* @global array $GLOBALS['_PEAR_ERRORSTACK_SINGLETON']`	41	`* @global array $GLOBALS['_PEAR_ERRORSTACK_SINGLETON']`
43	`*/`	42	`*/`
44	`$GLOBALS['_PEAR_ERRORSTACK_SINGLETON'] = array();`	43	`$GLOBALS['_PEAR_ERRORSTACK_SINGLETON'] = array();`
45		44
46	`/**`	45	`/**`
47	`* Global error callback (default)`	46	`* Global error callback (default)`
48	`*`	47	`*`
49	`* This is only used if set to non-false. * is the default callback for`	48	`* This is only used if set to non-false. * is the default callback for`
50	`* all packages, whereas specific packages may set a default callback`	49	`* all packages, whereas specific packages may set a default callback`
51	`* for all instances, regardless of whether they are a singleton or not.`	50	`* for all instances, regardless of whether they are a singleton or not.`
52	`*`	51	`*`
53	`* To exclude non-singletons, only set the local callback for the singleton`	52	`* To exclude non-singletons, only set the local callback for the singleton`
54	`* @see PEAR_ErrorStack::setDefaultCallback()`	53	`* @see PEAR_ErrorStack::setDefaultCallback()`
55	`* @access private`	54	`* @access private`
56	`* @global array $GLOBALS['_PEAR_ERRORSTACK_DEFAULT_CALLBACK']`	55	`* @global array $GLOBALS['_PEAR_ERRORSTACK_DEFAULT_CALLBACK']`
57	`*/`	56	`*/`
58	`$GLOBALS['_PEAR_ERRORSTACK_DEFAULT_CALLBACK'] = array(`	57	`$GLOBALS['_PEAR_ERRORSTACK_DEFAULT_CALLBACK'] = array(`
59	`'*' => false,`	58	`'*' => false,`
60	`);`	59	`);`
61		60
62	`/**`	61	`/**`
63	`* Global Log object (default)`	62	`* Global Log object (default)`
64	`*`	63	`*`
65	`* This is only used if set to non-false. Use to set a default log object for`	64	`* This is only used if set to non-false. Use to set a default log object for`
66	`* all stacks, regardless of instantiation order or location`	65	`* all stacks, regardless of instantiation order or location`
67	`* @see PEAR_ErrorStack::setDefaultLogger()`	66	`* @see PEAR_ErrorStack::setDefaultLogger()`
68	`* @access private`	67	`* @access private`
69	`* @global array $GLOBALS['_PEAR_ERRORSTACK_DEFAULT_LOGGER']`	68	`* @global array $GLOBALS['_PEAR_ERRORSTACK_DEFAULT_LOGGER']`
70	`*/`	69	`*/`
71	`$GLOBALS['_PEAR_ERRORSTACK_DEFAULT_LOGGER'] = false;`	70	`$GLOBALS['_PEAR_ERRORSTACK_DEFAULT_LOGGER'] = false;`
72		71
73	`/**`	72	`/**`
74	`* Global Overriding Callback`	73	`* Global Overriding Callback`
75	`*`	74	`*`
76	`* This callback will override any error callbacks that specific loggers have set.`	75	`* This callback will override any error callbacks that specific loggers have set.`
77	`* Use with EXTREME caution`	76	`* Use with EXTREME caution`
78	`* @see PEAR_ErrorStack::staticPushCallback()`	77	`* @see PEAR_ErrorStack::staticPushCallback()`
79	`* @access private`	78	`* @access private`
80	`* @global array $GLOBALS['_PEAR_ERRORSTACK_DEFAULT_LOGGER']`	79	`* @global array $GLOBALS['_PEAR_ERRORSTACK_DEFAULT_LOGGER']`
81	`*/`	80	`*/`
82	`$GLOBALS['_PEAR_ERRORSTACK_OVERRIDE_CALLBACK'] = array();`	81	`$GLOBALS['_PEAR_ERRORSTACK_OVERRIDE_CALLBACK'] = array();`
83		82
84	`/**#@+`	83	`/**#@+`
85	`* One of four possible return values from the error Callback`	84	`* One of four possible return values from the error Callback`
86	`* @see PEAR_ErrorStack::_errorCallback()`	85	`* @see PEAR_ErrorStack::_errorCallback()`
87	`*/`	86	`*/`
88	`/**`	87	`/**`
89	`* If this is returned, then the error will be both pushed onto the stack`	88	`* If this is returned, then the error will be both pushed onto the stack`
90	`* and logged.`	89	`* and logged.`
91	`*/`	90	`*/`
92	`define('PEAR_ERRORSTACK_PUSHANDLOG', 1);`	91	`define('PEAR_ERRORSTACK_PUSHANDLOG', 1);`
93	`/**`	92	`/**`
94	`* If this is returned, then the error will only be pushed onto the stack,`	93	`* If this is returned, then the error will only be pushed onto the stack,`
95	`* and not logged.`	94	`* and not logged.`
96	`*/`	95	`*/`
97	`define('PEAR_ERRORSTACK_PUSH', 2);`	96	`define('PEAR_ERRORSTACK_PUSH', 2);`
98	`/**`	97	`/**`
99	`* If this is returned, then the error will only be logged, but not pushed`	98	`* If this is returned, then the error will only be logged, but not pushed`
100	`* onto the error stack.`	99	`* onto the error stack.`
101	`*/`	100	`*/`
102	`define('PEAR_ERRORSTACK_LOG', 3);`	101	`define('PEAR_ERRORSTACK_LOG', 3);`
103	`/**`	102	`/**`
104	`* If this is returned, then the error is completely ignored.`	103	`* If this is returned, then the error is completely ignored.`
105	`*/`	104	`*/`
106	`define('PEAR_ERRORSTACK_IGNORE', 4);`	105	`define('PEAR_ERRORSTACK_IGNORE', 4);`
107	`/**`	106	`/**`
108	`* If this is returned, then the error is logged and die() is called.`	107	`* If this is returned, then the error is logged and die() is called.`
109	`*/`	108	`*/`
110	`define('PEAR_ERRORSTACK_DIE', 5);`	109	`define('PEAR_ERRORSTACK_DIE', 5);`
111	`/*#@-/`	110	`/*#@-/`
112		111
113	`/**`	112	`/**`
114	`* Error code for an attempt to instantiate a non-class as a PEAR_ErrorStack in`	113	`* Error code for an attempt to instantiate a non-class as a PEAR_ErrorStack in`
115	`* the singleton method.`	114	`* the singleton method.`
116	`*/`	115	`*/`
117	`define('PEAR_ERRORSTACK_ERR_NONCLASS', 1);`	116	`define('PEAR_ERRORSTACK_ERR_NONCLASS', 1);`
118		117
119	`/**`	118	`/**`
120	`* Error code for an attempt to pass an object into {@link PEAR_ErrorStack::getMessage()}`	119	`* Error code for an attempt to pass an object into {@link PEAR_ErrorStack::getMessage()}`
121	`* that has no __toString() method`	120	`* that has no __toString() method`
122	`*/`	121	`*/`
123	`define('PEAR_ERRORSTACK_ERR_OBJTOSTRING', 2);`	122	`define('PEAR_ERRORSTACK_ERR_OBJTOSTRING', 2);`
124	`/**`	123	`/**`
125	`* Error Stack Implementation`	124	`* Error Stack Implementation`
126	`*`	125	`*`
127	`* Usage:`	126	`* Usage:`
128	`* <code>`	127	`* <code>`
129	`* // global error stack`	128	`* // global error stack`
130	`* $global_stack = &PEAR_ErrorStack::singleton('MyPackage');`	129	`* $global_stack = &PEAR_ErrorStack::singleton('MyPackage');`
131	`* // local error stack`	130	`* // local error stack`
132	`* $local_stack = new PEAR_ErrorStack('MyPackage');`	131	`* $local_stack = new PEAR_ErrorStack('MyPackage');`
133	`* </code>`	132	`* </code>`
134	`* @author Greg Beaver <cellog@php.net>`	133	`* @author Greg Beaver <cellog@php.net>`
135	`* @version 1.5.1`	134	`* @version 1.10.1`
136	`* @package PEAR_ErrorStack`	135	`* @package PEAR_ErrorStack`
137	`* @category Debugging`	136	`* @category Debugging`
138	`* @copyright 2004-2006 Greg Beaver`	137	`* @copyright 2004-2008 Greg Beaver`
139	`* @license http://www.php.net/license/3_0.txt PHP License 3.0`	138	`* @license http://opensource.org/licenses/bsd-license.php New BSD License`
140	`* @version CVS: $Id: ErrorStack.php,v 1.26 2006/10/31 02:54:40 cellog Exp $`	-
141	`* @link http://pear.php.net/package/PEAR_ErrorStack`	139	`* @link http://pear.php.net/package/PEAR_ErrorStack`
142	`*/`	140	`*/`
143	`class PEAR_ErrorStack {`	141	`class PEAR_ErrorStack {`
144	`/**`	142	`/**`
145	`* Errors are stored in the order that they are pushed on the stack.`	143	`* Errors are stored in the order that they are pushed on the stack.`
146	`* @since 0.4alpha Errors are no longer organized by error level.`	144	`* @since 0.4alpha Errors are no longer organized by error level.`
147	`* This renders pop() nearly unusable, and levels could be more easily`	145	`* This renders pop() nearly unusable, and levels could be more easily`
148	`* handled in a callback anyway`	146	`* handled in a callback anyway`
149	`* @var array`	147	`* @var array`
150	`* @access private`	148	`* @access private`
151	`*/`	149	`*/`
152	`var $_errors = array();`	150	`var $_errors = array();`
153		151
154	`/**`	152	`/**`
155	`* Storage of errors by level.`	153	`* Storage of errors by level.`
156	`*`	154	`*`
157	`* Allows easy retrieval and deletion of only errors from a particular level`	155	`* Allows easy retrieval and deletion of only errors from a particular level`
158	`* @since PEAR 1.4.0dev`	156	`* @since PEAR 1.4.0dev`
159	`* @var array`	157	`* @var array`
160	`* @access private`	158	`* @access private`
161	`*/`	159	`*/`
162	`var $_errorsByLevel = array();`	160	`var $_errorsByLevel = array();`
163		161
164	`/**`	162	`/**`
165	`* Package name this error stack represents`	163	`* Package name this error stack represents`
166	`* @var string`	164	`* @var string`
167	`* @access protected`	165	`* @access protected`
168	`*/`	166	`*/`
169	`var $_package;`	167	`var $_package;`
170		168
171	`/**`	169	`/**`
172	`* Determines whether a PEAR_Error is thrown upon every error addition`	170	`* Determines whether a PEAR_Error is thrown upon every error addition`
173	`* @var boolean`	171	`* @var boolean`
174	`* @access private`	172	`* @access private`
175	`*/`	173	`*/`
176	`var $_compat = false;`	174	`var $_compat = false;`
177		175
178	`/**`	176	`/**`
179	`* If set to a valid callback, this will be used to generate the error`	177	`* If set to a valid callback, this will be used to generate the error`
180	`* message from the error code, otherwise the message passed in will be`	178	`* message from the error code, otherwise the message passed in will be`
181	`* used`	179	`* used`
182	`* @var false\|string\|array`	180	`* @var false\|string\|array`
183	`* @access private`	181	`* @access private`
184	`*/`	182	`*/`
185	`var $_msgCallback = false;`	183	`var $_msgCallback = false;`
186		184
187	`/**`	185	`/**`
188	`* If set to a valid callback, this will be used to generate the error`	186	`* If set to a valid callback, this will be used to generate the error`
189	`* context for an error. For PHP-related errors, this will be a file`	187	`* context for an error. For PHP-related errors, this will be a file`
190	`* and line number as retrieved from debug_backtrace(), but can be`	188	`* and line number as retrieved from debug_backtrace(), but can be`
191	`* customized for other purposes. The error might actually be in a separate`	189	`* customized for other purposes. The error might actually be in a separate`
192	`* configuration file, or in a database query.`	190	`* configuration file, or in a database query.`
193	`* @var false\|string\|array`	191	`* @var false\|string\|array`
194	`* @access protected`	192	`* @access protected`
195	`*/`	193	`*/`
196	`var $_contextCallback = false;`	194	`var $_contextCallback = false;`
197		195
198	`/**`	196	`/**`
199	`* If set to a valid callback, this will be called every time an error`	197	`* If set to a valid callback, this will be called every time an error`
200	`* is pushed onto the stack. The return value will be used to determine`	198	`* is pushed onto the stack. The return value will be used to determine`
201	`* whether to allow an error to be pushed or logged.`	199	`* whether to allow an error to be pushed or logged.`
202	`*`	200	`*`
203	`* The return value must be one an PEAR_ERRORSTACK_* constant`	201	`* The return value must be one an PEAR_ERRORSTACK_* constant`
204	`* @see PEAR_ERRORSTACK_PUSHANDLOG, PEAR_ERRORSTACK_PUSH, PEAR_ERRORSTACK_LOG`	202	`* @see PEAR_ERRORSTACK_PUSHANDLOG, PEAR_ERRORSTACK_PUSH, PEAR_ERRORSTACK_LOG`
205	`* @var false\|string\|array`	203	`* @var false\|string\|array`
206	`* @access protected`	204	`* @access protected`
207	`*/`	205	`*/`
208	`var $_errorCallback = array();`	206	`var $_errorCallback = array();`
209		207
210	`/**`	208	`/**`
211	`* PEAR::Log object for logging errors`	209	`* PEAR::Log object for logging errors`
212	`* @var false\|Log`	210	`* @var false\|Log`
213	`* @access protected`	211	`* @access protected`
214	`*/`	212	`*/`
215	`var $_logger = false;`	213	`var $_logger = false;`
216		214
217	`/**`	215	`/**`
218	`* Error messages - designed to be overridden`	216	`* Error messages - designed to be overridden`
219	`* @var array`	217	`* @var array`
220	`* @abstract`	218	`* @abstract`
221	`*/`	219	`*/`
222	`var $_errorMsgs = array();`	220	`var $_errorMsgs = array();`
223		221
224	`/**`	222	`/**`
225	`* Set up a new error stack`	223	`* Set up a new error stack`
226	`*`	224	`*`
227	`* @param string $package name of the package this error stack represents`	225	`* @param string $package name of the package this error stack represents`
228	`* @param callback $msgCallback callback used for error message generation`	226	`* @param callback $msgCallback callback used for error message generation`
229	`* @param callback $contextCallback callback used for context generation,`	227	`* @param callback $contextCallback callback used for context generation,`
230	`* defaults to {@link getFileLine()}`	228	`* defaults to {@link getFileLine()}`
231	`* @param boolean $throwPEAR_Error`	229	`* @param boolean $throwPEAR_Error`
232	`*/`	230	`*/`
233	`function PEAR_ErrorStack($package, $msgCallback = false, $contextCallback = false,`	231	`function __construct($package, $msgCallback = false, $contextCallback = false,`
234	`$throwPEAR_Error = false)`	232	`$throwPEAR_Error = false)`
235	`{`	233	`{`
236	`$this->_package = $package;`	234	`$this->_package = $package;`
237	`$this->setMessageCallback($msgCallback);`	235	`$this->setMessageCallback($msgCallback);`
238	`$this->setContextCallback($contextCallback);`	236	`$this->setContextCallback($contextCallback);`
239	`$this->_compat = $throwPEAR_Error;`	237	`$this->_compat = $throwPEAR_Error;`
240	`}`	238	`}`
241		239
242	`/**`	240	`/**`
243	`* Return a single error stack for this package.`	241	`* Return a single error stack for this package.`
244	`*`	242	`*`
245	`* Note that all parameters are ignored if the stack for package $package`	243	`* Note that all parameters are ignored if the stack for package $package`
246	`* has already been instantiated`	244	`* has already been instantiated`
247	`* @param string $package name of the package this error stack represents`	245	`* @param string $package name of the package this error stack represents`
248	`* @param callback $msgCallback callback used for error message generation`	246	`* @param callback $msgCallback callback used for error message generation`
249	`* @param callback $contextCallback callback used for context generation,`	247	`* @param callback $contextCallback callback used for context generation,`
250	`* defaults to {@link getFileLine()}`	248	`* defaults to {@link getFileLine()}`
251	`* @param boolean $throwPEAR_Error`	249	`* @param boolean $throwPEAR_Error`
252	`* @param string $stackClass class to instantiate`	250	`* @param string $stackClass class to instantiate`
253	`* @static`	251	`*`
254	`* @return PEAR_ErrorStack`	252	`* @return PEAR_ErrorStack`
255	`*/`	253	`*/`
-		254	`public static function &singleton(`
256	`function &singleton($package, $msgCallback = false, $contextCallback = false,`	255	`$package, $msgCallback = false, $contextCallback = false,`
257	`$throwPEAR_Error = false, $stackClass = 'PEAR_ErrorStack')`	256	`$throwPEAR_Error = false, $stackClass = 'PEAR_ErrorStack'`
258	`{`	257	`) {`
259	`if (isset($GLOBALS['_PEAR_ERRORSTACK_SINGLETON'][$package])) {`	258	`if (isset($GLOBALS['_PEAR_ERRORSTACK_SINGLETON'][$package])) {`
260	`return $GLOBALS['_PEAR_ERRORSTACK_SINGLETON'][$package];`	259	`return $GLOBALS['_PEAR_ERRORSTACK_SINGLETON'][$package];`
261	`}`	260	`}`
262	`if (!class_exists($stackClass)) {`	261	`if (!class_exists($stackClass)) {`
263	`if (function_exists('debug_backtrace')) {`	262	`if (function_exists('debug_backtrace')) {`
264	`$trace = debug_backtrace();`	263	`$trace = debug_backtrace();`
265	`}`	264	`}`
266	`PEAR_ErrorStack::staticPush('PEAR_ErrorStack', PEAR_ERRORSTACK_ERR_NONCLASS,`	265	`PEAR_ErrorStack::staticPush('PEAR_ErrorStack', PEAR_ERRORSTACK_ERR_NONCLASS,`
267	`'exception', array('stackclass' => $stackClass),`	266	`'exception', array('stackclass' => $stackClass),`
268	`'stack class "%stackclass%" is not a valid class name (should be like PEAR_ErrorStack)',`	267	`'stack class "%stackclass%" is not a valid class name (should be like PEAR_ErrorStack)',`
269	`false, $trace);`	268	`false, $trace);`
270	`}`	269	`}`
271	`$GLOBALS['_PEAR_ERRORSTACK_SINGLETON'][$package] =`	270	`$GLOBALS['_PEAR_ERRORSTACK_SINGLETON'][$package] =`
272	`new $stackClass($package, $msgCallback, $contextCallback, $throwPEAR_Error);`	271	`new $stackClass($package, $msgCallback, $contextCallback, $throwPEAR_Error);`
273		272
274	`return $GLOBALS['_PEAR_ERRORSTACK_SINGLETON'][$package];`	273	`return $GLOBALS['_PEAR_ERRORSTACK_SINGLETON'][$package];`
275	`}`	274	`}`
276		275
277	`/**`	276	`/**`
278	`* Internal error handler for PEAR_ErrorStack class`	277	`* Internal error handler for PEAR_ErrorStack class`
279	`*`	278	`*`
280	`* Dies if the error is an exception (and would have died anyway)`	279	`* Dies if the error is an exception (and would have died anyway)`
281	`* @access private`	280	`* @access private`
282	`*/`	281	`*/`
283	`function _handleError($err)`	282	`function _handleError($err)`
284	`{`	283	`{`
285	`if ($err['level'] == 'exception') {`	284	`if ($err['level'] == 'exception') {`
286	`$message = $err['message'];`	285	`$message = $err['message'];`
287	`if (isset($_SERVER['REQUEST_URI'])) {`	286	`if (isset($_SERVER['REQUEST_URI'])) {`
288	`echo '<br />';`	287	`echo '<br />';`
289	`} else {`	288	`} else {`
290	`echo "\n";`	289	`echo "\n";`
291	`}`	290	`}`
292	`var_dump($err['context']);`	291	`var_dump($err['context']);`
293	`die($message);`	292	`die($message);`
294	`}`	293	`}`
295	`}`	294	`}`
296		295
297	`/**`	296	`/**`
298	`* Set up a PEAR::Log object for all error stacks that don't have one`	297	`* Set up a PEAR::Log object for all error stacks that don't have one`
299	`* @param Log $log`	298	`* @param Log $log`
300	`* @static`	-
301	`*/`	299	`*/`
302	`function setDefaultLogger(&$log)`	300	`public static function setDefaultLogger(&$log)`
303	`{`	301	`{`
304	`if (is_object($log) && method_exists($log, 'log') ) {`	302	`if (is_object($log) && method_exists($log, 'log') ) {`
305	`$GLOBALS['_PEAR_ERRORSTACK_DEFAULT_LOGGER'] = &$log;`	303	`$GLOBALS['_PEAR_ERRORSTACK_DEFAULT_LOGGER'] = &$log;`
306	`} elseif (is_callable($log)) {`	304	`} elseif (is_callable($log)) {`
307	`$GLOBALS['_PEAR_ERRORSTACK_DEFAULT_LOGGER'] = &$log;`	305	`$GLOBALS['_PEAR_ERRORSTACK_DEFAULT_LOGGER'] = &$log;`
308	`}`	306	`}`
309	`}`	307	`}`
310		308
311	`/**`	309	`/**`
312	`* Set up a PEAR::Log object for this error stack`	310	`* Set up a PEAR::Log object for this error stack`
313	`* @param Log $log`	311	`* @param Log $log`
314	`*/`	312	`*/`
315	`function setLogger(&$log)`	313	`function setLogger(&$log)`
316	`{`	314	`{`
317	`if (is_object($log) && method_exists($log, 'log') ) {`	315	`if (is_object($log) && method_exists($log, 'log') ) {`
318	`$this->_logger = &$log;`	316	`$this->_logger = &$log;`
319	`} elseif (is_callable($log)) {`	317	`} elseif (is_callable($log)) {`
320	`$this->_logger = &$log;`	318	`$this->_logger = &$log;`
321	`}`	319	`}`
322	`}`	320	`}`
323		321
324	`/**`	322	`/**`
325	`* Set an error code => error message mapping callback`	323	`* Set an error code => error message mapping callback`
326	`*`	324	`*`
327	`* This method sets the callback that can be used to generate error`	325	`* This method sets the callback that can be used to generate error`
328	`* messages for any instance`	326	`* messages for any instance`
329	`* @param array\|string Callback function/method`	327	`* @param array\|string Callback function/method`
330	`*/`	328	`*/`
331	`function setMessageCallback($msgCallback)`	329	`function setMessageCallback($msgCallback)`
332	`{`	330	`{`
333	`if (!$msgCallback) {`	331	`if (!$msgCallback) {`
334	`$this->_msgCallback = array(&$this, 'getErrorMessage');`	332	`$this->_msgCallback = array(&$this, 'getErrorMessage');`
335	`} else {`	333	`} else {`
336	`if (is_callable($msgCallback)) {`	334	`if (is_callable($msgCallback)) {`
337	`$this->_msgCallback = $msgCallback;`	335	`$this->_msgCallback = $msgCallback;`
338	`}`	336	`}`
339	`}`	337	`}`
340	`}`	338	`}`
341		339
342	`/**`	340	`/**`
343	`* Get an error code => error message mapping callback`	341	`* Get an error code => error message mapping callback`
344	`*`	342	`*`
345	`* This method returns the current callback that can be used to generate error`	343	`* This method returns the current callback that can be used to generate error`
346	`* messages`	344	`* messages`
347	`* @return array\|string\|false Callback function/method or false if none`	345	`* @return array\|string\|false Callback function/method or false if none`
348	`*/`	346	`*/`
349	`function getMessageCallback()`	347	`function getMessageCallback()`
350	`{`	348	`{`
351	`return $this->_msgCallback;`	349	`return $this->_msgCallback;`
352	`}`	350	`}`
353		351
354	`/**`	352	`/**`
355	`* Sets a default callback to be used by all error stacks`	353	`* Sets a default callback to be used by all error stacks`
356	`*`	354	`*`
357	`* This method sets the callback that can be used to generate error`	355	`* This method sets the callback that can be used to generate error`
358	`* messages for a singleton`	356	`* messages for a singleton`
359	`* @param array\|string Callback function/method`	357	`* @param array\|string Callback function/method`
360	`* @param string Package name, or false for all packages`	358	`* @param string Package name, or false for all packages`
361	`* @static`	-
362	`*/`	359	`*/`
363	`function setDefaultCallback($callback = false, $package = false)`	360	`public static function setDefaultCallback($callback = false, $package = false)`
364	`{`	361	`{`
365	`if (!is_callable($callback)) {`	362	`if (!is_callable($callback)) {`
366	`$callback = false;`	363	`$callback = false;`
367	`}`	364	`}`
368	`$package = $package ? $package : '*';`	365	`$package = $package ? $package : '*';`
369	`$GLOBALS['_PEAR_ERRORSTACK_DEFAULT_CALLBACK'][$package] = $callback;`	366	`$GLOBALS['_PEAR_ERRORSTACK_DEFAULT_CALLBACK'][$package] = $callback;`
370	`}`	367	`}`
371		368
372	`/**`	369	`/**`
373	`* Set a callback that generates context information (location of error) for an error stack`	370	`* Set a callback that generates context information (location of error) for an error stack`
374	`*`	371	`*`
375	`* This method sets the callback that can be used to generate context`	372	`* This method sets the callback that can be used to generate context`
376	`* information for an error. Passing in NULL will disable context generation`	373	`* information for an error. Passing in NULL will disable context generation`
377	`* and remove the expensive call to debug_backtrace()`	374	`* and remove the expensive call to debug_backtrace()`
378	`* @param array\|string\|null Callback function/method`	375	`* @param array\|string\|null Callback function/method`
379	`*/`	376	`*/`
380	`function setContextCallback($contextCallback)`	377	`function setContextCallback($contextCallback)`
381	`{`	378	`{`
382	`if ($contextCallback === null) {`	379	`if ($contextCallback === null) {`
383	`return $this->_contextCallback = false;`	380	`return $this->_contextCallback = false;`
384	`}`	381	`}`
385	`if (!$contextCallback) {`	382	`if (!$contextCallback) {`
386	`$this->_contextCallback = array(&$this, 'getFileLine');`	383	`$this->_contextCallback = array(&$this, 'getFileLine');`
387	`} else {`	384	`} else {`
388	`if (is_callable($contextCallback)) {`	385	`if (is_callable($contextCallback)) {`
389	`$this->_contextCallback = $contextCallback;`	386	`$this->_contextCallback = $contextCallback;`
390	`}`	387	`}`
391	`}`	388	`}`
392	`}`	389	`}`
393		390
394	`/**`	391	`/**`
395	`* Set an error Callback`	392	`* Set an error Callback`
396	`* If set to a valid callback, this will be called every time an error`	393	`* If set to a valid callback, this will be called every time an error`
397	`* is pushed onto the stack. The return value will be used to determine`	394	`* is pushed onto the stack. The return value will be used to determine`
398	`* whether to allow an error to be pushed or logged.`	395	`* whether to allow an error to be pushed or logged.`
399	`*`	396	`*`
400	`* The return value must be one of the ERRORSTACK_* constants.`	397	`* The return value must be one of the ERRORSTACK_* constants.`
401	`*`	398	`*`
402	`* This functionality can be used to emulate PEAR's pushErrorHandling, and`	399	`* This functionality can be used to emulate PEAR's pushErrorHandling, and`
403	`* the PEAR_ERROR_CALLBACK mode, without affecting the integrity of`	400	`* the PEAR_ERROR_CALLBACK mode, without affecting the integrity of`
404	`* the error stack or logging`	401	`* the error stack or logging`
405	`* @see PEAR_ERRORSTACK_PUSHANDLOG, PEAR_ERRORSTACK_PUSH, PEAR_ERRORSTACK_LOG`	402	`* @see PEAR_ERRORSTACK_PUSHANDLOG, PEAR_ERRORSTACK_PUSH, PEAR_ERRORSTACK_LOG`
406	`* @see popCallback()`	403	`* @see popCallback()`
407	`* @param string\|array $cb`	404	`* @param string\|array $cb`
408	`*/`	405	`*/`
409	`function pushCallback($cb)`	406	`function pushCallback($cb)`
410	`{`	407	`{`
411	`array_push($this->_errorCallback, $cb);`	408	`array_push($this->_errorCallback, $cb);`
412	`}`	409	`}`
413		410
414	`/**`	411	`/**`
415	`* Remove a callback from the error callback stack`	412	`* Remove a callback from the error callback stack`
416	`* @see pushCallback()`	413	`* @see pushCallback()`
417	`* @return array\|string\|false`	414	`* @return array\|string\|false`
418	`*/`	415	`*/`
419	`function popCallback()`	416	`function popCallback()`
420	`{`	417	`{`
421	`if (!count($this->_errorCallback)) {`	418	`if (!count($this->_errorCallback)) {`
422	`return false;`	419	`return false;`
423	`}`	420	`}`
424	`return array_pop($this->_errorCallback);`	421	`return array_pop($this->_errorCallback);`
425	`}`	422	`}`
426		423
427	`/**`	424	`/**`
428	`* Set a temporary overriding error callback for every package error stack`	425	`* Set a temporary overriding error callback for every package error stack`
429	`*`	426	`*`
430	`* Use this to temporarily disable all existing callbacks (can be used`	427	`* Use this to temporarily disable all existing callbacks (can be used`
431	`* to emulate the @ operator, for instance)`	428	`* to emulate the @ operator, for instance)`
432	`* @see PEAR_ERRORSTACK_PUSHANDLOG, PEAR_ERRORSTACK_PUSH, PEAR_ERRORSTACK_LOG`	429	`* @see PEAR_ERRORSTACK_PUSHANDLOG, PEAR_ERRORSTACK_PUSH, PEAR_ERRORSTACK_LOG`
433	`* @see staticPopCallback(), pushCallback()`	430	`* @see staticPopCallback(), pushCallback()`
434	`* @param string\|array $cb`	431	`* @param string\|array $cb`
435	`* @static`	-
436	`*/`	432	`*/`
437	`function staticPushCallback($cb)`	433	`public static function staticPushCallback($cb)`
438	`{`	434	`{`
439	`array_push($GLOBALS['_PEAR_ERRORSTACK_OVERRIDE_CALLBACK'], $cb);`	435	`array_push($GLOBALS['_PEAR_ERRORSTACK_OVERRIDE_CALLBACK'], $cb);`
440	`}`	436	`}`
441		437
442	`/**`	438	`/**`
443	`* Remove a temporary overriding error callback`	439	`* Remove a temporary overriding error callback`
444	`* @see staticPushCallback()`	440	`* @see staticPushCallback()`
445	`* @return array\|string\|false`	441	`* @return array\|string\|false`
446	`* @static`	-
447	`*/`	442	`*/`
448	`function staticPopCallback()`	443	`public static function staticPopCallback()`
449	`{`	444	`{`
450	`$ret = array_pop($GLOBALS['_PEAR_ERRORSTACK_OVERRIDE_CALLBACK']);`	445	`$ret = array_pop($GLOBALS['_PEAR_ERRORSTACK_OVERRIDE_CALLBACK']);`
451	`if (!is_array($GLOBALS['_PEAR_ERRORSTACK_OVERRIDE_CALLBACK'])) {`	446	`if (!is_array($GLOBALS['_PEAR_ERRORSTACK_OVERRIDE_CALLBACK'])) {`
452	`$GLOBALS['_PEAR_ERRORSTACK_OVERRIDE_CALLBACK'] = array();`	447	`$GLOBALS['_PEAR_ERRORSTACK_OVERRIDE_CALLBACK'] = array();`
453	`}`	448	`}`
454	`return $ret;`	449	`return $ret;`
455	`}`	450	`}`
456		451
457	`/**`	452	`/**`
458	`* Add an error to the stack`	453	`* Add an error to the stack`
459	`*`	454	`*`
460	`* If the message generator exists, it is called with 2 parameters.`	455	`* If the message generator exists, it is called with 2 parameters.`
461	`* - the current Error Stack object`	456	`* - the current Error Stack object`
462	`* - an array that is in the same format as an error. Available indices`	457	`* - an array that is in the same format as an error. Available indices`
463	`* are 'code', 'package', 'time', 'params', 'level', and 'context'`	458	`* are 'code', 'package', 'time', 'params', 'level', and 'context'`
464	`*`	459	`*`
465	`* Next, if the error should contain context information, this is`	460	`* Next, if the error should contain context information, this is`
466	`* handled by the context grabbing method.`	461	`* handled by the context grabbing method.`
467	`* Finally, the error is pushed onto the proper error stack`	462	`* Finally, the error is pushed onto the proper error stack`
468	`* @param int $code Package-specific error code`	463	`* @param int $code Package-specific error code`
469	`* @param string $level Error level. This is NOT spell-checked`	464	`* @param string $level Error level. This is NOT spell-checked`
470	`* @param array $params associative array of error parameters`	465	`* @param array $params associative array of error parameters`
471	`* @param string $msg Error message, or a portion of it if the message`	466	`* @param string $msg Error message, or a portion of it if the message`
472	`* is to be generated`	467	`* is to be generated`
473	`* @param array $repackage If this error re-packages an error pushed by`	468	`* @param array $repackage If this error re-packages an error pushed by`
474	`* another package, place the array returned from`	469	`* another package, place the array returned from`
475	`* {@link pop()} in this parameter`	470	`* {@link pop()} in this parameter`
476	`* @param array $backtrace Protected parameter: use this to pass in the`	471	`* @param array $backtrace Protected parameter: use this to pass in the`
477	`* {@link debug_backtrace()} that should be used`	472	`* {@link debug_backtrace()} that should be used`
478	`* to find error context`	473	`* to find error context`
479	`* @return PEAR_Error\|array if compatibility mode is on, a PEAR_Error is also`	474	`* @return PEAR_Error\|array if compatibility mode is on, a PEAR_Error is also`
480	`* thrown. If a PEAR_Error is returned, the userinfo`	475	`* thrown. If a PEAR_Error is returned, the userinfo`
481	`* property is set to the following array:`	476	`* property is set to the following array:`
482	`*`	477	`*`
483	`* <code>`	478	`* <code>`
484	`* array(`	479	`* array(`
485	`* 'code' => $code,`	480	`* 'code' => $code,`
486	`* 'params' => $params,`	481	`* 'params' => $params,`
487	`* 'package' => $this->_package,`	482	`* 'package' => $this->_package,`
488	`* 'level' => $level,`	483	`* 'level' => $level,`
489	`* 'time' => time(),`	484	`* 'time' => time(),`
490	`* 'context' => $context,`	485	`* 'context' => $context,`
491	`* 'message' => $msg,`	486	`* 'message' => $msg,`
492	`* //['repackage' => $err] repackaged error array/Exception class`	487	`* //['repackage' => $err] repackaged error array/Exception class`
493	`* );`	488	`* );`
494	`* </code>`	489	`* </code>`
495	`*`	490	`*`
496	`* Normally, the previous array is returned.`	491	`* Normally, the previous array is returned.`
497	`*/`	492	`*/`
498	`function push($code, $level = 'error', $params = array(), $msg = false,`	493	`function push($code, $level = 'error', $params = array(), $msg = false,`
499	`$repackage = false, $backtrace = false)`	494	`$repackage = false, $backtrace = false)`

Subversion Repositories Applications.gtt

(root)/trunk/bibliotheque/pear/PEAR/ErrorStack.php – Rev 94 → 187