Context Navigation

source: branches/comu-utf8/data/module/PEAR.php @ 15099

Visit:

Revision 15099, 33.1 KB checked in by Yammy, 19 years ago (diff)
UTF-8変換済みファイルインポート 1.3.4ベース

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 [email protected] so we can mail you a copy immediately.
14	*
15	* @category pear
16	* @package PEAR
17	* @author Sterling Hughes <[email protected]>
18	* @author Stig Bakken <[email protected]>
19	* @author Tomas V.V.Cox <[email protected]>
20	* @author Greg Beaver <[email protected]>
21	* @copyright 1997-2006 The PHP Group
22	* @license http://www.php.net/license/3_0.txt PHP License 3.0
23	* @version CVS: $Id: PEAR.php 4773 2006-10-12 06:57:07Z naka $
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 <[email protected]>
92	* @author Tomas V.V. Cox <[email protected]>
93	* @author Greg Beaver <[email protected]>
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.4.6
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 <[email protected]>
801	* @author Tomas V.V. Cox <[email protected]>
802	* @author Gregory Beaver <[email protected]>
803	* @copyright 1997-2006 The PHP Group
804	* @license http://www.php.net/license/3_0.txt PHP License 3.0
805	* @version Release: 1.4.6
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	?>

Note: See TracBrowser for help on using the repository browser.

Download in other formats: