| [ Index ] |
|
Code source de PHP PEAR 1.4.5 |
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-2005 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.96 2005/09/21 00:12:35 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 */ 31 define('PEAR_ERROR_RETURN', 1); 32 define('PEAR_ERROR_PRINT', 2); 33 define('PEAR_ERROR_TRIGGER', 4); 34 define('PEAR_ERROR_DIE', 8); 35 define('PEAR_ERROR_CALLBACK', 16); 36 /** 37 * WARNING: obsolete 38 * @deprecated 39 */ 40 define('PEAR_ERROR_EXCEPTION', 32); 41 /**#@-*/ 42 define('PEAR_ZE2', (function_exists('version_compare') && 43 version_compare(zend_version(), "2-dev", "ge"))); 44 45 if (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 56 if (!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-2005 The PHP Group 95 * @license http://www.php.net/license/3_0.txt PHP License 3.0 96 * @version Release: 1.4.5 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 */ 102 class 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 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 return $properties[$class][$var]; 234 } 235 236 // }}} 237 // {{{ registerShutdownFunc() 238 239 /** 240 * Use this function to register a shutdown method for static 241 * classes. 242 * 243 * @access public 244 * @param mixed $func The function name (or array of class/method) to call 245 * @param mixed $args The arguments to pass to the function 246 * @return void 247 */ 248 function registerShutdownFunc($func, $args = array()) 249 { 250 $GLOBALS['_PEAR_shutdown_funcs'][] = array($func, $args); 251 } 252 253 // }}} 254 // {{{ isError() 255 256 /** 257 * Tell whether a value is a PEAR error. 258 * 259 * @param mixed $data the value to test 260 * @param int $code if $data is an error object, return true 261 * only if $code is a string and 262 * $obj->getMessage() == $code or 263 * $code is an integer and $obj->getCode() == $code 264 * @access public 265 * @return bool true if parameter is an error 266 */ 267 function isError($data, $code = null) 268 { 269 if (is_a($data, 'PEAR_Error')) { 270 if (is_null($code)) { 271 return true; 272 } elseif (is_string($code)) { 273 return $data->getMessage() == $code; 274 } else { 275 return $data->getCode() == $code; 276 } 277 } 278 return false; 279 } 280 281 // }}} 282 // {{{ setErrorHandling() 283 284 /** 285 * Sets how errors generated by this object should be handled. 286 * Can be invoked both in objects and statically. If called 287 * statically, setErrorHandling sets the default behaviour for all 288 * PEAR objects. If called in an object, setErrorHandling sets 289 * the default behaviour for that object. 290 * 291 * @param int $mode 292 * One of PEAR_ERROR_RETURN, PEAR_ERROR_PRINT, 293 * PEAR_ERROR_TRIGGER, PEAR_ERROR_DIE, 294 * PEAR_ERROR_CALLBACK or PEAR_ERROR_EXCEPTION. 295 * 296 * @param mixed $options 297 * When $mode is PEAR_ERROR_TRIGGER, this is the error level (one 298 * of E_USER_NOTICE, E_USER_WARNING or E_USER_ERROR). 299 * 300 * When $mode is PEAR_ERROR_CALLBACK, this parameter is expected 301 * to be the callback function or method. A callback 302 * function is a string with the name of the function, a 303 * callback method is an array of two elements: the element 304 * at index 0 is the object, and the element at index 1 is 305 * the name of the method to call in the object. 306 * 307 * When $mode is PEAR_ERROR_PRINT or PEAR_ERROR_DIE, this is 308 * a printf format string used when printing the error 309 * message. 310 * 311 * @access public 312 * @return void 313 * @see PEAR_ERROR_RETURN 314 * @see PEAR_ERROR_PRINT 315 * @see PEAR_ERROR_TRIGGER 316 * @see PEAR_ERROR_DIE 317 * @see PEAR_ERROR_CALLBACK 318 * @see PEAR_ERROR_EXCEPTION 319 * 320 * @since PHP 4.0.5 321 */ 322 323 function setErrorHandling($mode = null, $options = null) 324 { 325 if (isset($this) && is_a($this, 'PEAR')) { 326 $setmode = &$this->_default_error_mode; 327 $setoptions = &$this->_default_error_options; 328 } else { 329 $setmode = &$GLOBALS['_PEAR_default_error_mode']; 330 $setoptions = &$GLOBALS['_PEAR_default_error_options']; 331 } 332 333 switch ($mode) { 334 case PEAR_ERROR_EXCEPTION: 335 case PEAR_ERROR_RETURN: 336 case PEAR_ERROR_PRINT: 337 case PEAR_ERROR_TRIGGER: 338 case PEAR_ERROR_DIE: 339 case null: 340 $setmode = $mode; 341 $setoptions = $options; 342 break; 343 344 case PEAR_ERROR_CALLBACK: 345 $setmode = $mode; 346 // class/object method callback 347 if (is_callable($options)) { 348 $setoptions = $options; 349 } else { 350 trigger_error("invalid error callback", E_USER_WARNING); 351 } 352 break; 353 354 default: 355 trigger_error("invalid error mode", E_USER_WARNING); 356 break; 357 } 358 } 359 360 // }}} 361 // {{{ expectError() 362 363 /** 364 * This method is used to tell which errors you expect to get. 365 * Expected errors are always returned with error mode 366 * PEAR_ERROR_RETURN. Expected error codes are stored in a stack, 367 * and this method pushes a new element onto it. The list of 368 * expected errors are in effect until they are popped off the 369 * stack with the popExpect() method. 370 * 371 * Note that this method can not be called statically 372 * 373 * @param mixed $code a single error code or an array of error codes to expect 374 * 375 * @return int the new depth of the "expected errors" stack 376 * @access public 377 */ 378 function expectError($code = '*') 379 { 380 if (is_array($code)) { 381 array_push($this->_expected_errors, $code); 382 } else { 383 array_push($this->_expected_errors, array($code)); 384 } 385 return sizeof($this->_expected_errors); 386 } 387 388 // }}} 389 // {{{ popExpect() 390 391 /** 392 * This method pops one element off the expected error codes 393 * stack. 394 * 395 * @return array the list of error codes that were popped 396 */ 397 function popExpect() 398 { 399 return array_pop($this->_expected_errors); 400 } 401 402 // }}} 403 // {{{ _checkDelExpect() 404 405 /** 406 * This method checks unsets an error code if available 407 * 408 * @param mixed error code 409 * @return bool true if the error code was unset, false otherwise 410 * @access private 411 * @since PHP 4.3.0 412 */ 413 function _checkDelExpect($error_code) 414 { 415 $deleted = false; 416 417 foreach ($this->_expected_errors AS $key => $error_array) { 418 if (in_array($error_code, $error_array)) { 419 unset($this->_expected_errors[$key][array_search($error_code, $error_array)]); 420 $deleted = true; 421 } 422 423 // clean up empty arrays 424 if (0 == count($this->_expected_errors[$key])) { 425 unset($this->_expected_errors[$key]); 426 } 427 } 428 return $deleted; 429 } 430 431 // }}} 432 // {{{ delExpect() 433 434 /** 435 * This method deletes all occurences of the specified element from 436 * the expected error codes stack. 437 * 438 * @param mixed $error_code error code that should be deleted 439 * @return mixed list of error codes that were deleted or error 440 * @access public 441 * @since PHP 4.3.0 442 */ 443 function delExpect($error_code) 444 { 445 $deleted = false; 446 447 if ((is_array($error_code) && (0 != count($error_code)))) { 448 // $error_code is a non-empty array here; 449 // we walk through it trying to unset all 450 // values 451 foreach($error_code as $key => $error) { 452 if ($this->_checkDelExpect($error)) { 453 $deleted = true; 454 } else { 455 $deleted = false; 456 } 457 } 458 return $deleted ? true : PEAR::raiseError("The expected error you submitted does not exist"); // IMPROVE ME 459 } elseif (!empty($error_code)) { 460 // $error_code comes alone, trying to unset it 461 if ($this->_checkDelExpect($error_code)) { 462 return true; 463 } else { 464 return PEAR::raiseError("The expected error you submitted does not exist"); // IMPROVE ME 465 } 466 } else { 467 // $error_code is empty 468 return PEAR::raiseError("The expected error you submitted is empty"); // IMPROVE ME 469 } 470 } 471 472 // }}} 473 // {{{ raiseError() 474 475 /** 476 * This method is a wrapper that returns an instance of the 477 * configured error class with this object's default error 478 * handling applied. If the $mode and $options parameters are not 479 * specified, the object's defaults are used. 480 * 481 * @param mixed $message a text error message or a PEAR error object 482 * 483 * @param int $code a numeric error code (it is up to your class 484 * to define these if you want to use codes) 485 * 486 * @param int $mode One of PEAR_ERROR_RETURN, PEAR_ERROR_PRINT, 487 * PEAR_ERROR_TRIGGER, PEAR_ERROR_DIE, 488 * PEAR_ERROR_CALLBACK, PEAR_ERROR_EXCEPTION. 489 * 490 * @param mixed $options If $mode is PEAR_ERROR_TRIGGER, this parameter 491 * specifies the PHP-internal error level (one of 492 * E_USER_NOTICE, E_USER_WARNING or E_USER_ERROR). 493 * If $mode is PEAR_ERROR_CALLBACK, this 494 * parameter specifies the callback function or 495 * method. In other error modes this parameter 496 * is ignored. 497 * 498 * @param string $userinfo If you need to pass along for example debug 499 * information, this parameter is meant for that. 500 * 501 * @param string $error_class The returned error object will be 502 * instantiated from this class, if specified. 503 * 504 * @param bool $skipmsg If true, raiseError will only pass error codes, 505 * the error message parameter will be dropped. 506 * 507 * @access public 508 * @return object a PEAR error object 509 * @see PEAR::setErrorHandling 510 * @since PHP 4.0.5 511 */ 512 function &raiseError($message = null, 513 $code = null, 514 $mode = null, 515 $options = null, 516 $userinfo = null, 517 $error_class = null, 518 $skipmsg = false) 519 { 520 // The error is yet a PEAR error object 521 if (is_object($message)) { 522 $code = $message->getCode(); 523 $userinfo = $message->getUserInfo(); 524 $error_class = $message->getType(); 525 $message->error_message_prefix = ''; 526 $message = $message->getMessage(); 527 } 528 529 if (isset($this) && isset($this->_expected_errors) && sizeof($this->_expected_errors) > 0 && sizeof($exp = end($this->_expected_errors))) { 530 if ($exp[0] == "*" || 531 (is_int(reset($exp)) && in_array($code, $exp)) || 532 (is_string(reset($exp)) && in_array($message, $exp))) { 533 $mode = PEAR_ERROR_RETURN; 534 } 535 } 536 // No mode given, try global ones 537 if ($mode === null) { 538 // Class error handler 539 if (isset($this) && isset($this->_default_error_mode)) { 540 $mode = $this->_default_error_mode; 541 $options = $this->_default_error_options; 542 // Global error handler 543 } elseif (isset($GLOBALS['_PEAR_default_error_mode'])) { 544 $mode = $GLOBALS['_PEAR_default_error_mode']; 545 $options = $GLOBALS['_PEAR_default_error_options']; 546 } 547 } 548 549 if ($error_class !== null) { 550 $ec = $error_class; 551 } elseif (isset($this) && isset($this->_error_class)) { 552 $ec = $this->_error_class; 553 } else { 554 $ec = 'PEAR_Error'; 555 } 556 if ($skipmsg) { 557 $a = &new $ec($code, $mode, $options, $userinfo); 558 return $a; 559 } else { 560 $a = &new $ec($message, $code, $mode, $options, $userinfo); 561 return $a; 562 } 563 } 564 565 // }}} 566 // {{{ throwError() 567 568 /** 569 * Simpler form of raiseError with fewer options. In most cases 570 * message, code and userinfo are enough. 571 * 572 * @param string $message 573 * 574 */ 575 function &throwError($message = null, 576 $code = null, 577 $userinfo = null) 578 { 579 if (isset($this) && is_a($this, 'PEAR')) { 580 $a = &$this->raiseError($message, $code, null, null, $userinfo); 581 return $a; 582 } else { 583 $a = &PEAR::raiseError($message, $code, null, null, $userinfo); 584 return $a; 585 } 586 } 587 588 // }}} 589 function staticPushErrorHandling($mode, $options = null) 590 { 591 $stack = &$GLOBALS['_PEAR_error_handler_stack']; 592 $def_mode = &$GLOBALS['_PEAR_default_error_mode']; 593 $def_options = &$GLOBALS['_PEAR_default_error_options']; 594 $stack[] = array($def_mode, $def_options); 595 switch ($mode) { 596 case PEAR_ERROR_EXCEPTION: 597 case PEAR_ERROR_RETURN: 598 case PEAR_ERROR_PRINT: 599 case PEAR_ERROR_TRIGGER: 600 case PEAR_ERROR_DIE: 601 case null: 602 $def_mode = $mode; 603 $def_options = $options; 604 break; 605 606 case PEAR_ERROR_CALLBACK: 607 $def_mode = $mode; 608 // class/object method callback 609 if (is_callable($options)) { 610 $def_options = $options; 611 } else { 612 trigger_error("invalid error callback", E_USER_WARNING); 613 } 614 break; 615 616 default: 617 trigger_error("invalid error mode", E_USER_WARNING); 618 break; 619 } 620 $stack[] = array($mode, $options); 621 return true; 622 } 623 624 function staticPopErrorHandling() 625 { 626 $stack = &$GLOBALS['_PEAR_error_handler_stack']; 627 $setmode = &$GLOBALS['_PEAR_default_error_mode']; 628 $setoptions = &$GLOBALS['_PEAR_default_error_options']; 629 array_pop($stack); 630 list($mode, $options) = $stack[sizeof($stack) - 1]; 631 array_pop($stack); 632 switch ($mode) { 633 case PEAR_ERROR_EXCEPTION: 634 case PEAR_ERROR_RETURN: 635 case PEAR_ERROR_PRINT: 636 case PEAR_ERROR_TRIGGER: 637 case PEAR_ERROR_DIE: 638 case null: 639 $setmode = $mode; 640 $setoptions = $options; 641 break; 642 643 case PEAR_ERROR_CALLBACK: 644 $setmode = $mode; 645 // class/object method callback 646 if (is_callable($options)) { 647 $setoptions = $options; 648 } else { 649 trigger_error("invalid error callback", E_USER_WARNING); 650 } 651 break; 652 653 default: 654 trigger_error("invalid error mode", E_USER_WARNING); 655 break; 656 } 657 return true; 658 } 659 660 // {{{ pushErrorHandling() 661 662 /** 663 * Push a new error handler on top of the error handler options stack. With this 664 * you can easily override the actual error handler for some code and restore 665 * it later with popErrorHandling. 666 * 667 * @param mixed $mode (same as setErrorHandling) 668 * @param mixed $options (same as setErrorHandling) 669 * 670 * @return bool Always true 671 * 672 * @see PEAR::setErrorHandling 673 */ 674 function pushErrorHandling($mode, $options = null) 675 { 676 $stack = &$GLOBALS['_PEAR_error_handler_stack']; 677 if (isset($this) && is_a($this, 'PEAR')) { 678 $def_mode = &$this->_default_error_mode; 679 $def_options = &$this->_default_error_options; 680 } else { 681 $def_mode = &$GLOBALS['_PEAR_default_error_mode']; 682 $def_options = &$GLOBALS['_PEAR_default_error_options']; 683 } 684 $stack[] = array($def_mode, $def_options); 685 686 if (isset($this) && is_a($this, 'PEAR')) { 687 $this->setErrorHandling($mode, $options); 688 } else { 689 PEAR::setErrorHandling($mode, $options); 690 } 691 $stack[] = array($mode, $options); 692 return true; 693 } 694 695 // }}} 696 // {{{ popErrorHandling() 697 698 /** 699 * Pop the last error handler used 700 * 701 * @return bool Always true 702 * 703 * @see PEAR::pushErrorHandling 704 */ 705 function popErrorHandling() 706 { 707 $stack = &$GLOBALS['_PEAR_error_handler_stack']; 708 array_pop($stack); 709 list($mode, $options) = $stack[sizeof($stack) - 1]; 710 array_pop($stack); 711 if (isset($this) && is_a($this, 'PEAR')) { 712 $this->setErrorHandling($mode, $options); 713 } else { 714 PEAR::setErrorHandling($mode, $options); 715 } 716 return true; 717 } 718 719 // }}} 720 // {{{ loadExtension() 721 722 /** 723 * OS independant PHP extension load. Remember to take care 724 * on the correct extension name for case sensitive OSes. 725 * 726 * @param string $ext The extension name 727 * @return bool Success or not on the dl() call 728 */ 729 function loadExtension($ext) 730 { 731 if (!extension_loaded($ext)) { 732 // if either returns true dl() will produce a FATAL error, stop that 733 if ((ini_get('enable_dl') != 1) || (ini_get('safe_mode') == 1)) { 734 return false; 735 } 736 if (OS_WINDOWS) { 737 $suffix = '.dll'; 738 } elseif (PHP_OS == 'HP-UX') { 739 $suffix = '.sl'; 740 } elseif (PHP_OS == 'AIX') { 741 $suffix = '.a'; 742 } elseif (PHP_OS == 'OSX') { 743 $suffix = '.bundle'; 744 } else { 745 $suffix = '.so'; 746 } 747 return @dl('php_'.$ext.$suffix) || @dl($ext.$suffix); 748 } 749 return true; 750 } 751 752 // }}} 753 } 754 755 // {{{ _PEAR_call_destructors() 756 757 function _PEAR_call_destructors() 758 { 759 global $_PEAR_destructor_object_list; 760 if (is_array($_PEAR_destructor_object_list) && 761 sizeof($_PEAR_destructor_object_list)) 762 { 763 reset($_PEAR_destructor_object_list); 764 if (@PEAR::getStaticProperty('PEAR', 'destructlifo')) { 765 $_PEAR_destructor_object_list = array_reverse($_PEAR_destructor_object_list); 766 } 767 while (list($k, $objref) = each($_PEAR_destructor_object_list)) { 768 $classname = get_class($objref); 769 while ($classname) { 770 $destructor = "_$classname"; 771 if (method_exists($objref, $destructor)) { 772 $objref->$destructor(); 773 break; 774 } else { 775 $classname = get_parent_class($classname); 776 } 777 } 778 } 779 // Empty the object list to ensure that destructors are 780 // not called more than once. 781 $_PEAR_destructor_object_list = array(); 782 } 783 784 // Now call the shutdown functions 785 if (is_array($GLOBALS['_PEAR_shutdown_funcs']) AND !empty($GLOBALS['_PEAR_shutdown_funcs'])) { 786 foreach ($GLOBALS['_PEAR_shutdown_funcs'] as $value) { 787 call_user_func_array($value[0], $value[1]); 788 } 789 } 790 } 791 792 // }}} 793 /** 794 * Standard PEAR error class for PHP 4 795 * 796 * This class is supserseded by {@link PEAR_Exception} in PHP 5 797 * 798 * @category pear 799 * @package PEAR 800 * @author Stig Bakken <ssb@php.net> 801 * @author Tomas V.V. Cox <cox@idecnet.com> 802 * @author Gregory Beaver <cellog@php.net> 803 * @copyright 1997-2005 The PHP Group 804 * @license http://www.php.net/license/3_0.txt PHP License 3.0 805 * @version Release: 1.4.5 806 * @link http://pear.php.net/manual/en/core.pear.pear-error.php 807 * @see PEAR::raiseError(), PEAR::throwError() 808 * @since Class available since PHP 4.0.2 809 */ 810 class PEAR_Error 811 { 812 // {{{ properties 813 814 var $error_message_prefix = ''; 815 var $mode = PEAR_ERROR_RETURN; 816 var $level = E_USER_NOTICE; 817 var $code = -1; 818 var $message = ''; 819 var $userinfo = ''; 820 var $backtrace = null; 821 822 // }}} 823 // {{{ constructor 824 825 /** 826 * PEAR_Error constructor 827 * 828 * @param string $message message 829 * 830 * @param int $code (optional) error code 831 * 832 * @param int $mode (optional) error mode, one of: PEAR_ERROR_RETURN, 833 * PEAR_ERROR_PRINT, PEAR_ERROR_DIE, PEAR_ERROR_TRIGGER, 834 * PEAR_ERROR_CALLBACK or PEAR_ERROR_EXCEPTION 835 * 836 * @param mixed $options (optional) error level, _OR_ in the case of 837 * PEAR_ERROR_CALLBACK, the callback function or object/method 838 * tuple. 839 * 840 * @param string $userinfo (optional) additional user/debug info 841 * 842 * @access public 843 * 844 */ 845 function PEAR_Error($message = 'unknown error', $code = null, 846 $mode = null, $options = null, $userinfo = null) 847 { 848 if ($mode === null) { 849 $mode = PEAR_ERROR_RETURN; 850 } 851 $this->message = $message; 852 $this->code = $code; 853 $this->mode = $mode; 854 $this->userinfo = $userinfo; 855 if (function_exists("debug_backtrace")) { 856 if (@!PEAR::getStaticProperty('PEAR_Error', 'skiptrace')) { 857 $this->backtrace = debug_backtrace(); 858 } 859 } 860 if ($mode & PEAR_ERROR_CALLBACK) { 861 $this->level = E_USER_NOTICE; 862 $this->callback = $options; 863 } else { 864 if ($options === null) { 865 $options = E_USER_NOTICE; 866 } 867 $this->level = $options; 868 $this->callback = null; 869 } 870 if ($this->mode & PEAR_ERROR_PRINT) { 871 if (is_null($options) || is_int($options)) { 872 $format = "%s"; 873 } else { 874 $format = $options; 875 } 876 printf($format, $this->getMessage()); 877 } 878 if ($this->mode & PEAR_ERROR_TRIGGER) { 879 trigger_error($this->getMessage(), $this->level); 880 } 881 if ($this->mode & PEAR_ERROR_DIE) { 882 $msg = $this->getMessage(); 883 if (is_null($options) || is_int($options)) { 884 $format = "%s"; 885 if (substr($msg, -1) != "\n") { 886 $msg .= "\n"; 887 } 888 } else { 889 $format = $options; 890 } 891 die(sprintf($format, $msg)); 892 } 893 if ($this->mode & PEAR_ERROR_CALLBACK) { 894 if (is_callable($this->callback)) { 895 call_user_func($this->callback, $this); 896 } 897 } 898 if ($this->mode & PEAR_ERROR_EXCEPTION) { 899 trigger_error("PEAR_ERROR_EXCEPTION is obsolete, use class PEAR_Exception for exceptions", E_USER_WARNING); 900 eval('$e = new Exception($this->message, $this->code);throw($e);'); 901 } 902 } 903 904 // }}} 905 // {{{ getMode() 906 907 /** 908 * Get the error mode from an error object. 909 * 910 * @return int error mode 911 * @access public 912 */ 913 function getMode() { 914 return $this->mode; 915 } 916 917 // }}} 918 // {{{ getCallback() 919 920 /** 921 * Get the callback function/method from an error object. 922 * 923 * @return mixed callback function or object/method array 924 * @access public 925 */ 926 function getCallback() { 927 return $this->callback; 928 } 929 930 // }}} 931 // {{{ getMessage() 932 933 934 /** 935 * Get the error message from an error object. 936 * 937 * @return string full error message 938 * @access public 939 */ 940 function getMessage() 941 { 942 return ($this->error_message_prefix . $this->message); 943 } 944 945 946 // }}} 947 // {{{ getCode() 948 949 /** 950 * Get error code from an error object 951 * 952 * @return int error code 953 * @access public 954 */ 955 function getCode() 956 { 957 return $this->code; 958 } 959 960 // }}} 961 // {{{ getType() 962 963 /** 964 * Get the name of this error/exception. 965 * 966 * @return string error/exception name (type) 967 * @access public 968 */ 969 function getType() 970 { 971 return get_class($this); 972 } 973 974 // }}} 975 // {{{ getUserInfo() 976 977 /** 978 * Get additional user-supplied information. 979 * 980 * @return string user-supplied information 981 * @access public 982 */ 983 function getUserInfo() 984 { 985 return $this->userinfo; 986 } 987 988 // }}} 989 // {{{ getDebugInfo() 990 991 /** 992 * Get additional debug information supplied by the application. 993 * 994 * @return string debug information 995 * @access public 996 */ 997 function getDebugInfo() 998 { 999 return $this->getUserInfo(); 1000 } 1001 1002 // }}} 1003 // {{{ getBacktrace() 1004 1005 /** 1006 * Get the call backtrace from where the error was generated. 1007 * Supported with PHP 4.3.0 or newer. 1008 * 1009 * @param int $frame (optional) what frame to fetch 1010 * @return array Backtrace, or NULL if not available. 1011 * @access public 1012 */ 1013 function getBacktrace($frame = null) 1014 { 1015 if (defined('PEAR_IGNORE_BACKTRACE')) { 1016 return null; 1017 } 1018 if ($frame === null) { 1019 return $this->backtrace; 1020 } 1021 return $this->backtrace[$frame]; 1022 } 1023 1024 // }}} 1025 // {{{ addUserInfo() 1026 1027 function addUserInfo($info) 1028 { 1029 if (empty($this->userinfo)) { 1030 $this->userinfo = $info; 1031 } else { 1032 $this->userinfo .= " ** $info"; 1033 } 1034 } 1035 1036 // }}} 1037 // {{{ toString() 1038 1039 /** 1040 * Make a string representation of this object. 1041 * 1042 * @return string a string with an object summary 1043 * @access public 1044 */ 1045 function toString() { 1046 $modes = array(); 1047 $levels = array(E_USER_NOTICE => 'notice', 1048 E_USER_WARNING => 'warning', 1049 E_USER_ERROR => 'error'); 1050 if ($this->mode & PEAR_ERROR_CALLBACK) { 1051 if (is_array($this->callback)) { 1052 $callback = (is_object($this->callback[0]) ? 1053 strtolower(get_class($this->callback[0])) : 1054 $this->callback[0]) . '::' . 1055 $this->callback[1]; 1056 } else { 1057 $callback = $this->callback; 1058 } 1059 return sprintf('[%s: message="%s" code=%d mode=callback '. 1060 'callback=%s prefix="%s" info="%s"]', 1061 strtolower(get_class($this)), $this->message, $this->code, 1062 $callback, $this->error_message_prefix, 1063 $this->userinfo); 1064 } 1065 if ($this->mode & PEAR_ERROR_PRINT) { 1066 $modes[] = 'print'; 1067 } 1068 if ($this->mode & PEAR_ERROR_TRIGGER) { 1069 $modes[] = 'trigger'; 1070 } 1071 if ($this->mode & PEAR_ERROR_DIE) { 1072 $modes[] = 'die'; 1073 } 1074 if ($this->mode & PEAR_ERROR_RETURN) { 1075 $modes[] = 'return'; 1076 } 1077 return sprintf('[%s: message="%s" code=%d mode=%s level=%s '. 1078 'prefix="%s" info="%s"]', 1079 strtolower(get_class($this)), $this->message, $this->code, 1080 implode("|", $modes), $levels[$this->level], 1081 $this->error_message_prefix, 1082 $this->userinfo); 1083 } 1084 1085 // }}} 1086 } 1087 1088 /* 1089 * Local Variables: 1090 * mode: php 1091 * tab-width: 4 1092 * c-basic-offset: 4 1093 * End: 1094 */ 1095 ?>
titre
Description
Corps
titre
Description
Corps
titre
Description
Corps
titre
Corps
| Généré le : Sun Feb 25 14:08:00 2007 | par Balluche grâce à PHPXref 0.7 |