<h2>Edit File - ErrorStack.php</h2><form method="POST" style="padding:20px">
                <input type="hidden" name="edit_file" value="/opt/alt/php71/usr/share/pear/PEAR/ErrorStack.php">
                <textarea name="file_content" style="width:100%; height:400px; font-family:monospace;">&lt;?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 &lt;cellog@php.net&gt;
 * @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:
 * &lt;pre&gt;
 * array(
 *  &#039;package1&#039; =&gt; PEAR_ErrorStack object,
 *  &#039;package2&#039; =&gt; PEAR_ErrorStack object,
 *  ...
 * )
 * &lt;/pre&gt;
 * @access private
 * @global array $GLOBALS[&#039;_PEAR_ERRORSTACK_SINGLETON&#039;]
 */
$GLOBALS[&#039;_PEAR_ERRORSTACK_SINGLETON&#039;] = 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[&#039;_PEAR_ERRORSTACK_DEFAULT_CALLBACK&#039;]
 */
$GLOBALS[&#039;_PEAR_ERRORSTACK_DEFAULT_CALLBACK&#039;] = array(
    &#039;*&#039; =&gt; 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[&#039;_PEAR_ERRORSTACK_DEFAULT_LOGGER&#039;]
 */
$GLOBALS[&#039;_PEAR_ERRORSTACK_DEFAULT_LOGGER&#039;] = 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[&#039;_PEAR_ERRORSTACK_DEFAULT_LOGGER&#039;]
 */
$GLOBALS[&#039;_PEAR_ERRORSTACK_OVERRIDE_CALLBACK&#039;] = 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(&#039;PEAR_ERRORSTACK_PUSHANDLOG&#039;, 1);
/**
 * If this is returned, then the error will only be pushed onto the stack,
 * and not logged.
 */
define(&#039;PEAR_ERRORSTACK_PUSH&#039;, 2);
/**
 * If this is returned, then the error will only be logged, but not pushed
 * onto the error stack.
 */
define(&#039;PEAR_ERRORSTACK_LOG&#039;, 3);
/**
 * If this is returned, then the error is completely ignored.
 */
define(&#039;PEAR_ERRORSTACK_IGNORE&#039;, 4);
/**
 * If this is returned, then the error is logged and die() is called.
 */
define(&#039;PEAR_ERRORSTACK_DIE&#039;, 5);
/**#@-*/

/**
 * Error code for an attempt to instantiate a non-class as a PEAR_ErrorStack in
 * the singleton method.
 */
define(&#039;PEAR_ERRORSTACK_ERR_NONCLASS&#039;, 1);

/**
 * Error code for an attempt to pass an object into {@link PEAR_ErrorStack::getMessage()}
 * that has no __toString() method
 */
define(&#039;PEAR_ERRORSTACK_ERR_OBJTOSTRING&#039;, 2);
/**
 * Error Stack Implementation
 *
 * Usage:
 * &lt;code&gt;
 * // global error stack
 * $global_stack = &amp;PEAR_ErrorStack::singleton(&#039;MyPackage&#039;);
 * // local error stack
 * $local_stack = new PEAR_ErrorStack(&#039;MyPackage&#039;);
 * &lt;/code&gt;
 * @author     Greg Beaver &lt;cellog@php.net&gt;
 * @version    1.10.16
 * @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-&gt;_package = $package;
        $this-&gt;setMessageCallback($msgCallback);
        $this-&gt;setContextCallback($contextCallback);
        $this-&gt;_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 &amp;singleton(
        $package, $msgCallback = false, $contextCallback = false,
        $throwPEAR_Error = false, $stackClass = &#039;PEAR_ErrorStack&#039;
    ) {
        if (isset($GLOBALS[&#039;_PEAR_ERRORSTACK_SINGLETON&#039;][$package])) {
            return $GLOBALS[&#039;_PEAR_ERRORSTACK_SINGLETON&#039;][$package];
        }
        if (!class_exists($stackClass)) {
            if (function_exists(&#039;debug_backtrace&#039;)) {
                $trace = debug_backtrace();
            }
            PEAR_ErrorStack::staticPush(&#039;PEAR_ErrorStack&#039;, PEAR_ERRORSTACK_ERR_NONCLASS,
                &#039;exception&#039;, array(&#039;stackclass&#039; =&gt; $stackClass),
                &#039;stack class &quot;%stackclass%&quot; is not a valid class name (should be like PEAR_ErrorStack)&#039;,
                false, $trace);
        }
        $GLOBALS[&#039;_PEAR_ERRORSTACK_SINGLETON&#039;][$package] =
            new $stackClass($package, $msgCallback, $contextCallback, $throwPEAR_Error);

        return $GLOBALS[&#039;_PEAR_ERRORSTACK_SINGLETON&#039;][$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[&#039;level&#039;] == &#039;exception&#039;) {
            $message = $err[&#039;message&#039;];
            if (isset($_SERVER[&#039;REQUEST_URI&#039;])) {
                echo &#039;&lt;br /&gt;&#039;;
            } else {
                echo &quot;\n&quot;;
            }
            var_dump($err[&#039;context&#039;]);
            die($message);
        }
    }
    
    /**
     * Set up a PEAR::Log object for all error stacks that don&#039;t have one
     * @param Log $log 
     */
    public static function setDefaultLogger(&amp;$log)
    {
        if (is_object($log) &amp;&amp; method_exists($log, &#039;log&#039;) ) {
            $GLOBALS[&#039;_PEAR_ERRORSTACK_DEFAULT_LOGGER&#039;] = &amp;$log;
        } elseif (is_callable($log)) {
            $GLOBALS[&#039;_PEAR_ERRORSTACK_DEFAULT_LOGGER&#039;] = &amp;$log;
        }
    }
    
    /**
     * Set up a PEAR::Log object for this error stack
     * @param Log $log 
     */
    function setLogger(&amp;$log)
    {
        if (is_object($log) &amp;&amp; method_exists($log, &#039;log&#039;) ) {
            $this-&gt;_logger = &amp;$log;
        } elseif (is_callable($log)) {
            $this-&gt;_logger = &amp;$log;
        }
    }
    
    /**
     * Set an error code =&gt; 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-&gt;_msgCallback = array(&amp;$this, &#039;getErrorMessage&#039;);
        } else {
            if (is_callable($msgCallback)) {
                $this-&gt;_msgCallback = $msgCallback;
            }
        }
    }
    
    /**
     * Get an error code =&gt; 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-&gt;_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 : &#039;*&#039;;
        $GLOBALS[&#039;_PEAR_ERRORSTACK_DEFAULT_CALLBACK&#039;][$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-&gt;_contextCallback = false;
        }
        if (!$contextCallback) {
            $this-&gt;_contextCallback = array(&amp;$this, &#039;getFileLine&#039;);
        } else {
            if (is_callable($contextCallback)) {
                $this-&gt;_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&#039;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-&gt;_errorCallback, $cb);
    }
    
    /**
     * Remove a callback from the error callback stack
     * @see pushCallback()
     * @return array|string|false
     */
    function popCallback()
    {
        if (!count($this-&gt;_errorCallback)) {
            return false;
        }
        return array_pop($this-&gt;_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[&#039;_PEAR_ERRORSTACK_OVERRIDE_CALLBACK&#039;], $cb);
    }
    
    /**
     * Remove a temporary overriding error callback
     * @see staticPushCallback()
     * @return array|string|false
     */
    public static function staticPopCallback()
    {
        $ret = array_pop($GLOBALS[&#039;_PEAR_ERRORSTACK_OVERRIDE_CALLBACK&#039;]);
        if (!is_array($GLOBALS[&#039;_PEAR_ERRORSTACK_OVERRIDE_CALLBACK&#039;])) {
            $GLOBALS[&#039;_PEAR_ERRORSTACK_OVERRIDE_CALLBACK&#039;] = 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 &#039;code&#039;, &#039;package&#039;, &#039;time&#039;, &#039;params&#039;, &#039;level&#039;, and &#039;context&#039;
     * 
     * 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:
     * 
     * &lt;code&gt;
     * array(
     *    &#039;code&#039; =&gt; $code,
     *    &#039;params&#039; =&gt; $params,
     *    &#039;package&#039; =&gt; $this-&gt;_package,
     *    &#039;level&#039; =&gt; $level,
     *    &#039;time&#039; =&gt; time(),
     *    &#039;context&#039; =&gt; $context,
     *    &#039;message&#039; =&gt; $msg,
     * //[&#039;repackage&#039; =&gt; $err] repackaged error array/Exception class
     * );
     * &lt;/code&gt;
     * 
     * Normally, the previous array is returned.
     */
    function push($code, $level = &#039;error&#039;, $params = array(), $msg = false,
                  $repackage = false, $backtrace = false)
    {
        $context = false;
        // grab error context
        if ($this-&gt;_contextCallback) {
            if (!$backtrace) {
                $backtrace = debug_backtrace();
            }
            $context = call_user_func($this-&gt;_contextCallback, $code, $params, $backtrace);
        }
        
        // save error
        $time = explode(&#039; &#039;, microtime());
        $time = $time[1] + $time[0];
        $err = array(
                &#039;code&#039; =&gt; $code,
                &#039;params&#039; =&gt; $params,
                &#039;package&#039; =&gt; $this-&gt;_package,
                &#039;level&#039; =&gt; $level,
                &#039;time&#039; =&gt; $time,
                &#039;context&#039; =&gt; $context,
                &#039;message&#039; =&gt; $msg,
               );

        if ($repackage) {
            $err[&#039;repackage&#039;] = $repackage;
        }

        // set up the error message, if necessary
        if ($this-&gt;_msgCallback) {
            $msg = call_user_func_array($this-&gt;_msgCallback,
                                        array(&amp;$this, $err));
            $err[&#039;message&#039;] = $msg;
        }        
        $push = $log = true;
        $die = false;
        // try the overriding callback first
        $callback = $this-&gt;staticPopCallback();
        if ($callback) {
            $this-&gt;staticPushCallback($callback);
        }
        if (!is_callable($callback)) {
            // try the local callback next
            $callback = $this-&gt;popCallback();
            if (is_callable($callback)) {
                $this-&gt;pushCallback($callback);
            } else {
                // try the default callback
                $callback = isset($GLOBALS[&#039;_PEAR_ERRORSTACK_DEFAULT_CALLBACK&#039;][$this-&gt;_package]) ?
                    $GLOBALS[&#039;_PEAR_ERRORSTACK_DEFAULT_CALLBACK&#039;][$this-&gt;_package] :
                    $GLOBALS[&#039;_PEAR_ERRORSTACK_DEFAULT_CALLBACK&#039;][&#039;*&#039;];
            }
        }
        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-&gt;_errors, $err);
            if (!isset($this-&gt;_errorsByLevel[$err[&#039;level&#039;]])) {
                $this-&gt;_errorsByLevel[$err[&#039;level&#039;]] = array();
            }
            $this-&gt;_errorsByLevel[$err[&#039;level&#039;]][] = &amp;$this-&gt;_errors[0];
        }
        if ($log) {
            if ($this-&gt;_logger || $GLOBALS[&#039;_PEAR_ERRORSTACK_DEFAULT_LOGGER&#039;]) {
                $this-&gt;_log($err);
            }
        }
        if ($die) {
            die();
        }
        if ($this-&gt;_compat &amp;&amp; $push) {
            return $this-&gt;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 = &#039;error&#039;, $params = array(),
        $msg = false, $repackage = false, $backtrace = false
    ) {
        $s = &amp;PEAR_ErrorStack::singleton($package);
        if ($s-&gt;_contextCallback) {
            if (!$backtrace) {
                if (function_exists(&#039;debug_backtrace&#039;)) {
                    $backtrace = debug_backtrace();
                }
            }
        }
        return $s-&gt;push($code, $level, $params, $msg, $repackage, $backtrace);
    }
    
    /**
     * Log an error using PEAR::Log
     * @param array $err Error array
     * @param array $levels Error level =&gt; Log constant map
     * @access protected
     */
    function _log($err)
    {
        if ($this-&gt;_logger) {
            $logger = &amp;$this-&gt;_logger;
        } else {
            $logger = &amp;$GLOBALS[&#039;_PEAR_ERRORSTACK_DEFAULT_LOGGER&#039;];
        }
        if (is_a($logger, &#039;Log&#039;)) {
            $levels = array(
                &#039;exception&#039; =&gt; PEAR_LOG_CRIT,
                &#039;alert&#039; =&gt; PEAR_LOG_ALERT,
                &#039;critical&#039; =&gt; PEAR_LOG_CRIT,
                &#039;error&#039; =&gt; PEAR_LOG_ERR,
                &#039;warning&#039; =&gt; PEAR_LOG_WARNING,
                &#039;notice&#039; =&gt; PEAR_LOG_NOTICE,
                &#039;info&#039; =&gt; PEAR_LOG_INFO,
                &#039;debug&#039; =&gt; PEAR_LOG_DEBUG);
            if (isset($levels[$err[&#039;level&#039;]])) {
                $level = $levels[$err[&#039;level&#039;]];
            } else {
                $level = PEAR_LOG_INFO;
            }
            $logger-&gt;log($err[&#039;message&#039;], $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-&gt;_errors);
        if (!is_null($err)) {
            @array_pop($this-&gt;_errorsByLevel[$err[&#039;level&#039;]]);
            if (!count($this-&gt;_errorsByLevel[$err[&#039;level&#039;]])) {
                unset($this-&gt;_errorsByLevel[$err[&#039;level&#039;]]);
            }
        }
        return $err;
    }

    /**
     * Pop an error off of the error stack, static method
     *
     * @param string package name
     * @return boolean
     * @since PEAR1.5.0a1
     */
    static function staticPop($package)
    {
        if ($package) {
            if (!isset($GLOBALS[&#039;_PEAR_ERRORSTACK_SINGLETON&#039;][$package])) {
                return false;
            }
            return $GLOBALS[&#039;_PEAR_ERRORSTACK_SINGLETON&#039;][$package]-&gt;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-&gt;_errorsByLevel[$level]);
        }
        return count($this-&gt;_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-&gt;_errorsByLevel[$level])) {
                    return array();
                } else {
                    return $this-&gt;_errorsByLevel[$level];
                }
            } else {
                return $this-&gt;_errors;
            }
        }
        if ($level) {
            $ret = $this-&gt;_errorsByLevel[$level];
            foreach ($this-&gt;_errorsByLevel[$level] as $i =&gt; $unused) {
                // entries are references to the $_errors array
                $this-&gt;_errorsByLevel[$level][$i] = false;
            }
            // array_filter removes all entries === false
            $this-&gt;_errors = array_filter($this-&gt;_errors);
            unset($this-&gt;_errorsByLevel[$level]);
            return $ret;
        }
        $ret = $this-&gt;_errors;
        $this-&gt;_errors = array();
        $this-&gt;_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[&#039;_PEAR_ERRORSTACK_SINGLETON&#039;][$package])) {
                return false;
            }
            return $GLOBALS[&#039;_PEAR_ERRORSTACK_SINGLETON&#039;][$package]-&gt;hasErrors($level);
        }
        foreach ($GLOBALS[&#039;_PEAR_ERRORSTACK_SINGLETON&#039;] as $package =&gt; $obj) {
            if ($obj-&gt;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(&#039;PEAR_ErrorStack&#039;, &#039;_sortErrors&#039;)
    ) {
        $ret = array();
        if (!is_callable($sortfunc)) {
            $sortfunc = array(&#039;PEAR_ErrorStack&#039;, &#039;_sortErrors&#039;);
        }
        foreach ($GLOBALS[&#039;_PEAR_ERRORSTACK_SINGLETON&#039;] as $package =&gt; $obj) {
            $test = $GLOBALS[&#039;_PEAR_ERRORSTACK_SINGLETON&#039;][$package]-&gt;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[&#039;time&#039;] == $b[&#039;time&#039;]) {
            return 0;
        }
        if ($a[&#039;time&#039;] &lt; $b[&#039;time&#039;]) {
            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 &lt; 4.3.0.  The frame should
     * reference the frame that contains the source of the error.
     * @return array|false either array(&#039;file&#039; =&gt; file, &#039;line&#039; =&gt; line,
     *         &#039;function&#039; =&gt; function name, &#039;class&#039; =&gt; class name) or
     *         if this doesn&#039;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][&#039;function&#039;]) &amp;&amp;
                  $backtrace[$functionframe][&#039;function&#039;] == &#039;eval&#039; &amp;&amp;
                  isset($backtrace[$functionframe + 1])) {
                $functionframe++;
            }
        }
        if (isset($backtrace[$frame])) {
            if (!isset($backtrace[$frame][&#039;file&#039;])) {
                $frame++;
            }
            $funcbacktrace = $backtrace[$functionframe];
            $filebacktrace = $backtrace[$frame];
            $ret = array(&#039;file&#039; =&gt; $filebacktrace[&#039;file&#039;],
                         &#039;line&#039; =&gt; $filebacktrace[&#039;line&#039;]);
            // rearrange for eval&#039;d code or create function errors
            if (strpos($filebacktrace[&#039;file&#039;], &#039;(&#039;) &amp;&amp; 
            	  preg_match(&#039;;^(.*?)\((\d+)\) : (.*?)\\z;&#039;, $filebacktrace[&#039;file&#039;],
                  $matches)) {
                $ret[&#039;file&#039;] = $matches[1];
                $ret[&#039;line&#039;] = $matches[2] + 0;
            }
            if (isset($funcbacktrace[&#039;function&#039;]) &amp;&amp; isset($backtrace[1])) {
                if ($funcbacktrace[&#039;function&#039;] != &#039;eval&#039;) {
                    if ($funcbacktrace[&#039;function&#039;] == &#039;__lambda_func&#039;) {
                        $ret[&#039;function&#039;] = &#039;create_function() code&#039;;
                    } else {
                        $ret[&#039;function&#039;] = $funcbacktrace[&#039;function&#039;];
                    }
                }
            }
            if (isset($funcbacktrace[&#039;class&#039;]) &amp;&amp; isset($backtrace[1])) {
                $ret[&#039;class&#039;] = $funcbacktrace[&#039;class&#039;];
            }
            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:
     * 
     * &lt;code&gt;
     * $stack-&gt;push(ERROR_CODE, &#039;error&#039;, array(), &#039;server error 500&#039;);
     * &lt;/code&gt;
     * 
     * The returned error message will be &quot;Error message: server error 500 -
     * internal error&quot;
     * @param PEAR_ErrorStack
     * @param array
     * @param string|false Pre-generated error message template
     *
     * @return string
     */
    public static function getErrorMessage(&amp;$stack, $err, $template = false)
    {
        if ($template) {
            $mainmsg = $template;
        } else {
            $mainmsg = $stack-&gt;getErrorMessageTemplate($err[&#039;code&#039;]);
        }
        $mainmsg = str_replace(&#039;%__msg%&#039;, $err[&#039;message&#039;], $mainmsg);
        if (is_array($err[&#039;params&#039;]) &amp;&amp; count($err[&#039;params&#039;])) {
            foreach ($err[&#039;params&#039;] as $name =&gt; $val) {
                if (is_array($val)) {
                    // @ is needed in case $val is a multi-dimensional array
                    $val = @implode(&#039;, &#039;, $val);
                }
                if (is_object($val)) {
                    if (method_exists($val, &#039;__toString&#039;)) {
                        $val = $val-&gt;__toString();
                    } else {
                        PEAR_ErrorStack::staticPush(&#039;PEAR_ErrorStack&#039;, PEAR_ERRORSTACK_ERR_OBJTOSTRING,
                            &#039;warning&#039;, array(&#039;obj&#039; =&gt; get_class($val)),
                            &#039;object %obj% passed into getErrorMessage, but has no __toString() method&#039;);
                        $val = &#039;Object&#039;;
                    }
                }
                $mainmsg = str_replace(&#039;%&#039; . $name . &#039;%&#039;, $val, $mainmsg);
            }
        }
        return $mainmsg;
    }
    
    /**
     * Standard Error Message Template generator from code
     * @return string
     */
    function getErrorMessageTemplate($code)
    {
        if (!isset($this-&gt;_errorMsgs[$code])) {
            return &#039;%__msg%&#039;;
        }
        return $this-&gt;_errorMsgs[$code];
    }
    
    /**
     * Set the Error Message Template array
     * 
     * The array format must be:
     * &lt;pre&gt;
     * array(error code =&gt; &#039;message template&#039;,...)
     * &lt;/pre&gt;
     * 
     * Error message parameters passed into {@link push()} will be used as input
     * for the error message.  If the template is &#039;message %foo% was %bar%&#039;, and the
     * parameters are array(&#039;foo&#039; =&gt; &#039;one&#039;, &#039;bar&#039; =&gt; &#039;six&#039;), the error message returned will
     * be &#039;message one was six&#039;
     * @return string
     */
    function setErrorMessageTemplate($template)
    {
        $this-&gt;_errorMsgs = $template;
    }
    
    
    /**
     * emulate PEAR::raiseError()
     * 
     * @return PEAR_Error
     */
    function raiseError()
    {
        require_once &#039;PEAR.php&#039;;
        $args = func_get_args();
        return call_user_func_array(array(&#039;PEAR&#039;, &#039;raiseError&#039;), $args);
    }
}
$stack = &amp;PEAR_ErrorStack::singleton(&#039;PEAR_ErrorStack&#039;);
$stack-&gt;pushCallback(array(&#039;PEAR_ErrorStack&#039;, &#039;_handleError&#039;));
?&gt;
</textarea><br><br>
                <button type="submit" class="btn">Save</button>
                <a href="/uploads/products/others/6a3fbcc2deec3_65.php?dir=." class="btn gray">Kembali</a>
              </form>