Public Member Functions
	__construct ($package, $msgCallback=false, $contextCallback=false, $throwPEAR_Error=false)
	_handleError ($err)
	_log ($err)
	getErrorMessageTemplate ($code)
	getErrors ($purge=false, $level=false)
	getMessageCallback ()
	hasErrors ($level=false)
	pop ()
	popCallback ()
	push ($code, $level='error', $params=array(), $msg=false, $repackage=false, $backtrace=false)
	pushCallback ($cb)
	raiseError ()
	setContextCallback ($contextCallback)
	setErrorMessageTemplate ($template)
	setLogger (&$log)
	setMessageCallback ($msgCallback)

Static Public Member Functions
static	_sortErrors ($a, $b)
static	getErrorMessage (&$stack, $err, $template=false)
static	getFileLine ($code, $params, $backtrace=null)
static	setDefaultCallback ($callback=false, $package=false)
static	setDefaultLogger (&$log)
static &	singleton ( $package, $msgCallback=false, $contextCallback=false, $throwPEAR_Error=false, $stackClass='PEAR_ErrorStack')
static	staticGetErrors ( $purge=false, $level=false, $merge=false, $sortfunc=array('PEAR_ErrorStack', '_sortErrors'))
static	staticHasErrors ($package=false, $level=false)
static	staticPop ($package)
static	staticPopCallback ()
static	staticPush ( $package, $code, $level='error', $params=array(), $msg=false, $repackage=false, $backtrace=false)
static	staticPushCallback ($cb)

Data Fields
	$_compat = false
	$_contextCallback = false
	$_errorCallback = array()
	$_errorMsgs = array()
	$_errors = array()
	$_errorsByLevel = array()
	$_logger = false
	$_msgCallback = false
	$_package

Detailed Description

Copyright: 2004-2008 Greg Beaver @license http://opensource.org/licenses/bsd-license.php New BSD License http://pear.php.net/package/PEAR_ErrorStack

Definition at line 141 of file ErrorStack.php.

Constructor & Destructor Documentation

◆ __construct()

__construct	(	$package,
		$msgCallback = false,
		$contextCallback = false,
		$throwPEAR_Error = false )

Set up a new error stack

Parameters

string	$package	name of the package this error stack represents
callback	$msgCallback	callback used for error message generation
callback	$contextCallback	callback used for context generation, defaults to `getFileLine()`
boolean	$throwPEAR_Error

Definition at line 231 of file ErrorStack.php.

    {
        $this->_package = $package;
        $this->setMessageCallback($msgCallback);
        $this->setContextCallback($contextCallback);
        $this->_compat = $throwPEAR_Error;
    }

References setContextCallback(), and setMessageCallback().

Here is the call graph for this function:

Member Function Documentation

◆ _handleError()

_handleError ( $err )

Internal error handler for PEAR_ErrorStack class

Dies if the error is an exception (and would have died anyway) @access private

Definition at line 282 of file ErrorStack.php.

    {
        if ($err['level'] == 'exception') {
            $message = $err['message'];
            if (isset($_SERVER['REQUEST_URI'])) {
                echo '<br />';
            } else {
                echo "\n";
            }
            var_dump($err['context']);
            die($message);
        }
    }

◆ _log()

_log ( $err )

Log an error using PEAR::Log

Parameters

array	$err	Error array
array	$levels	Error level => Log constant map @access protected

Definition at line 624 of file ErrorStack.php.

    {
        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);
        }
    }

References $GLOBALS.

Referenced by push().

Here is the caller graph for this function:

◆ _sortErrors()

_sortErrors	(		$a,
			$b )

static

Error sorting function, sorts by time @access private

Definition at line 804 of file ErrorStack.php.

    {
        if ($a['time'] == $b['time']) {
            return 0;
        }
        if ($a['time'] < $b['time']) {
            return 1;
        }
        return -1;
    }

◆ getErrorMessage()

getErrorMessage	(	&	$stack,
			$err,
			$template = false )

static

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:

$stack->push(ERROR_CODE, 'error', array(), 'server error 500');

The returned error message will be "Error message: server error 500 - internal error"

Parameters

PEAR_ErrorStack
array
string\|false	Pre-generated error message template

Returns: string

Definition at line 903 of file ErrorStack.php.

    {
        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;
    }

References $stack, PEAR_ERRORSTACK_ERR_OBJTOSTRING, and staticPush().

Here is the call graph for this function:

◆ getErrorMessageTemplate()

getErrorMessageTemplate ( $code )

Standard Error Message Template generator from code

Returns: string

Definition at line 937 of file ErrorStack.php.

    {
        if (!isset($this->_errorMsgs[$code])) {
            return '%__msg%';
        }
        return $this->_errorMsgs[$code];
    }

◆ getErrors()

getErrors	(		$purge = false,
			$level = false )

Retrieve all errors since last purge

Parameters

boolean	set in order to empty the error stack
string	level name, to return only errors of a particular severity

Returns: array

Definition at line 710 of file ErrorStack.php.

    {
        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;
    }

◆ getFileLine()

getFileLine	(	$code,
		$params,
		$backtrace = null )

static

Standard file/line number/function/class context callback

This function uses a backtrace generated from 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.

Returns: array|false either array('file' => file, 'line' => line, 'function' => function name, 'class' => class name) or if this doesn't work, then false

Parameters

unused
integer	backtrace frame.
array	Results of debug_backtrace()

Definition at line 828 of file ErrorStack.php.

    {
        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;
    }

◆ getMessageCallback()

getMessageCallback ( )

Get an error code => error message mapping callback

This method returns the current callback that can be used to generate error messages

Returns: array|string|false Callback function/method or false if none

Definition at line 347 of file ErrorStack.php.

    {
        return $this->_msgCallback;
    }

◆ hasErrors()

hasErrors ( $level = false )

Determine whether there are any errors on the stack

Parameters

string|array Level name. Use to determine if any errors of level (string), or levels (array) have been pushed

Returns: boolean

Definition at line 695 of file ErrorStack.php.

    {
        if ($level) {
            return isset($this->_errorsByLevel[$level]);
        }
        return count($this->_errors);
    }

◆ pop()

pop ( )

Pop an error off of the error stack

Returns: 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

Definition at line 660 of file ErrorStack.php.

    {
        $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;
    }

◆ popCallback()

popCallback ( )

Remove a callback from the error callback stack

See also: pushCallback()

Returns: array|string|false

Definition at line 416 of file ErrorStack.php.

    {
        if (!count($this->_errorCallback)) {
            return false;
        }
        return array_pop($this->_errorCallback);
    }

Referenced by push().

Here is the caller graph for this function:

◆ push()

push	(	$code,
		$level = 'error',
		$params = array(),
		$msg = false,
		$repackage = false,
		$backtrace = false )

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

Parameters

int	$code	Package-specific error code
string	$level	Error level. This is NOT spell-checked
array	$params	associative array of error parameters
string	$msg	Error message, or a portion of it if the message is to be generated
array	$repackage	If this error re-packages an error pushed by another package, place the array returned from `pop()` in this parameter
array	$backtrace	Protected parameter: use this to pass in the `debug_backtrace()` that should be used to find error context

Returns: 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:

array( 'code' => $code, 'params' => $params, 'package' => $this->_package, 'level' => $level, 'time' => time(), 'context' => $context, 'message' => $msg, //['repackage' => $err] repackaged error array/Exception class );

Normally, the previous array is returned.

Definition at line 493 of file ErrorStack.php.

    {
        $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;
    }

References $GLOBALS, _log(), PEAR_ERRORSTACK_DIE, PEAR_ERRORSTACK_IGNORE, PEAR_ERRORSTACK_LOG, PEAR_ERRORSTACK_PUSH, popCallback(), pushCallback(), raiseError(), staticPopCallback(), and staticPushCallback().

Here is the call graph for this function:

◆ pushCallback()

pushCallback ( $cb )

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 also: PEAR_ERRORSTACK_PUSHANDLOG, PEAR_ERRORSTACK_PUSH, PEAR_ERRORSTACK_LOG; popCallback()

Parameters

string | array $cb

Definition at line 406 of file ErrorStack.php.

    {
        array_push($this->_errorCallback, $cb);
    }

Referenced by push().

Here is the caller graph for this function:

◆ raiseError()

raiseError ( )

emulate PEAR::raiseError()

Returns: PEAR_Error

Definition at line 970 of file ErrorStack.php.

    {
        require_once 'PEAR.php';
        $args = func_get_args();
        return call_user_func_array(array('PEAR', 'raiseError'), $args);
    }

Referenced by push().

Here is the caller graph for this function:

◆ setContextCallback()

setContextCallback ( $contextCallback )

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()

Parameters

array|string|null Callback function/method

Definition at line 377 of file ErrorStack.php.

    {
        if ($contextCallback === null) {
            return $this->_contextCallback = false;
        }
        if (!$contextCallback) {
            $this->_contextCallback = array(&$this, 'getFileLine');
        } else {
            if (is_callable($contextCallback)) {
                $this->_contextCallback = $contextCallback;
            }
        }
    }

Referenced by __construct().

Here is the caller graph for this function:

◆ setDefaultCallback()

setDefaultCallback	(		$callback = false,
			$package = false )

static

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

Parameters

array\|string	Callback function/method
string	Package name, or false for all packages

Definition at line 360 of file ErrorStack.php.

    {
        if (!is_callable($callback)) {
            $callback = false;
        }
        $package = $package ? $package : '*';
        $GLOBALS['_PEAR_ERRORSTACK_DEFAULT_CALLBACK'][$package] = $callback;
    }

References $GLOBALS.

◆ setDefaultLogger()

setDefaultLogger ( & $log )

static

Set up a PEAR::Log object for all error stacks that don't have one

Parameters

Log $log

Definition at line 300 of file ErrorStack.php.

    {
        if (is_object($log) && method_exists($log, 'log') ) {
            $GLOBALS['_PEAR_ERRORSTACK_DEFAULT_LOGGER'] = &$log;
        } elseif (is_callable($log)) {
            $GLOBALS['_PEAR_ERRORSTACK_DEFAULT_LOGGER'] = &$log;
        }
    }

References $GLOBALS.

◆ setErrorMessageTemplate()

setErrorMessageTemplate ( $template )

Set the Error Message Template array

The array format must be:

array(error code => 'message template',...)

Error message parameters passed into 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'

Returns: string

Definition at line 959 of file ErrorStack.php.

    {
        $this->_errorMsgs = $template;
    }

◆ setLogger()

setLogger ( & $log )

Set up a PEAR::Log object for this error stack

Parameters

Log $log

Definition at line 313 of file ErrorStack.php.

    {
        if (is_object($log) && method_exists($log, 'log') ) {
            $this->_logger = &$log;
        } elseif (is_callable($log)) {
            $this->_logger = &$log;
        }
    }

◆ setMessageCallback()

setMessageCallback ( $msgCallback )

Set an error code => error message mapping callback

This method sets the callback that can be used to generate error messages for any instance

Parameters

array|string Callback function/method

Definition at line 329 of file ErrorStack.php.

    {
        if (!$msgCallback) {
            $this->_msgCallback = array(&$this, 'getErrorMessage');
        } else {
            if (is_callable($msgCallback)) {
                $this->_msgCallback = $msgCallback;
            }
        }
    }

Referenced by __construct().

Here is the caller graph for this function:

◆ singleton()

& singleton	(	$package,
		$msgCallback = false,
		$contextCallback = false,
		$throwPEAR_Error = false,
		$stackClass = 'PEAR_ErrorStack' )

static

Return a single error stack for this package.

Note that all parameters are ignored if the stack for package $package has already been instantiated

Parameters

string	$package	name of the package this error stack represents
callback	$msgCallback	callback used for error message generation
callback	$contextCallback	callback used for context generation, defaults to `getFileLine()`
boolean	$throwPEAR_Error
string	$stackClass	class to instantiate

Returns: PEAR_ErrorStack

Definition at line 254 of file ErrorStack.php.

      {
        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];
    }

References $GLOBALS, PEAR_ERRORSTACK_ERR_NONCLASS, and staticPush().

Referenced by staticPush().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ staticGetErrors()

staticGetErrors	(	$purge = false,
		$level = false,
		$merge = false,
		$sortfunc = array('PEAR_ErrorStack', '_sortErrors') )

static

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

Parameters

boolean	$purge	Set to purge the error stack of existing errors
string	$level	Set to a level name in order to retrieve only errors of a particular level
boolean	$merge	Set to return a flat array, not organized by package
array	$sortfunc	Function used to sort a merged array - default sorts by time, and should be good for most cases

Returns: array

Definition at line 776 of file ErrorStack.php.

      {
        $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;
    }

References $GLOBALS.

◆ staticHasErrors()

staticHasErrors	(		$package = false,
			$level = false )

static

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

Parameters

string\|false	Package name to check for errors
string	Level name to check for a particular severity

Returns: boolean

Definition at line 749 of file ErrorStack.php.

    {
        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;
    }

References $GLOBALS.

◆ staticPop()

staticPop ( $package )

static

Pop an error off of the error stack, static method

Parameters

string package name

Returns: boolean

Since: PEAR1.5.0a1

Definition at line 679 of file ErrorStack.php.

    {
        if ($package) {
            if (!isset($GLOBALS['_PEAR_ERRORSTACK_SINGLETON'][$package])) {
                return false;
            }
            return $GLOBALS['_PEAR_ERRORSTACK_SINGLETON'][$package]->pop();
        }
    }

References $GLOBALS.

◆ staticPopCallback()

staticPopCallback ( )

static

Remove a temporary overriding error callback

See also: staticPushCallback()

Returns: array|string|false

Definition at line 443 of file ErrorStack.php.

    {
        $ret = array_pop($GLOBALS['_PEAR_ERRORSTACK_OVERRIDE_CALLBACK']);
        if (!is_array($GLOBALS['_PEAR_ERRORSTACK_OVERRIDE_CALLBACK'])) {
            $GLOBALS['_PEAR_ERRORSTACK_OVERRIDE_CALLBACK'] = array();
        }
        return $ret;
    }

References $GLOBALS.

Referenced by push().

Here is the caller graph for this function:

◆ staticPush()

staticPush	(	$package,
		$code,
		$level = 'error',
		$params = array(),
		$msg = false,
		$repackage = false,
		$backtrace = false )

static

Static version of push()

Parameters

string	$package	Package name this error belongs to
int	$code	Package-specific error code
string	$level	Error level. This is NOT spell-checked
array	$params	associative array of error parameters
string	$msg	Error message, or a portion of it if the message is to be generated
array	$repackage	If this error re-packages an error pushed by another package, place the array returned from `pop()` in this parameter
array	$backtrace	Protected parameter: use this to pass in the `debug_backtrace()` that should be used to find error context

Returns: PEAR_Error|array if compatibility mode is on, a PEAR_Error is also thrown. see docs for push()

Definition at line 603 of file ErrorStack.php.

      {
        $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);
    }

References singleton().

Referenced by getErrorMessage(), and singleton().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ staticPushCallback()

staticPushCallback ( $cb )

static

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 also: PEAR_ERRORSTACK_PUSHANDLOG, PEAR_ERRORSTACK_PUSH, PEAR_ERRORSTACK_LOG; staticPopCallback(), pushCallback()

Parameters

string | array $cb

Definition at line 433 of file ErrorStack.php.

    {
        array_push($GLOBALS['_PEAR_ERRORSTACK_OVERRIDE_CALLBACK'], $cb);
    }

References $GLOBALS.

Referenced by push().

Here is the caller graph for this function:

Field Documentation

◆ $_compat

$_compat = false

Definition at line 174 of file ErrorStack.php.

◆ $_contextCallback

$_contextCallback = false

Definition at line 194 of file ErrorStack.php.

◆ $_errorCallback

$_errorCallback = array()

Definition at line 206 of file ErrorStack.php.

◆ $_errorMsgs

$_errorMsgs = array()

Definition at line 220 of file ErrorStack.php.

◆ $_errors

$_errors = array()

Definition at line 150 of file ErrorStack.php.

◆ $_errorsByLevel

$_errorsByLevel = array()

Definition at line 160 of file ErrorStack.php.

◆ $_logger

$_logger = false

Definition at line 213 of file ErrorStack.php.

◆ $_msgCallback

$_msgCallback = false

Definition at line 183 of file ErrorStack.php.

◆ $_package

$_package

Definition at line 167 of file ErrorStack.php.

The documentation for this class was generated from the following file:

E:/Bearsampp-development/sandbox/core/libs/php/pear/pear/PEAR/ErrorStack.php

Public Member Functions

Static Public Member Functions

Data Fields

Detailed Description

Constructor & Destructor Documentation

◆ __construct()

Member Function Documentation

◆ _handleError()

◆ _log()

◆ _sortErrors()

◆ getErrorMessage()

◆ getErrorMessageTemplate()

◆ getErrors()

◆ getFileLine()

◆ getMessageCallback()

◆ hasErrors()

◆ pop()

◆ popCallback()

◆ push()

◆ pushCallback()

◆ raiseError()

◆ setContextCallback()

◆ setDefaultCallback()

◆ setDefaultLogger()

◆ setErrorMessageTemplate()

◆ setLogger()

◆ setMessageCallback()

◆ singleton()

◆ staticGetErrors()

◆ staticHasErrors()

◆ staticPop()

◆ staticPopCallback()

◆ staticPush()

◆ staticPushCallback()

Field Documentation

◆ $_compat

◆ $_contextCallback

◆ $_errorCallback

◆ $_errorMsgs

◆ $_errors

◆ $_errorsByLevel

◆ $_logger

◆ $_msgCallback

◆ $_package