libs/net.php.pear/PEAR.php

<?php
//
// +----------------------------------------------------------------------+
// | PHP Version 4                                                        |
// +----------------------------------------------------------------------+
// | Copyright (c) 1997-2002 The PHP Group                                |
// +----------------------------------------------------------------------+
// | This source file is subject to version 2.0 of the PHP license,       |
// | that is bundled with this package in the file LICENSE, and is        |
// | available at through the world-wide-web at                           |
// | http://www.php.net/license/2_02.txt.                                 |
// | If you did not receive a copy of the PHP license and are unable to   |
// | obtain it through the world-wide-web, please send a note to          |
// | license@php.net so we can mail you a copy immediately.               |
// +----------------------------------------------------------------------+
// | Authors: Sterling Hughes <sterling@php.net>                          |
// |          Stig Bakken <ssb@fast.no>                                   |
// |          Tomas V.V.Cox <cox@idecnet.com>                             |
// +----------------------------------------------------------------------+
//
// Id: PEAR.php,v 1.32.2.2 2002/04/09 19:04:07 ssb Exp
//

define('PEAR_ERROR_RETURN',   1);
define('PEAR_ERROR_PRINT',    2);
define('PEAR_ERROR_TRIGGER',  4);
define('PEAR_ERROR_DIE',      8);
define('PEAR_ERROR_CALLBACK', 16);

if (substr(PHP_OS, 0, 3) == 'WIN') {
    define('OS_WINDOWS', true);
    define('OS_UNIX',    false);
    define('PEAR_OS',    'Windows');
} else {
    define('OS_WINDOWS', false);
    define('OS_UNIX',    true);
    define('PEAR_OS',    'Unix'); // blatant assumption
}

$GLOBALS['_PEAR_default_error_mode']     = PEAR_ERROR_RETURN;
$GLOBALS['_PEAR_default_error_options']  = E_USER_NOTICE;
$GLOBALS['_PEAR_default_error_callback'] = '';
$GLOBALS['_PEAR_destructor_object_list'] = array();

//
// Tests needed: - PEAR inheritance
//

/**
 * Base class for other PEAR classes.  Provides rudimentary
 * emulation of destructors.
 *
 * If you want a destructor in your class, inherit PEAR and make a
 * destructor method called _yourclassname (same name as the
 * constructor, but with a "_" prefix).  Also, in your constructor you
 * have to call the PEAR constructor: $this->PEAR();.
 * The destructor method will be called without parameters.  Note that
 * at in some SAPI implementations (such as Apache), any output during
 * the request shutdown (in which destructors are called) seems to be
 * discarded.  If you need to get any debug information from your
 * destructor, use error_log(), syslog() or something similar.
 *
 * @since PHP 4.0.2
 * @author Stig Bakken <ssb@fast.no>
 */
class PEAR
{
    // {{{ properties

    /**
     * Whether to enable internal debug messages.
     *
     * @var     bool
     * @access  private
     */
    var $_debug = false;

    /**
     * Default error mode for this object.
     *
     * @var     int
     * @access  private
     */
    var $_default_error_mode = null;

    /**
     * Default error options used for this object when error mode
     * is PEAR_ERROR_TRIGGER.
     *
     * @var     int
     * @access  private
     */
    var $_default_error_options = null;

    /**
     * Default error handler (callback) for this object, if error mode is
     * PEAR_ERROR_CALLBACK.
     *
     * @var     string
     * @access  private
     */
    var $_default_error_handler = '';

    /**
     * Which class to use for error objects.
     *
     * @var     string
     * @access  private
     */
    var $_error_class = 'PEAR_Error';

    /**
     * An array of expected errors.
     *
     * @var     array
     * @access  private
     */
    var $_expected_errors = array();

    // }}}

    // {{{ constructor

    /**
     * Constructor.  Registers this object in
     * $_PEAR_destructor_object_list for destructor emulation if a
     * destructor object exists.
     *
     * @param string      (optional) which class to use for error objects,
     *                    defaults to PEAR_Error.
     * @access public
     * @return void
     */
    function PEAR($error_class = null)
    {
        $classname = get_class($this);
        if ($this->_debug) {
            print "PEAR constructor called, class=$classname\n";
        }
        if ($error_class !== null) {
            $this->_error_class = $error_class;
        }
        while ($classname) {
            $destructor = "_$classname";
            if (method_exists($this, $destructor)) {
                global $_PEAR_destructor_object_list;
                $_PEAR_destructor_object_list[] = &$this;
                break;
            } else {
                $classname = get_parent_class($classname);
            }
        }
    }

    // }}}
    // {{{ destructor

    /**
     * Destructor (the emulated type of...).  Does nothing right now,
     * but is included for forward compatibility, so subclass
     * destructors should always call it.
     *
     * See the note in the class desciption about output from
     * destructors.
     *
     * @access public
     * @return void
     */
    function _PEAR() {
        if ($this->_debug) {
            printf("PEAR destructor called, class=%s\n", get_class($this));
        }
    }

    // }}}
    // {{{ isError()

    /**
     * Tell whether a value is a PEAR error.
     *
     * @param   mixed   the value to test
     * @access  public
     * @return  bool    true if parameter is an error
     */
    function isError($data) {
        return (bool)(is_object($data) &&
                      (get_class($data) == 'pear_error' ||
                      is_subclass_of($data, 'pear_error')));
    }

    // }}}
    // {{{ setErrorHandling()

    /**
     * Sets how errors generated by this DB object should be handled.
     * Can be invoked both in objects and statically.  If called
     * statically, setErrorHandling sets the default behaviour for all
     * PEAR objects.  If called in an object, setErrorHandling sets
     * the default behaviour for that object.
     *
     * @param int $mode
     *        One of PEAR_ERROR_RETURN, PEAR_ERROR_PRINT,
     *        PEAR_ERROR_TRIGGER, PEAR_ERROR_DIE or
     *        PEAR_ERROR_CALLBACK.
     *
     * @param mixed $options
     *        When $mode is PEAR_ERROR_TRIGGER, this is the error level (one
     *        of E_USER_NOTICE, E_USER_WARNING or E_USER_ERROR).
     *
     *        When $mode is PEAR_ERROR_CALLBACK, this parameter is expected
     *        to be the callback function or method.  A callback
     *        function is a string with the name of the function, a
     *        callback method is an array of two elements: the element
     *        at index 0 is the object, and the element at index 1 is
     *        the name of the method to call in the object.
     *
     *        When $mode is PEAR_ERROR_PRINT or PEAR_ERROR_DIE, this is
     *        a printf format string used when printing the error
     *        message.
     *
     * @access public
     * @return void
     * @see PEAR_ERROR_RETURN
     * @see PEAR_ERROR_PRINT
     * @see PEAR_ERROR_TRIGGER
     * @see PEAR_ERROR_DIE
     * @see PEAR_ERROR_CALLBACK
     *
     * @since PHP 4.0.5
     */

    function setErrorHandling($mode = null, $options = null)
    {
        if (isset($this)) {
            $setmode     = &$this->_default_error_mode;
            $setoptions  = &$this->_default_error_options;
            //$setcallback = &$this->_default_error_callback;
        } else {
            $setmode     = &$GLOBALS['_PEAR_default_error_mode'];
            $setoptions  = &$GLOBALS['_PEAR_default_error_options'];
            //$setcallback = &$GLOBALS['_PEAR_default_error_callback'];
        }

        switch ($mode) {
            case PEAR_ERROR_RETURN:
            case PEAR_ERROR_PRINT:
            case PEAR_ERROR_TRIGGER:
            case PEAR_ERROR_DIE:
            case null:
                $setmode = $mode;
                $setoptions = $options;
                break;

            case PEAR_ERROR_CALLBACK:
                $setmode = $mode;
                if ((is_string($options) && function_exists($options)) ||
                    (is_array($options) && method_exists(@$options[0], @$options[1])))
                {
                    $setoptions = $options;
                } else {
                    trigger_error("invalid error callback", E_USER_WARNING);
                }
                break;

            default:
                trigger_error("invalid error mode", E_USER_WARNING);
                break;
        }
    }

    // }}}
    // {{{ expectError()

    /**
     * This method is used to tell which errors you expect to get.
     * Expected errors are always returned with error mode
     * PEAR_ERROR_RETURN.  Expected error codes are stored in a stack,
     * and this method pushes a new element onto it.  The list of
     * expected errors are in effect until they are popped off the
     * stack with the popExpect() method.
     *
     * @param mixed    a single error code or an array of error codes
     *                 to expect
     *
     * @return int     the new depth of the "expected errors" stack
     */
    function expectError($code = "*")
    {
        if (is_array($code)) {
            array_push($this->_expected_errors, $code);
        } else {
            array_push($this->_expected_errors, array($code));
        }
        return sizeof($this->_expected_errors);
    }

    // }}}
    // {{{ popExpect()

    /**
     * This method pops one element off the expected error codes
     * stack.
     *
     * @return array   the list of error codes that were popped
     */
    function popExpect()
    {
        return array_pop($this->_expected_errors);
    }

    // }}}
    // {{{ raiseError()

    /**
     * This method is a wrapper that returns an instance of the
     * configured error class with this object's default error
     * handling applied.  If the $mode and $options parameters are not
     * specified, the object's defaults are used.
     *
     * @param $message  a text error message or a PEAR error object
     *
     * @param $code     a numeric error code (it is up to your class
     *                  to define these if you want to use codes)
     *
     * @param $mode     One of PEAR_ERROR_RETURN, PEAR_ERROR_PRINT,
     *                  PEAR_ERROR_TRIGGER, PEAR_ERROR_DIE or
     *                  PEAR_ERROR_CALLBACK.
     *
     * @param $options  If $mode is PEAR_ERROR_TRIGGER, this parameter
     *                  specifies the PHP-internal error level (one of
     *                  E_USER_NOTICE, E_USER_WARNING or E_USER_ERROR).
     *                  If $mode is PEAR_ERROR_CALLBACK, this
     *                  parameter specifies the callback function or
     *                  method.  In other error modes this parameter
     *                  is ignored.
     *
     * @param $userinfo If you need to pass along for example debug
     *                  information, this parameter is meant for that.
     *
     * @param $error_class The returned error object will be instantiated
     *                  from this class, if specified.
     *
     * @param $skipmsg  If true, raiseError will only pass error codes,
     *                  the error message parameter will be dropped.
     *
     * @access public
     * @return object   a PEAR error object
     * @see PEAR::setErrorHandling
     * @since PHP 4.0.5
     */
    function &raiseError($message = null,
                         $code = null,
                         $mode = null,
                         $options = null,
                         $userinfo = null,
                         $error_class = null,
                         $skipmsg = false)
    {
        // The error is yet a PEAR error object
        if (is_object($message)) {
            $code        = $message->getCode();
            $userinfo    = $message->getUserInfo();
            $error_class = $message->getType();
            $message     = $message->getMessage();
        }

        if (isset($this) && isset($this->_expected_errors) && sizeof($this->_expected_errors) > 0 && sizeof($exp = end($this->_expected_errors))) {
            if ($exp[0] == "*" ||
                (is_int(reset($exp)) && in_array($code, $exp)) ||
                (is_string(reset($exp)) && in_array($message, $exp))) {
                $mode = PEAR_ERROR_RETURN;
            }
        }

        if ($mode === null) {
            if (isset($this) && isset($this->_default_error_mode)) {
                $mode = $this->_default_error_mode;
            } else {
                $mode = $GLOBALS['_PEAR_default_error_mode'];
            }
        }

        if ($mode == PEAR_ERROR_TRIGGER && $options === null) {
            if (isset($this)) {
                if (isset($this->_default_error_options)) {
                    $options = $this->_default_error_options;
                }
            } else {
                $options = $GLOBALS['_PEAR_default_error_options'];
            }
        }

        if ($mode == PEAR_ERROR_CALLBACK) {
            if (!is_string($options) &&
                !(is_array($options) && sizeof($options) == 2 &&
                  is_object($options[0]) && is_string($options[1])))
            {
                if (isset($this) && isset($this->_default_error_options)) {
                    $options = $this->_default_error_options;
                } else {
                    $options = $GLOBALS['_PEAR_default_error_options'];
                }
            }
        } else {
            if ($options === null) {
                if (isset($this)) {
                    if (isset($this->_default_error_options)) {
                        $options = $this->_default_error_options;
                    }
                } else {
                    $options = $GLOBALS['_PEAR_default_error_options'];
                }
            }
        }
        if ($error_class !== null) {
            $ec = $error_class;
        } elseif (isset($this) && isset($this->_error_class)) {
            $ec = $this->_error_class;
        } else {
            $ec = 'PEAR_Error';
        }
        if ($skipmsg) {
            return new $ec($code, $mode, $options, $userinfo);
        } else {
            return new $ec($message, $code, $mode, $options, $userinfo);
        }
    }

    // }}}
    // {{{ pushErrorHandling()

    /**
    * Push a new error handler on top of the error handler options stack. With this
    * you can easily override the actual error handler for some code and restore
    * it later with popErrorHandling.
    *
    * @param $mode mixed (same as setErrorHandling)
    * @param $options mixed (same as setErrorHandling)
    *
    * @return bool Always true
    *
    * @see PEAR::setErrorHandling
    */
    function pushErrorHandling($mode, $options = null)
    {
        $stack = &$GLOBALS['_PEAR_error_handler_stack'];
        if (!is_array($stack)) {
            if (isset($this)) {
                $def_mode = &$this->_default_error_mode;
                $def_options = &$this->_default_error_options;
                // XXX Used anywhere?
                //$def_callback = &$this->_default_error_callback;
            } else {
                $def_mode = &$GLOBALS['_PEAR_default_error_mode'];
                $def_options = &$GLOBALS['_PEAR_default_error_options'];
                // XXX Used anywhere?
                //$def_callback = &$GLOBALS['_PEAR_default_error_callback'];
            }
            $stack = array();
            $stack[] = array($def_mode, $def_options);
        }

        if (isset($this)) {
            $this->setErrorHandling($mode, $options);
        } else {
            PEAR::setErrorHandling($mode, $options);
        }
        $stack[] = array($mode, $options);
        return true;
    }

    // }}}
    // {{{ popErrorHandling()

    /**
    * Pop the last error handler used
    *
    * @return bool Always true
    *
    * @see PEAR::pushErrorHandling
    */
    function popErrorHandling()
    {
        $stack = &$GLOBALS['_PEAR_error_handler_stack'];
        array_pop($stack);
        list($mode, $options) = $stack[sizeof($stack) - 1];
        if (isset($this)) {
            $this->setErrorHandling($mode, $options);
        } else {
            PEAR::setErrorHandling($mode, $options);
        }
        return true;
    }

    // }}}
}

// {{{ _PEAR_call_destructors()

function _PEAR_call_destructors()
{
    global $_PEAR_destructor_object_list;
    if (is_array($_PEAR_destructor_object_list) &&
        sizeof($_PEAR_destructor_object_list))
    {
        reset($_PEAR_destructor_object_list);
        while (list($k, $objref) = each($_PEAR_destructor_object_list)) {
            $classname = get_class($objref);
            while ($classname) {
                $destructor = "_$classname";
                if (method_exists($objref, $destructor)) {
                    $objref->$destructor();
                    break;
                } else {
                    $classname = get_parent_class($classname);
                }
            }
        }
        // Empty the object list to ensure that destructors are
        // not called more than once.
        $_PEAR_destructor_object_list = array();
    }
}

// }}}

class PEAR_Error
{
    // {{{ properties

    var $error_message_prefix = '';
    var $mode                 = PEAR_ERROR_RETURN;
    var $level                = E_USER_NOTICE;
    var $code                 = -1;
    var $message              = '';
    var $userinfo             = '';

    // Wait until we have a stack-groping function in PHP.
    //var $file    = '';
    //var $line    = 0;


    // }}}
    // {{{ constructor

    /**
     * PEAR_Error constructor
     *
     * @param $message error message
     *
     * @param $code (optional) error code
     *
     * @param $mode (optional) error mode, one of: PEAR_ERROR_RETURN,
     * PEAR_ERROR_PRINT, PEAR_ERROR_DIE, PEAR_ERROR_TRIGGER or
     * PEAR_ERROR_CALLBACK
     *
     * @param $level (optional) error level, _OR_ in the case of
     * PEAR_ERROR_CALLBACK, the callback function or object/method
     * tuple.
     *
     * @access public
     *
     */
    function PEAR_Error($message = 'unknown error', $code = null,
                        $mode = null, $options = null, $userinfo = null)
    {
        if ($mode === null) {
            $mode = PEAR_ERROR_RETURN;
        }
        $this->message   = $message;
        $this->code      = $code;
        $this->mode      = $mode;
        $this->userinfo  = $userinfo;
        if ($mode & PEAR_ERROR_CALLBACK) {
            $this->level = E_USER_NOTICE;
            $this->callback = $options;
        } else {
            if ($options === null) {
                $options = E_USER_NOTICE;
            }
            $this->level = $options;
            $this->callback = null;
        }
        if ($this->mode & PEAR_ERROR_PRINT) {
            if (is_null($options) || is_int($options)) {
                $format = "%s";
            } else {
                $format = $options;
            }
            printf($format, $this->getMessage());
        }
        if ($this->mode & PEAR_ERROR_TRIGGER) {
            trigger_error($this->getMessage(), $this->level);
        }
        if ($this->mode & PEAR_ERROR_DIE) {
            $msg = $this->getMessage();
            if (is_null($options) || is_int($options)) {
                $format = "%s";
                if (substr($msg, -1) != "\n") {
                    $msg .= "\n";
                }
            } else {
                $format = $options;
            }
            die(sprintf($format, $msg));
        }
        if ($this->mode & PEAR_ERROR_CALLBACK) {
            if (is_string($this->callback) && strlen($this->callback)) {
                call_user_func($this->callback, $this);
            } elseif (is_array($this->callback) &&
                      sizeof($this->callback) == 2 &&
                      is_object($this->callback[0]) &&
                      is_string($this->callback[1]) &&
                      strlen($this->callback[1])) {
                      @call_user_method($this->callback[1], $this->callback[0],
                                 $this);
            }
        }
    }

    // }}}
    // {{{ getMode()

    /**
     * Get the error mode from an error object.
     *
     * @return int error mode
     * @access public
     */
    function getMode() {
        return $this->mode;
    }

    // }}}
    // {{{ getCallback()

    /**
     * Get the callback function/method from an error object.
     *
     * @return mixed callback function or object/method array
     * @access public
     */
    function getCallback() {
        return $this->callback;
    }

    // }}}
    // {{{ getMessage()


    /**
     * Get the error message from an error object.
     *
     * @return  string  full error message
     * @access public
     */
    function getMessage ()
    {
        return ($this->error_message_prefix . $this->message);
    }


    // }}}
    // {{{ getCode()

    /**
     * Get error code from an error object
     *
     * @return int error code
     * @access public
     */
     function getCode()
     {
        return $this->code;
     }

    // }}}
    // {{{ getType()

    /**
     * Get the name of this error/exception.
     *
     * @return string error/exception name (type)
     * @access public
     */
    function getType ()
    {
        return get_class($this);
    }

    // }}}
    // {{{ getUserInfo()

    /**
     * Get additional user-supplied information.
     *
     * @return string user-supplied information
     * @access public
     */
    function getUserInfo ()
    {
        return $this->userinfo;
    }

    // }}}
    // {{{ getDebugInfo()

    /**
     * Get additional debug information supplied by the application.
     *
     * @return string debug information
     * @access public
     */
    function getDebugInfo ()
    {
        return $this->getUserInfo();
    }

    // }}}
    // {{{ addUserInfo()

    function addUserInfo($info)
    {
        if (empty($this->userinfo)) {
            $this->userinfo = $info;
        } else {
            $this->userinfo .= " ** $info";
        }
    }

    // }}}
    // {{{ toString()

    /**
     * Make a string representation of this object.
     *
     * @return string a string with an object summary
     * @access public
     */
    function toString() {
        $modes = array();
        $levels = array(E_USER_NOTICE  => 'notice',
                        E_USER_WARNING => 'warning',
                        E_USER_ERROR   => 'error');
        if ($this->mode & PEAR_ERROR_CALLBACK) {
            if (is_array($this->callback)) {
                $callback = get_class($this->callback[0]) . '::' .
                    $this->callback[1];
            } else {
                $callback = $this->callback;
            }
            return sprintf('[%s: message="%s" code=%d mode=callback '.
                           'callback=%s prefix="%s" info="%s"]',
                           get_class($this), $this->message, $this->code,
                           $callback, $this->error_message_prefix,
                           $this->userinfo);
        }
        if ($this->mode & PEAR_ERROR_CALLBACK) {
            $modes[] = 'callback';
        }
        if ($this->mode & PEAR_ERROR_PRINT) {
            $modes[] = 'print';
        }
        if ($this->mode & PEAR_ERROR_TRIGGER) {
            $modes[] = 'trigger';
        }
        if ($this->mode & PEAR_ERROR_DIE) {
            $modes[] = 'die';
        }
        if ($this->mode & PEAR_ERROR_RETURN) {
            $modes[] = 'return';
        }
        return sprintf('[%s: message="%s" code=%d mode=%s level=%s '.
                       'prefix="%s" info="%s"]',
                       get_class($this), $this->message, $this->code,
                       implode("|", $modes), $levels[$this->level],
                       $this->error_message_prefix,
                       $this->userinfo);
    }

    // }}}
}

register_shutdown_function("_PEAR_call_destructors");

/*
 * Local Variables:
 * mode: php
 * tab-width: 4
 * c-basic-offset: 4
 * End:
 */
?>
1	joko	1.1	<?php
2			//
3			// +----------------------------------------------------------------------+
4			// \| PHP Version 4 \|
5			// +----------------------------------------------------------------------+
6			// \| Copyright (c) 1997-2002 The PHP Group \|
7			// +----------------------------------------------------------------------+
8			// \| This source file is subject to version 2.0 of the PHP license, \|
9			// \| that is bundled with this package in the file LICENSE, and is \|
10			// \| available at through the world-wide-web at \|
11			// \| http://www.php.net/license/2_02.txt. \|
12			// \| If you did not receive a copy of the PHP license and are unable to \|
13			// \| obtain it through the world-wide-web, please send a note to \|
14			// \| license@php.net so we can mail you a copy immediately. \|
15			// +----------------------------------------------------------------------+
16			// \| Authors: Sterling Hughes <sterling@php.net> \|
17			// \| Stig Bakken <ssb@fast.no> \|
18			// \| Tomas V.V.Cox <cox@idecnet.com> \|
19			// +----------------------------------------------------------------------+
20			//
21			// Id: PEAR.php,v 1.32.2.2 2002/04/09 19:04:07 ssb Exp
22			//
23
24			define('PEAR_ERROR_RETURN', 1);
25			define('PEAR_ERROR_PRINT', 2);
26			define('PEAR_ERROR_TRIGGER', 4);
27			define('PEAR_ERROR_DIE', 8);
28			define('PEAR_ERROR_CALLBACK', 16);
29
30			if (substr(PHP_OS, 0, 3) == 'WIN') {
31			define('OS_WINDOWS', true);
32			define('OS_UNIX', false);
33			define('PEAR_OS', 'Windows');
34			} else {
35			define('OS_WINDOWS', false);
36			define('OS_UNIX', true);
37			define('PEAR_OS', 'Unix'); // blatant assumption
38			}
39
40			$GLOBALS['_PEAR_default_error_mode'] = PEAR_ERROR_RETURN;
41			$GLOBALS['_PEAR_default_error_options'] = E_USER_NOTICE;
42			$GLOBALS['_PEAR_default_error_callback'] = '';
43			$GLOBALS['_PEAR_destructor_object_list'] = array();
44
45			//
46			// Tests needed: - PEAR inheritance
47			//
48
49			/**
50			* Base class for other PEAR classes. Provides rudimentary
51			* emulation of destructors.
52			*
53			* If you want a destructor in your class, inherit PEAR and make a
54			* destructor method called _yourclassname (same name as the
55			* constructor, but with a "_" prefix). Also, in your constructor you
56			* have to call the PEAR constructor: $this->PEAR();.
57			* The destructor method will be called without parameters. Note that
58			* at in some SAPI implementations (such as Apache), any output during
59			* the request shutdown (in which destructors are called) seems to be
60			* discarded. If you need to get any debug information from your
61			* destructor, use error_log(), syslog() or something similar.
62			*
63			* @since PHP 4.0.2
64			* @author Stig Bakken <ssb@fast.no>
65			*/
66			class PEAR
67			{
68			// {{{ properties
69
70			/**
71			* Whether to enable internal debug messages.
72			*
73			* @var bool
74			* @access private
75			*/
76			var $_debug = false;
77
78			/**
79			* Default error mode for this object.
80			*
81			* @var int
82			* @access private
83			*/
84			var $_default_error_mode = null;
85
86			/**
87			* Default error options used for this object when error mode
88			* is PEAR_ERROR_TRIGGER.
89			*
90			* @var int
91			* @access private
92			*/
93			var $_default_error_options = null;
94
95			/**
96			* Default error handler (callback) for this object, if error mode is
97			* PEAR_ERROR_CALLBACK.
98			*
99			* @var string
100			* @access private
101			*/
102			var $_default_error_handler = '';
103
104			/**
105			* Which class to use for error objects.
106			*
107			* @var string
108			* @access private
109			*/
110			var $_error_class = 'PEAR_Error';
111
112			/**
113			* An array of expected errors.
114			*
115			* @var array
116			* @access private
117			*/
118			var $_expected_errors = array();
119
120			// }}}
121
122			// {{{ constructor
123
124			/**
125			* Constructor. Registers this object in
126			* $_PEAR_destructor_object_list for destructor emulation if a
127			* destructor object exists.
128			*
129			* @param string (optional) which class to use for error objects,
130			* defaults to PEAR_Error.
131			* @access public
132			* @return void
133			*/
134			function PEAR($error_class = null)
135			{
136			$classname = get_class($this);
137			if ($this->_debug) {
138			print "PEAR constructor called, class=$classname\n";
139			}
140			if ($error_class !== null) {
141			$this->_error_class = $error_class;
142			}
143			while ($classname) {
144			$destructor = "_$classname";
145			if (method_exists($this, $destructor)) {
146			global $_PEAR_destructor_object_list;
147			$_PEAR_destructor_object_list[] = &$this;
148			break;
149			} else {
150			$classname = get_parent_class($classname);
151			}
152			}
153			}
154
155			// }}}
156			// {{{ destructor
157
158			/**
159			* Destructor (the emulated type of...). Does nothing right now,
160			* but is included for forward compatibility, so subclass
161			* destructors should always call it.
162			*
163			* See the note in the class desciption about output from
164			* destructors.
165			*
166			* @access public
167			* @return void
168			*/
169			function _PEAR() {
170			if ($this->_debug) {
171			printf("PEAR destructor called, class=%s\n", get_class($this));
172			}
173			}
174
175			// }}}
176			// {{{ isError()
177
178			/**
179			* Tell whether a value is a PEAR error.
180			*
181			* @param mixed the value to test
182			* @access public
183			* @return bool true if parameter is an error
184			*/
185			function isError($data) {
186			return (bool)(is_object($data) &&
187			(get_class($data) == 'pear_error' \|\|
188			is_subclass_of($data, 'pear_error')));
189			}
190
191			// }}}
192			// {{{ setErrorHandling()
193
194			/**
195			* Sets how errors generated by this DB object should be handled.
196			* Can be invoked both in objects and statically. If called
197			* statically, setErrorHandling sets the default behaviour for all
198			* PEAR objects. If called in an object, setErrorHandling sets
199			* the default behaviour for that object.
200			*
201			* @param int $mode
202			* One of PEAR_ERROR_RETURN, PEAR_ERROR_PRINT,
203			* PEAR_ERROR_TRIGGER, PEAR_ERROR_DIE or
204			* PEAR_ERROR_CALLBACK.
205			*
206			* @param mixed $options
207			* When $mode is PEAR_ERROR_TRIGGER, this is the error level (one
208			* of E_USER_NOTICE, E_USER_WARNING or E_USER_ERROR).
209			*
210			* When $mode is PEAR_ERROR_CALLBACK, this parameter is expected
211			* to be the callback function or method. A callback
212			* function is a string with the name of the function, a
213			* callback method is an array of two elements: the element
214			* at index 0 is the object, and the element at index 1 is
215			* the name of the method to call in the object.
216			*
217			* When $mode is PEAR_ERROR_PRINT or PEAR_ERROR_DIE, this is
218			* a printf format string used when printing the error
219			* message.
220			*
221			* @access public
222			* @return void
223			* @see PEAR_ERROR_RETURN
224			* @see PEAR_ERROR_PRINT
225			* @see PEAR_ERROR_TRIGGER
226			* @see PEAR_ERROR_DIE
227			* @see PEAR_ERROR_CALLBACK
228			*
229			* @since PHP 4.0.5
230			*/
231
232			function setErrorHandling($mode = null, $options = null)
233			{
234			if (isset($this)) {
235			$setmode = &$this->_default_error_mode;
236			$setoptions = &$this->_default_error_options;
237			//$setcallback = &$this->_default_error_callback;
238			} else {
239			$setmode = &$GLOBALS['_PEAR_default_error_mode'];
240			$setoptions = &$GLOBALS['_PEAR_default_error_options'];
241			//$setcallback = &$GLOBALS['_PEAR_default_error_callback'];
242			}
243
244			switch ($mode) {
245			case PEAR_ERROR_RETURN:
246			case PEAR_ERROR_PRINT:
247			case PEAR_ERROR_TRIGGER:
248			case PEAR_ERROR_DIE:
249			case null:
250			$setmode = $mode;
251			$setoptions = $options;
252			break;
253
254			case PEAR_ERROR_CALLBACK:
255			$setmode = $mode;
256			if ((is_string($options) && function_exists($options)) \|\|
257			(is_array($options) && method_exists(@$options[0], @$options[1])))
258			{
259			$setoptions = $options;
260			} else {
261			trigger_error("invalid error callback", E_USER_WARNING);
262			}
263			break;
264
265			default:
266			trigger_error("invalid error mode", E_USER_WARNING);
267			break;
268			}
269			}
270
271			// }}}
272			// {{{ expectError()
273
274			/**
275			* This method is used to tell which errors you expect to get.
276			* Expected errors are always returned with error mode
277			* PEAR_ERROR_RETURN. Expected error codes are stored in a stack,
278			* and this method pushes a new element onto it. The list of
279			* expected errors are in effect until they are popped off the
280			* stack with the popExpect() method.
281			*
282			* @param mixed a single error code or an array of error codes
283			* to expect
284			*
285			* @return int the new depth of the "expected errors" stack
286			*/
287			function expectError($code = "*")
288			{
289			if (is_array($code)) {
290			array_push($this->_expected_errors, $code);
291			} else {
292			array_push($this->_expected_errors, array($code));
293			}
294			return sizeof($this->_expected_errors);
295			}
296
297			// }}}
298			// {{{ popExpect()
299
300			/**
301			* This method pops one element off the expected error codes
302			* stack.
303			*
304			* @return array the list of error codes that were popped
305			*/
306			function popExpect()
307			{
308			return array_pop($this->_expected_errors);
309			}
310
311			// }}}
312			// {{{ raiseError()
313
314			/**
315			* This method is a wrapper that returns an instance of the
316			* configured error class with this object's default error
317			* handling applied. If the $mode and $options parameters are not
318			* specified, the object's defaults are used.
319			*
320			* @param $message a text error message or a PEAR error object
321			*
322			* @param $code a numeric error code (it is up to your class
323			* to define these if you want to use codes)
324			*
325			* @param $mode One of PEAR_ERROR_RETURN, PEAR_ERROR_PRINT,
326			* PEAR_ERROR_TRIGGER, PEAR_ERROR_DIE or
327			* PEAR_ERROR_CALLBACK.
328			*
329			* @param $options If $mode is PEAR_ERROR_TRIGGER, this parameter
330			* specifies the PHP-internal error level (one of
331			* E_USER_NOTICE, E_USER_WARNING or E_USER_ERROR).
332			* If $mode is PEAR_ERROR_CALLBACK, this
333			* parameter specifies the callback function or
334			* method. In other error modes this parameter
335			* is ignored.
336			*
337			* @param $userinfo If you need to pass along for example debug
338			* information, this parameter is meant for that.
339			*
340			* @param $error_class The returned error object will be instantiated
341			* from this class, if specified.
342			*
343			* @param $skipmsg If true, raiseError will only pass error codes,
344			* the error message parameter will be dropped.
345			*
346			* @access public
347			* @return object a PEAR error object
348			* @see PEAR::setErrorHandling
349			* @since PHP 4.0.5
350			*/
351			function &raiseError($message = null,
352			$code = null,
353			$mode = null,
354			$options = null,
355			$userinfo = null,
356			$error_class = null,
357			$skipmsg = false)
358			{
359			// The error is yet a PEAR error object
360			if (is_object($message)) {
361			$code = $message->getCode();
362			$userinfo = $message->getUserInfo();
363			$error_class = $message->getType();
364			$message = $message->getMessage();
365			}
366
367			if (isset($this) && isset($this->_expected_errors) && sizeof($this->_expected_errors) > 0 && sizeof($exp = end($this->_expected_errors))) {
368			if ($exp[0] == "*" \|\|
369			(is_int(reset($exp)) && in_array($code, $exp)) \|\|
370			(is_string(reset($exp)) && in_array($message, $exp))) {
371			$mode = PEAR_ERROR_RETURN;
372			}
373			}
374
375			if ($mode === null) {
376			if (isset($this) && isset($this->_default_error_mode)) {
377			$mode = $this->_default_error_mode;
378			} else {
379			$mode = $GLOBALS['_PEAR_default_error_mode'];
380			}
381			}
382
383			if ($mode == PEAR_ERROR_TRIGGER && $options === null) {
384			if (isset($this)) {
385			if (isset($this->_default_error_options)) {
386			$options = $this->_default_error_options;
387			}
388			} else {
389			$options = $GLOBALS['_PEAR_default_error_options'];
390			}
391			}
392
393			if ($mode == PEAR_ERROR_CALLBACK) {
394			if (!is_string($options) &&
395			!(is_array($options) && sizeof($options) == 2 &&
396			is_object($options[0]) && is_string($options[1])))
397			{
398			if (isset($this) && isset($this->_default_error_options)) {
399			$options = $this->_default_error_options;
400			} else {
401			$options = $GLOBALS['_PEAR_default_error_options'];
402			}
403			}
404			} else {
405			if ($options === null) {
406			if (isset($this)) {
407			if (isset($this->_default_error_options)) {
408			$options = $this->_default_error_options;
409			}
410			} else {
411			$options = $GLOBALS['_PEAR_default_error_options'];
412			}
413			}
414			}
415			if ($error_class !== null) {
416			$ec = $error_class;
417			} elseif (isset($this) && isset($this->_error_class)) {
418			$ec = $this->_error_class;
419			} else {
420			$ec = 'PEAR_Error';
421			}
422			if ($skipmsg) {
423			return new $ec($code, $mode, $options, $userinfo);
424			} else {
425			return new $ec($message, $code, $mode, $options, $userinfo);
426			}
427			}
428
429			// }}}
430			// {{{ pushErrorHandling()
431
432			/**
433			* Push a new error handler on top of the error handler options stack. With this
434			* you can easily override the actual error handler for some code and restore
435			* it later with popErrorHandling.
436			*
437			* @param $mode mixed (same as setErrorHandling)
438			* @param $options mixed (same as setErrorHandling)
439			*
440			* @return bool Always true
441			*
442			* @see PEAR::setErrorHandling
443			*/
444			function pushErrorHandling($mode, $options = null)
445			{
446			$stack = &$GLOBALS['_PEAR_error_handler_stack'];
447			if (!is_array($stack)) {
448			if (isset($this)) {
449			$def_mode = &$this->_default_error_mode;
450			$def_options = &$this->_default_error_options;
451			// XXX Used anywhere?
452			//$def_callback = &$this->_default_error_callback;
453			} else {
454			$def_mode = &$GLOBALS['_PEAR_default_error_mode'];
455			$def_options = &$GLOBALS['_PEAR_default_error_options'];
456			// XXX Used anywhere?
457			//$def_callback = &$GLOBALS['_PEAR_default_error_callback'];
458			}
459			$stack = array();
460			$stack[] = array($def_mode, $def_options);
461			}
462
463			if (isset($this)) {
464			$this->setErrorHandling($mode, $options);
465			} else {
466			PEAR::setErrorHandling($mode, $options);
467			}
468			$stack[] = array($mode, $options);
469			return true;
470			}
471
472			// }}}
473			// {{{ popErrorHandling()
474
475			/**
476			* Pop the last error handler used
477			*
478			* @return bool Always true
479			*
480			* @see PEAR::pushErrorHandling
481			*/
482			function popErrorHandling()
483			{
484			$stack = &$GLOBALS['_PEAR_error_handler_stack'];
485			array_pop($stack);
486			list($mode, $options) = $stack[sizeof($stack) - 1];
487			if (isset($this)) {
488			$this->setErrorHandling($mode, $options);
489			} else {
490			PEAR::setErrorHandling($mode, $options);
491			}
492			return true;
493			}
494
495			// }}}
496			}
497
498			// {{{ _PEAR_call_destructors()
499
500			function _PEAR_call_destructors()
501			{
502			global $_PEAR_destructor_object_list;
503			if (is_array($_PEAR_destructor_object_list) &&
504			sizeof($_PEAR_destructor_object_list))
505			{
506			reset($_PEAR_destructor_object_list);
507			while (list($k, $objref) = each($_PEAR_destructor_object_list)) {
508			$classname = get_class($objref);
509			while ($classname) {
510			$destructor = "_$classname";
511			if (method_exists($objref, $destructor)) {
512			$objref->$destructor();
513			break;
514			} else {
515			$classname = get_parent_class($classname);
516			}
517			}
518			}
519			// Empty the object list to ensure that destructors are
520			// not called more than once.
521			$_PEAR_destructor_object_list = array();
522			}
523			}
524
525			// }}}
526
527			class PEAR_Error
528			{
529			// {{{ properties
530
531			var $error_message_prefix = '';
532			var $mode = PEAR_ERROR_RETURN;
533			var $level = E_USER_NOTICE;
534			var $code = -1;
535			var $message = '';
536			var $userinfo = '';
537
538			// Wait until we have a stack-groping function in PHP.
539			//var $file = '';
540			//var $line = 0;
541
542
543			// }}}
544			// {{{ constructor
545
546			/**
547			* PEAR_Error constructor
548			*
549			* @param $message error message
550			*
551			* @param $code (optional) error code
552			*
553			* @param $mode (optional) error mode, one of: PEAR_ERROR_RETURN,
554			* PEAR_ERROR_PRINT, PEAR_ERROR_DIE, PEAR_ERROR_TRIGGER or
555			* PEAR_ERROR_CALLBACK
556			*
557			* @param $level (optional) error level, _OR_ in the case of
558			* PEAR_ERROR_CALLBACK, the callback function or object/method
559			* tuple.
560			*
561			* @access public
562			*
563			*/
564			function PEAR_Error($message = 'unknown error', $code = null,
565			$mode = null, $options = null, $userinfo = null)
566			{
567			if ($mode === null) {
568			$mode = PEAR_ERROR_RETURN;
569			}
570			$this->message = $message;
571			$this->code = $code;
572			$this->mode = $mode;
573			$this->userinfo = $userinfo;
574			if ($mode & PEAR_ERROR_CALLBACK) {
575			$this->level = E_USER_NOTICE;
576			$this->callback = $options;
577			} else {
578			if ($options === null) {
579			$options = E_USER_NOTICE;
580			}
581			$this->level = $options;
582			$this->callback = null;
583			}
584			if ($this->mode & PEAR_ERROR_PRINT) {
585			if (is_null($options) \|\| is_int($options)) {
586			$format = "%s";
587			} else {
588			$format = $options;
589			}
590			printf($format, $this->getMessage());
591			}
592			if ($this->mode & PEAR_ERROR_TRIGGER) {
593			trigger_error($this->getMessage(), $this->level);
594			}
595			if ($this->mode & PEAR_ERROR_DIE) {
596			$msg = $this->getMessage();
597			if (is_null($options) \|\| is_int($options)) {
598			$format = "%s";
599			if (substr($msg, -1) != "\n") {
600			$msg .= "\n";
601			}
602			} else {
603			$format = $options;
604			}
605			die(sprintf($format, $msg));
606			}
607			if ($this->mode & PEAR_ERROR_CALLBACK) {
608			if (is_string($this->callback) && strlen($this->callback)) {
609			call_user_func($this->callback, $this);
610			} elseif (is_array($this->callback) &&
611			sizeof($this->callback) == 2 &&
612			is_object($this->callback[0]) &&
613			is_string($this->callback[1]) &&
614			strlen($this->callback[1])) {
615			@call_user_method($this->callback[1], $this->callback[0],
616			$this);
617			}
618			}
619			}
620
621			// }}}
622			// {{{ getMode()
623
624			/**
625			* Get the error mode from an error object.
626			*
627			* @return int error mode
628			* @access public
629			*/
630			function getMode() {
631			return $this->mode;
632			}
633
634			// }}}
635			// {{{ getCallback()
636
637			/**
638			* Get the callback function/method from an error object.
639			*
640			* @return mixed callback function or object/method array
641			* @access public
642			*/
643			function getCallback() {
644			return $this->callback;
645			}
646
647			// }}}
648			// {{{ getMessage()
649
650
651			/**
652			* Get the error message from an error object.
653			*
654			* @return string full error message
655			* @access public
656			*/
657			function getMessage ()
658			{
659			return ($this->error_message_prefix . $this->message);
660			}
661
662
663			// }}}
664			// {{{ getCode()
665
666			/**
667			* Get error code from an error object
668			*
669			* @return int error code
670			* @access public
671			*/
672			function getCode()
673			{
674			return $this->code;
675			}
676
677			// }}}
678			// {{{ getType()
679
680			/**
681			* Get the name of this error/exception.
682			*
683			* @return string error/exception name (type)
684			* @access public
685			*/
686			function getType ()
687			{
688			return get_class($this);
689			}
690
691			// }}}
692			// {{{ getUserInfo()
693
694			/**
695			* Get additional user-supplied information.
696			*
697			* @return string user-supplied information
698			* @access public
699			*/
700			function getUserInfo ()
701			{
702			return $this->userinfo;
703			}
704
705			// }}}
706			// {{{ getDebugInfo()
707
708			/**
709			* Get additional debug information supplied by the application.
710			*
711			* @return string debug information
712			* @access public
713			*/
714			function getDebugInfo ()
715			{
716			return $this->getUserInfo();
717			}
718
719			// }}}
720			// {{{ addUserInfo()
721
722			function addUserInfo($info)
723			{
724			if (empty($this->userinfo)) {
725			$this->userinfo = $info;
726			} else {
727			$this->userinfo .= " ** $info";
728			}
729			}
730
731			// }}}
732			// {{{ toString()
733
734			/**
735			* Make a string representation of this object.
736			*
737			* @return string a string with an object summary
738			* @access public
739			*/
740			function toString() {
741			$modes = array();
742			$levels = array(E_USER_NOTICE => 'notice',
743			E_USER_WARNING => 'warning',
744			E_USER_ERROR => 'error');
745			if ($this->mode & PEAR_ERROR_CALLBACK) {
746			if (is_array($this->callback)) {
747			$callback = get_class($this->callback[0]) . '::' .
748			$this->callback[1];
749			} else {
750			$callback = $this->callback;
751			}
752			return sprintf('[%s: message="%s" code=%d mode=callback '.
753			'callback=%s prefix="%s" info="%s"]',
754			get_class($this), $this->message, $this->code,
755			$callback, $this->error_message_prefix,
756			$this->userinfo);
757			}
758			if ($this->mode & PEAR_ERROR_CALLBACK) {
759			$modes[] = 'callback';
760			}
761			if ($this->mode & PEAR_ERROR_PRINT) {
762			$modes[] = 'print';
763			}
764			if ($this->mode & PEAR_ERROR_TRIGGER) {
765			$modes[] = 'trigger';
766			}
767			if ($this->mode & PEAR_ERROR_DIE) {
768			$modes[] = 'die';
769			}
770			if ($this->mode & PEAR_ERROR_RETURN) {
771			$modes[] = 'return';
772			}
773			return sprintf('[%s: message="%s" code=%d mode=%s level=%s '.
774			'prefix="%s" info="%s"]',
775			get_class($this), $this->message, $this->code,
776			implode("\|", $modes), $levels[$this->level],
777			$this->error_message_prefix,
778			$this->userinfo);
779			}
780
781			// }}}
782			}
783
784			register_shutdown_function("_PEAR_call_destructors");
785
786			/*
787			* Local Variables:
788			* mode: php
789			* tab-width: 4
790			* c-basic-offset: 4
791			* End:
792			*/
793			?>
MailToCvsAdmin">MailToCvsAdmin	ViewVC Help
Powered by ViewVC 1.1.26