source: trunk/www.guidonia.net/wp/wp-content/plugins/tubepress/classes/net/php/pear/PEAR.class.php@ 44

Last change on this file since 44 was 44, checked in by luciano, 14 years ago
File size: 34.3 KB
Line 
1<?php
2/**
3 * PEAR, the PHP Extension and Application Repository
4 *
5 * PEAR class and PEAR_Error class
6 *
7 * PHP versions 4 and 5
8 *
9 * LICENSE: This source file is subject to version 3.0 of the PHP license
10 * that is available through the world-wide-web at the following URI:
11 * http://www.php.net/license/3_0.txt. If you did not receive a copy of
12 * the PHP License and are unable to obtain it through the web, please
13 * send a note to license@php.net so we can mail you a copy immediately.
14 *
15 * @category pear
16 * @package PEAR
17 * @author Sterling Hughes <sterling@php.net>
18 * @author Stig Bakken <ssb@php.net>
19 * @author Tomas V.V.Cox <cox@idecnet.com>
20 * @author Greg Beaver <cellog@php.net>
21 * @copyright 1997-2008 The PHP Group
22 * @license http://www.php.net/license/3_0.txt PHP License 3.0
23 * @version CVS: $Id: PEAR.php,v 1.104 2008/01/03 20:26:34 cellog Exp $
24 * @link http://pear.php.net/package/PEAR
25 * @since File available since Release 0.1
26 */
27
28/**#@+
29 * ERROR constants
30 */
31define('PEAR_ERROR_RETURN', 1);
32define('PEAR_ERROR_PRINT', 2);
33define('PEAR_ERROR_TRIGGER', 4);
34define('PEAR_ERROR_DIE', 8);
35define('PEAR_ERROR_CALLBACK', 16);
36/**
37 * WARNING: obsolete
38 * @deprecated
39 */
40define('PEAR_ERROR_EXCEPTION', 32);
41/**#@-*/
42define('PEAR_ZE2', (function_exists('version_compare') &&
43 version_compare(zend_version(), "2-dev", "ge")));
44
45if (substr(PHP_OS, 0, 3) == 'WIN') {
46 define('OS_WINDOWS', true);
47 define('OS_UNIX', false);
48 define('PEAR_OS', 'Windows');
49} else {
50 define('OS_WINDOWS', false);
51 define('OS_UNIX', true);
52 define('PEAR_OS', 'Unix'); // blatant assumption
53}
54
55// instant backwards compatibility
56if (!defined('PATH_SEPARATOR')) {
57 if (OS_WINDOWS) {
58 define('PATH_SEPARATOR', ';');
59 } else {
60 define('PATH_SEPARATOR', ':');
61 }
62}
63
64$GLOBALS['_PEAR_default_error_mode'] = PEAR_ERROR_RETURN;
65$GLOBALS['_PEAR_default_error_options'] = E_USER_NOTICE;
66$GLOBALS['_PEAR_destructor_object_list'] = array();
67$GLOBALS['_PEAR_shutdown_funcs'] = array();
68$GLOBALS['_PEAR_error_handler_stack'] = array();
69
70@ini_set('track_errors', true);
71
72/**
73 * Base class for other PEAR classes. Provides rudimentary
74 * emulation of destructors.
75 *
76 * If you want a destructor in your class, inherit PEAR and make a
77 * destructor method called _yourclassname (same name as the
78 * constructor, but with a "_" prefix). Also, in your constructor you
79 * have to call the PEAR constructor: $this->PEAR();.
80 * The destructor method will be called without parameters. Note that
81 * at in some SAPI implementations (such as Apache), any output during
82 * the request shutdown (in which destructors are called) seems to be
83 * discarded. If you need to get any debug information from your
84 * destructor, use error_log(), syslog() or something similar.
85 *
86 * IMPORTANT! To use the emulated destructors you need to create the
87 * objects by reference: $obj =& new PEAR_child;
88 *
89 * @category pear
90 * @package PEAR
91 * @author Stig Bakken <ssb@php.net>
92 * @author Tomas V.V. Cox <cox@idecnet.com>
93 * @author Greg Beaver <cellog@php.net>
94 * @copyright 1997-2006 The PHP Group
95 * @license http://www.php.net/license/3_0.txt PHP License 3.0
96 * @version Release: 1.7.2
97 * @link http://pear.php.net/package/PEAR
98 * @see PEAR_Error
99 * @since Class available since PHP 4.0.2
100 * @link http://pear.php.net/manual/en/core.pear.php#core.pear.pear
101 */
102class net_php_pear_PEAR
103{
104 // {{{ properties
105
106 /**
107 * Whether to enable internal debug messages.
108 *
109 * @var bool
110 * @access private
111 */
112 var $_debug = false;
113
114 /**
115 * Default error mode for this object.
116 *
117 * @var int
118 * @access private
119 */
120 var $_default_error_mode = null;
121
122 /**
123 * Default error options used for this object when error mode
124 * is PEAR_ERROR_TRIGGER.
125 *
126 * @var int
127 * @access private
128 */
129 var $_default_error_options = null;
130
131 /**
132 * Default error handler (callback) for this object, if error mode is
133 * PEAR_ERROR_CALLBACK.
134 *
135 * @var string
136 * @access private
137 */
138 var $_default_error_handler = '';
139
140 /**
141 * Which class to use for error objects.
142 *
143 * @var string
144 * @access private
145 */
146 var $_error_class = 'PEAR_Error';
147
148 /**
149 * An array of expected errors.
150 *
151 * @var array
152 * @access private
153 */
154 var $_expected_errors = array();
155
156 // }}}
157
158 // {{{ constructor
159
160 /**
161 * Constructor. Registers this object in
162 * $_PEAR_destructor_object_list for destructor emulation if a
163 * destructor object exists.
164 *
165 * @param string $error_class (optional) which class to use for
166 * error objects, defaults to PEAR_Error.
167 * @access public
168 * @return void
169 */
170 function net_php_pear_PEAR($error_class = null)
171 {
172 $classname = strtolower(get_class($this));
173 if ($this->_debug) {
174 print "PEAR constructor called, class=$classname\n";
175 }
176 if ($error_class !== null) {
177 $this->_error_class = $error_class;
178 }
179 while ($classname && strcasecmp($classname, "pear")) {
180 $destructor = "_$classname";
181 if (method_exists($this, $destructor)) {
182 global $_PEAR_destructor_object_list;
183 $_PEAR_destructor_object_list[] = &$this;
184 if (!isset($GLOBALS['_PEAR_SHUTDOWN_REGISTERED'])) {
185 register_shutdown_function("_PEAR_call_destructors");
186 $GLOBALS['_PEAR_SHUTDOWN_REGISTERED'] = true;
187 }
188 break;
189 } else {
190 $classname = get_parent_class($classname);
191 }
192 }
193 }
194
195 // }}}
196 // {{{ destructor
197
198 /**
199 * Destructor (the emulated type of...). Does nothing right now,
200 * but is included for forward compatibility, so subclass
201 * destructors should always call it.
202 *
203 * See the note in the class desciption about output from
204 * destructors.
205 *
206 * @access public
207 * @return void
208 */
209 function _PEAR() {
210 if ($this->_debug) {
211 printf("PEAR destructor called, class=%s\n", strtolower(get_class($this)));
212 }
213 }
214
215 // }}}
216 // {{{ getStaticProperty()
217
218 /**
219 * If you have a class that's mostly/entirely static, and you need static
220 * properties, you can use this method to simulate them. Eg. in your method(s)
221 * do this: $myVar = &PEAR::getStaticProperty('myclass', 'myVar');
222 * You MUST use a reference, or they will not persist!
223 *
224 * @access public
225 * @param string $class The calling classname, to prevent clashes
226 * @param string $var The variable to retrieve.
227 * @return mixed A reference to the variable. If not set it will be
228 * auto initialised to NULL.
229 */
230 function &getStaticProperty($class, $var)
231 {
232 static $properties;
233 if (!isset($properties[$class])) {
234 $properties[$class] = array();
235 }
236 if (!array_key_exists($var, $properties[$class])) {
237 $properties[$class][$var] = null;
238 }
239 return $properties[$class][$var];
240 }
241
242 // }}}
243 // {{{ registerShutdownFunc()
244
245 /**
246 * Use this function to register a shutdown method for static
247 * classes.
248 *
249 * @access public
250 * @param mixed $func The function name (or array of class/method) to call
251 * @param mixed $args The arguments to pass to the function
252 * @return void
253 */
254 function registerShutdownFunc($func, $args = array())
255 {
256 // if we are called statically, there is a potential
257 // that no shutdown func is registered. Bug #6445
258 if (!isset($GLOBALS['_PEAR_SHUTDOWN_REGISTERED'])) {
259 register_shutdown_function("_PEAR_call_destructors");
260 $GLOBALS['_PEAR_SHUTDOWN_REGISTERED'] = true;
261 }
262 $GLOBALS['_PEAR_shutdown_funcs'][] = array($func, $args);
263 }
264
265 // }}}
266 // {{{ isError()
267
268 /**
269 * Tell whether a value is a PEAR error.
270 *
271 * @param mixed $data the value to test
272 * @param int $code if $data is an error object, return true
273 * only if $code is a string and
274 * $obj->getMessage() == $code or
275 * $code is an integer and $obj->getCode() == $code
276 * @access public
277 * @return bool true if parameter is an error
278 */
279 function isError($data, $code = null)
280 {
281 if (is_a($data, 'PEAR_Error')) {
282 if (is_null($code)) {
283 return true;
284 } elseif (is_string($code)) {
285 return $data->getMessage() == $code;
286 } else {
287 return $data->getCode() == $code;
288 }
289 }
290 return false;
291 }
292
293 // }}}
294 // {{{ setErrorHandling()
295
296 /**
297 * Sets how errors generated by this object should be handled.
298 * Can be invoked both in objects and statically. If called
299 * statically, setErrorHandling sets the default behaviour for all
300 * PEAR objects. If called in an object, setErrorHandling sets
301 * the default behaviour for that object.
302 *
303 * @param int $mode
304 * One of PEAR_ERROR_RETURN, PEAR_ERROR_PRINT,
305 * PEAR_ERROR_TRIGGER, PEAR_ERROR_DIE,
306 * PEAR_ERROR_CALLBACK or PEAR_ERROR_EXCEPTION.
307 *
308 * @param mixed $options
309 * When $mode is PEAR_ERROR_TRIGGER, this is the error level (one
310 * of E_USER_NOTICE, E_USER_WARNING or E_USER_ERROR).
311 *
312 * When $mode is PEAR_ERROR_CALLBACK, this parameter is expected
313 * to be the callback function or method. A callback
314 * function is a string with the name of the function, a
315 * callback method is an array of two elements: the element
316 * at index 0 is the object, and the element at index 1 is
317 * the name of the method to call in the object.
318 *
319 * When $mode is PEAR_ERROR_PRINT or PEAR_ERROR_DIE, this is
320 * a printf format string used when printing the error
321 * message.
322 *
323 * @access public
324 * @return void
325 * @see PEAR_ERROR_RETURN
326 * @see PEAR_ERROR_PRINT
327 * @see PEAR_ERROR_TRIGGER
328 * @see PEAR_ERROR_DIE
329 * @see PEAR_ERROR_CALLBACK
330 * @see PEAR_ERROR_EXCEPTION
331 *
332 * @since PHP 4.0.5
333 */
334
335 function setErrorHandling($mode = null, $options = null)
336 {
337 if (isset($this) && is_a($this, 'PEAR')) {
338 $setmode = &$this->_default_error_mode;
339 $setoptions = &$this->_default_error_options;
340 } else {
341 $setmode = &$GLOBALS['_PEAR_default_error_mode'];
342 $setoptions = &$GLOBALS['_PEAR_default_error_options'];
343 }
344
345 switch ($mode) {
346 case PEAR_ERROR_EXCEPTION:
347 case PEAR_ERROR_RETURN:
348 case PEAR_ERROR_PRINT:
349 case PEAR_ERROR_TRIGGER:
350 case PEAR_ERROR_DIE:
351 case null:
352 $setmode = $mode;
353 $setoptions = $options;
354 break;
355
356 case PEAR_ERROR_CALLBACK:
357 $setmode = $mode;
358 // class/object method callback
359 if (is_callable($options)) {
360 $setoptions = $options;
361 } else {
362 trigger_error("invalid error callback", E_USER_WARNING);
363 }
364 break;
365
366 default:
367 trigger_error("invalid error mode", E_USER_WARNING);
368 break;
369 }
370 }
371
372 // }}}
373 // {{{ expectError()
374
375 /**
376 * This method is used to tell which errors you expect to get.
377 * Expected errors are always returned with error mode
378 * PEAR_ERROR_RETURN. Expected error codes are stored in a stack,
379 * and this method pushes a new element onto it. The list of
380 * expected errors are in effect until they are popped off the
381 * stack with the popExpect() method.
382 *
383 * Note that this method can not be called statically
384 *
385 * @param mixed $code a single error code or an array of error codes to expect
386 *
387 * @return int the new depth of the "expected errors" stack
388 * @access public
389 */
390 function expectError($code = '*')
391 {
392 if (is_array($code)) {
393 array_push($this->_expected_errors, $code);
394 } else {
395 array_push($this->_expected_errors, array($code));
396 }
397 return sizeof($this->_expected_errors);
398 }
399
400 // }}}
401 // {{{ popExpect()
402
403 /**
404 * This method pops one element off the expected error codes
405 * stack.
406 *
407 * @return array the list of error codes that were popped
408 */
409 function popExpect()
410 {
411 return array_pop($this->_expected_errors);
412 }
413
414 // }}}
415 // {{{ _checkDelExpect()
416
417 /**
418 * This method checks unsets an error code if available
419 *
420 * @param mixed error code
421 * @return bool true if the error code was unset, false otherwise
422 * @access private
423 * @since PHP 4.3.0
424 */
425 function _checkDelExpect($error_code)
426 {
427 $deleted = false;
428
429 foreach ($this->_expected_errors AS $key => $error_array) {
430 if (in_array($error_code, $error_array)) {
431 unset($this->_expected_errors[$key][array_search($error_code, $error_array)]);
432 $deleted = true;
433 }
434
435 // clean up empty arrays
436 if (0 == count($this->_expected_errors[$key])) {
437 unset($this->_expected_errors[$key]);
438 }
439 }
440 return $deleted;
441 }
442
443 // }}}
444 // {{{ delExpect()
445
446 /**
447 * This method deletes all occurences of the specified element from
448 * the expected error codes stack.
449 *
450 * @param mixed $error_code error code that should be deleted
451 * @return mixed list of error codes that were deleted or error
452 * @access public
453 * @since PHP 4.3.0
454 */
455 function delExpect($error_code)
456 {
457 $deleted = false;
458
459 if ((is_array($error_code) && (0 != count($error_code)))) {
460 // $error_code is a non-empty array here;
461 // we walk through it trying to unset all
462 // values
463 foreach($error_code as $key => $error) {
464 if ($this->_checkDelExpect($error)) {
465 $deleted = true;
466 } else {
467 $deleted = false;
468 }
469 }
470 return $deleted ? true : net_php_pear_PEAR::raiseError("The expected error you submitted does not exist"); // IMPROVE ME
471 } elseif (!empty($error_code)) {
472 // $error_code comes alone, trying to unset it
473 if ($this->_checkDelExpect($error_code)) {
474 return true;
475 } else {
476 return net_php_pear_PEAR::raiseError("The expected error you submitted does not exist"); // IMPROVE ME
477 }
478 } else {
479 // $error_code is empty
480 return net_php_pear_PEAR::raiseError("The expected error you submitted is empty"); // IMPROVE ME
481 }
482 }
483
484 // }}}
485 // {{{ raiseError()
486
487 /**
488 * This method is a wrapper that returns an instance of the
489 * configured error class with this object's default error
490 * handling applied. If the $mode and $options parameters are not
491 * specified, the object's defaults are used.
492 *
493 * @param mixed $message a text error message or a PEAR error object
494 *
495 * @param int $code a numeric error code (it is up to your class
496 * to define these if you want to use codes)
497 *
498 * @param int $mode One of PEAR_ERROR_RETURN, PEAR_ERROR_PRINT,
499 * PEAR_ERROR_TRIGGER, PEAR_ERROR_DIE,
500 * PEAR_ERROR_CALLBACK, PEAR_ERROR_EXCEPTION.
501 *
502 * @param mixed $options If $mode is PEAR_ERROR_TRIGGER, this parameter
503 * specifies the PHP-internal error level (one of
504 * E_USER_NOTICE, E_USER_WARNING or E_USER_ERROR).
505 * If $mode is PEAR_ERROR_CALLBACK, this
506 * parameter specifies the callback function or
507 * method. In other error modes this parameter
508 * is ignored.
509 *
510 * @param string $userinfo If you need to pass along for example debug
511 * information, this parameter is meant for that.
512 *
513 * @param string $error_class The returned error object will be
514 * instantiated from this class, if specified.
515 *
516 * @param bool $skipmsg If true, raiseError will only pass error codes,
517 * the error message parameter will be dropped.
518 *
519 * @access public
520 * @return object a PEAR error object
521 * @see PEAR::setErrorHandling
522 * @since PHP 4.0.5
523 */
524 function &raiseError($message = null,
525 $code = null,
526 $mode = null,
527 $options = null,
528 $userinfo = null,
529 $error_class = null,
530 $skipmsg = false)
531 {
532 // The error is yet a PEAR error object
533 if (is_object($message)) {
534 $code = $message->getCode();
535 $userinfo = $message->getUserInfo();
536 $error_class = $message->getType();
537 $message->error_message_prefix = '';
538 $message = $message->getMessage();
539 }
540
541 if (isset($this) && isset($this->_expected_errors) && sizeof($this->_expected_errors) > 0 && sizeof($exp = end($this->_expected_errors))) {
542 if ($exp[0] == "*" ||
543 (is_int(reset($exp)) && in_array($code, $exp)) ||
544 (is_string(reset($exp)) && in_array($message, $exp))) {
545 $mode = PEAR_ERROR_RETURN;
546 }
547 }
548 // No mode given, try global ones
549 if ($mode === null) {
550 // Class error handler
551 if (isset($this) && isset($this->_default_error_mode)) {
552 $mode = $this->_default_error_mode;
553 $options = $this->_default_error_options;
554 // Global error handler
555 } elseif (isset($GLOBALS['_PEAR_default_error_mode'])) {
556 $mode = $GLOBALS['_PEAR_default_error_mode'];
557 $options = $GLOBALS['_PEAR_default_error_options'];
558 }
559 }
560
561 if ($error_class !== null) {
562 $ec = $error_class;
563 } elseif (isset($this) && isset($this->_error_class)) {
564 $ec = $this->_error_class;
565 } else {
566 $ec = 'PEAR_Error';
567 }
568 if (intval(PHP_VERSION) < 5) {
569 // little non-eval hack to fix bug #12147
570 include 'PEAR/FixPHP5PEARWarnings.php';
571 return $a;
572 }
573 if ($skipmsg) {
574 $a = new $ec($code, $mode, $options, $userinfo);
575 } else {
576 $a = new $ec($message, $code, $mode, $options, $userinfo);
577 }
578 return $a;
579 }
580
581 // }}}
582 // {{{ throwError()
583
584 /**
585 * Simpler form of raiseError with fewer options. In most cases
586 * message, code and userinfo are enough.
587 *
588 * @param string $message
589 *
590 */
591 function &throwError($message = null,
592 $code = null,
593 $userinfo = null)
594 {
595 if (isset($this) && is_a($this, 'net_php_pear_PEAR')) {
596 $a = &$this->raiseError($message, $code, null, null, $userinfo);
597 return $a;
598 } else {
599 $a = &net_php_pear_PEAR::raiseError($message, $code, null, null, $userinfo);
600 return $a;
601 }
602 }
603
604 // }}}
605 function staticPushErrorHandling($mode, $options = null)
606 {
607 $stack = &$GLOBALS['_PEAR_error_handler_stack'];
608 $def_mode = &$GLOBALS['_PEAR_default_error_mode'];
609 $def_options = &$GLOBALS['_PEAR_default_error_options'];
610 $stack[] = array($def_mode, $def_options);
611 switch ($mode) {
612 case PEAR_ERROR_EXCEPTION:
613 case PEAR_ERROR_RETURN:
614 case PEAR_ERROR_PRINT:
615 case PEAR_ERROR_TRIGGER:
616 case PEAR_ERROR_DIE:
617 case null:
618 $def_mode = $mode;
619 $def_options = $options;
620 break;
621
622 case PEAR_ERROR_CALLBACK:
623 $def_mode = $mode;
624 // class/object method callback
625 if (is_callable($options)) {
626 $def_options = $options;
627 } else {
628 trigger_error("invalid error callback", E_USER_WARNING);
629 }
630 break;
631
632 default:
633 trigger_error("invalid error mode", E_USER_WARNING);
634 break;
635 }
636 $stack[] = array($mode, $options);
637 return true;
638 }
639
640 function staticPopErrorHandling()
641 {
642 $stack = &$GLOBALS['_PEAR_error_handler_stack'];
643 $setmode = &$GLOBALS['_PEAR_default_error_mode'];
644 $setoptions = &$GLOBALS['_PEAR_default_error_options'];
645 array_pop($stack);
646 list($mode, $options) = $stack[sizeof($stack) - 1];
647 array_pop($stack);
648 switch ($mode) {
649 case PEAR_ERROR_EXCEPTION:
650 case PEAR_ERROR_RETURN:
651 case PEAR_ERROR_PRINT:
652 case PEAR_ERROR_TRIGGER:
653 case PEAR_ERROR_DIE:
654 case null:
655 $setmode = $mode;
656 $setoptions = $options;
657 break;
658
659 case PEAR_ERROR_CALLBACK:
660 $setmode = $mode;
661 // class/object method callback
662 if (is_callable($options)) {
663 $setoptions = $options;
664 } else {
665 trigger_error("invalid error callback", E_USER_WARNING);
666 }
667 break;
668
669 default:
670 trigger_error("invalid error mode", E_USER_WARNING);
671 break;
672 }
673 return true;
674 }
675
676 // {{{ pushErrorHandling()
677
678 /**
679 * Push a new error handler on top of the error handler options stack. With this
680 * you can easily override the actual error handler for some code and restore
681 * it later with popErrorHandling.
682 *
683 * @param mixed $mode (same as setErrorHandling)
684 * @param mixed $options (same as setErrorHandling)
685 *
686 * @return bool Always true
687 *
688 * @see PEAR::setErrorHandling
689 */
690 function pushErrorHandling($mode, $options = null)
691 {
692 $stack = &$GLOBALS['_PEAR_error_handler_stack'];
693 if (isset($this) && is_a($this, 'net_php_pear_PEAR')) {
694 $def_mode = &$this->_default_error_mode;
695 $def_options = &$this->_default_error_options;
696 } else {
697 $def_mode = &$GLOBALS['_PEAR_default_error_mode'];
698 $def_options = &$GLOBALS['_PEAR_default_error_options'];
699 }
700 $stack[] = array($def_mode, $def_options);
701
702 if (isset($this) && is_a($this, 'net_php_pear_PEAR')) {
703 $this->setErrorHandling($mode, $options);
704 } else {
705 net_php_pear_PEAR::setErrorHandling($mode, $options);
706 }
707 $stack[] = array($mode, $options);
708 return true;
709 }
710
711 // }}}
712 // {{{ popErrorHandling()
713
714 /**
715 * Pop the last error handler used
716 *
717 * @return bool Always true
718 *
719 * @see PEAR::pushErrorHandling
720 */
721 function popErrorHandling()
722 {
723 $stack = &$GLOBALS['_PEAR_error_handler_stack'];
724 array_pop($stack);
725 list($mode, $options) = $stack[sizeof($stack) - 1];
726 array_pop($stack);
727 if (isset($this) && is_a($this, 'net_php_pear_PEAR')) {
728 $this->setErrorHandling($mode, $options);
729 } else {
730 net_php_pear_PEAR::setErrorHandling($mode, $options);
731 }
732 return true;
733 }
734
735 // }}}
736 // {{{ loadExtension()
737
738 /**
739 * OS independant PHP extension load. Remember to take care
740 * on the correct extension name for case sensitive OSes.
741 *
742 * @param string $ext The extension name
743 * @return bool Success or not on the dl() call
744 */
745 function loadExtension($ext)
746 {
747 if (!extension_loaded($ext)) {
748 // if either returns true dl() will produce a FATAL error, stop that
749 if ((ini_get('enable_dl') != 1) || (ini_get('safe_mode') == 1)) {
750 return false;
751 }
752 if (OS_WINDOWS) {
753 $suffix = '.dll';
754 } elseif (PHP_OS == 'HP-UX') {
755 $suffix = '.sl';
756 } elseif (PHP_OS == 'AIX') {
757 $suffix = '.a';
758 } elseif (PHP_OS == 'OSX') {
759 $suffix = '.bundle';
760 } else {
761 $suffix = '.so';
762 }
763 return @dl('php_'.$ext.$suffix) || @dl($ext.$suffix);
764 }
765 return true;
766 }
767
768 // }}}
769}
770
771// {{{ _PEAR_call_destructors()
772
773if (!function_exists("_PEAR_call_destructors")) {
774
775function _PEAR_call_destructors()
776{
777 global $_PEAR_destructor_object_list;
778 if (is_array($_PEAR_destructor_object_list) &&
779 sizeof($_PEAR_destructor_object_list))
780 {
781 reset($_PEAR_destructor_object_list);
782 if (net_php_pear_PEAR::getStaticProperty('net_php_pear_PEAR', 'destructlifo')) {
783 $_PEAR_destructor_object_list = array_reverse($_PEAR_destructor_object_list);
784 }
785 while (list($k, $objref) = each($_PEAR_destructor_object_list)) {
786 $classname = get_class($objref);
787 while ($classname) {
788 $destructor = "_$classname";
789 if (method_exists($objref, $destructor)) {
790 $objref->$destructor();
791 break;
792 } else {
793 $classname = get_parent_class($classname);
794 }
795 }
796 }
797 // Empty the object list to ensure that destructors are
798 // not called more than once.
799 $_PEAR_destructor_object_list = array();
800 }
801
802 // Now call the shutdown functions
803 if (is_array($GLOBALS['_PEAR_shutdown_funcs']) AND !empty($GLOBALS['_PEAR_shutdown_funcs'])) {
804 foreach ($GLOBALS['_PEAR_shutdown_funcs'] as $value) {
805 call_user_func_array($value[0], $value[1]);
806 }
807 }
808}
809
810}
811
812// }}}
813/**
814 * Standard PEAR error class for PHP 4
815 *
816 * This class is supserseded by {@link PEAR_Exception} in PHP 5
817 *
818 * @category pear
819 * @package PEAR
820 * @author Stig Bakken <ssb@php.net>
821 * @author Tomas V.V. Cox <cox@idecnet.com>
822 * @author Gregory Beaver <cellog@php.net>
823 * @copyright 1997-2006 The PHP Group
824 * @license http://www.php.net/license/3_0.txt PHP License 3.0
825 * @version Release: 1.7.2
826 * @link http://pear.php.net/manual/en/core.pear.pear-error.php
827 * @see PEAR::raiseError(), PEAR::throwError()
828 * @since Class available since PHP 4.0.2
829 */
830
831if (!class_exists("PEAR_Error")) {
832class PEAR_Error
833{
834 // {{{ properties
835
836 var $error_message_prefix = '';
837 var $mode = PEAR_ERROR_RETURN;
838 var $level = E_USER_NOTICE;
839 var $code = -1;
840 var $message = '';
841 var $userinfo = '';
842 var $backtrace = null;
843
844 // }}}
845 // {{{ constructor
846
847 /**
848 * PEAR_Error constructor
849 *
850 * @param string $message message
851 *
852 * @param int $code (optional) error code
853 *
854 * @param int $mode (optional) error mode, one of: PEAR_ERROR_RETURN,
855 * PEAR_ERROR_PRINT, PEAR_ERROR_DIE, PEAR_ERROR_TRIGGER,
856 * PEAR_ERROR_CALLBACK or PEAR_ERROR_EXCEPTION
857 *
858 * @param mixed $options (optional) error level, _OR_ in the case of
859 * PEAR_ERROR_CALLBACK, the callback function or object/method
860 * tuple.
861 *
862 * @param string $userinfo (optional) additional user/debug info
863 *
864 * @access public
865 *
866 */
867 function PEAR_Error($message = 'unknown error', $code = null,
868 $mode = null, $options = null, $userinfo = null)
869 {
870 if ($mode === null) {
871 $mode = PEAR_ERROR_RETURN;
872 }
873 $this->message = $message;
874 $this->code = $code;
875 $this->mode = $mode;
876 $this->userinfo = $userinfo;
877 if (!net_php_pear_PEAR::getStaticProperty('PEAR_Error', 'skiptrace')) {
878 $this->backtrace = debug_backtrace();
879 if (isset($this->backtrace[0]) && isset($this->backtrace[0]['object'])) {
880 unset($this->backtrace[0]['object']);
881 }
882 }
883 if ($mode & PEAR_ERROR_CALLBACK) {
884 $this->level = E_USER_NOTICE;
885 $this->callback = $options;
886 } else {
887 if ($options === null) {
888 $options = E_USER_NOTICE;
889 }
890 $this->level = $options;
891 $this->callback = null;
892 }
893 if ($this->mode & PEAR_ERROR_PRINT) {
894 if (is_null($options) || is_int($options)) {
895 $format = "%s";
896 } else {
897 $format = $options;
898 }
899 printf($format, $this->getMessage());
900 }
901 if ($this->mode & PEAR_ERROR_TRIGGER) {
902 trigger_error($this->getMessage(), $this->level);
903 }
904 if ($this->mode & PEAR_ERROR_DIE) {
905 $msg = $this->getMessage();
906 if (is_null($options) || is_int($options)) {
907 $format = "%s";
908 if (substr($msg, -1) != "\n") {
909 $msg .= "\n";
910 }
911 } else {
912 $format = $options;
913 }
914 die(sprintf($format, $msg));
915 }
916 if ($this->mode & PEAR_ERROR_CALLBACK) {
917 if (is_callable($this->callback)) {
918 call_user_func($this->callback, $this);
919 }
920 }
921 if ($this->mode & PEAR_ERROR_EXCEPTION) {
922 trigger_error("PEAR_ERROR_EXCEPTION is obsolete, use class PEAR_Exception for exceptions", E_USER_WARNING);
923 eval('$e = new Exception($this->message, $this->code);throw($e);');
924 }
925 }
926
927 // }}}
928 // {{{ getMode()
929
930 /**
931 * Get the error mode from an error object.
932 *
933 * @return int error mode
934 * @access public
935 */
936 function getMode() {
937 return $this->mode;
938 }
939
940 // }}}
941 // {{{ getCallback()
942
943 /**
944 * Get the callback function/method from an error object.
945 *
946 * @return mixed callback function or object/method array
947 * @access public
948 */
949 function getCallback() {
950 return $this->callback;
951 }
952
953 // }}}
954 // {{{ getMessage()
955
956
957 /**
958 * Get the error message from an error object.
959 *
960 * @return string full error message
961 * @access public
962 */
963 function getMessage()
964 {
965 return ($this->error_message_prefix . $this->message);
966 }
967
968
969 // }}}
970 // {{{ getCode()
971
972 /**
973 * Get error code from an error object
974 *
975 * @return int error code
976 * @access public
977 */
978 function getCode()
979 {
980 return $this->code;
981 }
982
983 // }}}
984 // {{{ getType()
985
986 /**
987 * Get the name of this error/exception.
988 *
989 * @return string error/exception name (type)
990 * @access public
991 */
992 function getType()
993 {
994 return get_class($this);
995 }
996
997 // }}}
998 // {{{ getUserInfo()
999
1000 /**
1001 * Get additional user-supplied information.
1002 *
1003 * @return string user-supplied information
1004 * @access public
1005 */
1006 function getUserInfo()
1007 {
1008 return $this->userinfo;
1009 }
1010
1011 // }}}
1012 // {{{ getDebugInfo()
1013
1014 /**
1015 * Get additional debug information supplied by the application.
1016 *
1017 * @return string debug information
1018 * @access public
1019 */
1020 function getDebugInfo()
1021 {
1022 return $this->getUserInfo();
1023 }
1024
1025 // }}}
1026 // {{{ getBacktrace()
1027
1028 /**
1029 * Get the call backtrace from where the error was generated.
1030 * Supported with PHP 4.3.0 or newer.
1031 *
1032 * @param int $frame (optional) what frame to fetch
1033 * @return array Backtrace, or NULL if not available.
1034 * @access public
1035 */
1036 function getBacktrace($frame = null)
1037 {
1038 if (defined('PEAR_IGNORE_BACKTRACE')) {
1039 return null;
1040 }
1041 if ($frame === null) {
1042 return $this->backtrace;
1043 }
1044 return $this->backtrace[$frame];
1045 }
1046
1047 // }}}
1048 // {{{ addUserInfo()
1049
1050 function addUserInfo($info)
1051 {
1052 if (empty($this->userinfo)) {
1053 $this->userinfo = $info;
1054 } else {
1055 $this->userinfo .= " ** $info";
1056 }
1057 }
1058
1059 // }}}
1060 // {{{ toString()
1061 function __toString()
1062 {
1063 return $this->getMessage();
1064 }
1065 // }}}
1066 // {{{ toString()
1067
1068 /**
1069 * Make a string representation of this object.
1070 *
1071 * @return string a string with an object summary
1072 * @access public
1073 */
1074 function toString() {
1075 $modes = array();
1076 $levels = array(E_USER_NOTICE => 'notice',
1077 E_USER_WARNING => 'warning',
1078 E_USER_ERROR => 'error');
1079 if ($this->mode & PEAR_ERROR_CALLBACK) {
1080 if (is_array($this->callback)) {
1081 $callback = (is_object($this->callback[0]) ?
1082 strtolower(get_class($this->callback[0])) :
1083 $this->callback[0]) . '::' .
1084 $this->callback[1];
1085 } else {
1086 $callback = $this->callback;
1087 }
1088 return sprintf('[%s: message="%s" code=%d mode=callback '.
1089 'callback=%s prefix="%s" info="%s"]',
1090 strtolower(get_class($this)), $this->message, $this->code,
1091 $callback, $this->error_message_prefix,
1092 $this->userinfo);
1093 }
1094 if ($this->mode & PEAR_ERROR_PRINT) {
1095 $modes[] = 'print';
1096 }
1097 if ($this->mode & PEAR_ERROR_TRIGGER) {
1098 $modes[] = 'trigger';
1099 }
1100 if ($this->mode & PEAR_ERROR_DIE) {
1101 $modes[] = 'die';
1102 }
1103 if ($this->mode & PEAR_ERROR_RETURN) {
1104 $modes[] = 'return';
1105 }
1106 return sprintf('[%s: message="%s" code=%d mode=%s level=%s '.
1107 'prefix="%s" info="%s"]',
1108 strtolower(get_class($this)), $this->message, $this->code,
1109 implode("|", $modes), $levels[$this->level],
1110 $this->error_message_prefix,
1111 $this->userinfo);
1112 }
1113
1114 // }}}
1115}
1116}
1117
1118/*
1119 * Local Variables:
1120 * mode: php
1121 * tab-width: 4
1122 * c-basic-offset: 4
1123 * End:
1124 */
1125?>
Note: See TracBrowser for help on using the repository browser.