← All changes | back/Libraries/Pear/Pear.php +869 -0 10.1.1 → 11.1.0 View file →

		@@ -1,0 +1,869 @@
	1	+<?php
	2	+
	3	+namespace AcyMailing\Libraries\Pear;
	4	+
	5	+acym_cmsLoaded();
	6	+
	7	+/**
	8	+ * PEAR, the PHP Extension and Application Repository
	9	+ *
	10	+ * PEAR class and PEAR_Error class
	11	+ *
	12	+ * PHP versions 4 and 5
	13	+ *
	14	+ * @category pear
	15	+ * @package PEAR
	16	+ * @author Sterling Hughes <[email protected]>
	17	+ * @author Stig Bakken <[email protected]>
	18	+ * @author Tomas V.V.Cox <[email protected]>
	19	+ * @author Greg Beaver <[email protected]>
	20	+ * @copyright 1997-2010 The Authors
	21	+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
	22	+ * @link http://pear.php.net/package/PEAR
	23	+ * @since File available since Release 0.1
	24	+ */
	25	+
	26	+/**#@+
	27	+ * ERROR constants
	28	+ */
	29	+define('PEAR_ERROR_RETURN', 1);
	30	+define('PEAR_ERROR_PRINT', 2);
	31	+define('PEAR_ERROR_TRIGGER', 4);
	32	+define('PEAR_ERROR_DIE', 8);
	33	+define('PEAR_ERROR_CALLBACK', 16);
	34	+/**
	35	+ * WARNING: obsolete
	36	+ * @deprecated
	37	+ */
	38	+define('PEAR_ERROR_EXCEPTION', 32);
	39	+/**#@-*/
	40	+
	41	+if (substr(PHP_OS, 0, 3) == 'WIN') {
	42	+ define('OS_WINDOWS', true);
	43	+ define('OS_UNIX', false);
	44	+ define('PEAR_OS', 'Windows');
	45	+} else {
	46	+ define('OS_WINDOWS', false);
	47	+ define('OS_UNIX', true);
	48	+ define('PEAR_OS', 'Unix'); // blatant assumption
	49	+}
	50	+
	51	+$GLOBALS['_PEAR_default_error_mode'] = PEAR_ERROR_RETURN;
	52	+$GLOBALS['_PEAR_default_error_options'] = E_USER_NOTICE;
	53	+$GLOBALS['_PEAR_destructor_object_list'] = [];
	54	+$GLOBALS['_PEAR_shutdown_funcs'] = [];
	55	+$GLOBALS['_PEAR_error_handler_stack'] = [];
	56	+
	57	+if (function_exists('ini_set')) {
	58	+ @ini_set('track_errors', true);
	59	+}
	60	+
	61	+/**
	62	+ * Base class for other PEAR classes. Provides rudimentary
	63	+ * emulation of destructors.
	64	+ *
	65	+ * If you want a destructor in your class, inherit PEAR and make a
	66	+ * destructor method called _yourclassname (same name as the
	67	+ * constructor, but with a "_" prefix). Also, in your constructor you
	68	+ * have to call the PEAR constructor: $this->PEAR();.
	69	+ * The destructor method will be called without parameters. Note that
	70	+ * at in some SAPI implementations (such as Apache), any output during
	71	+ * the request shutdown (in which destructors are called) seems to be
	72	+ * discarded. If you need to get any debug information from your
	73	+ * destructor, use error_log(), syslog() or something similar.
	74	+ *
	75	+ * IMPORTANT! To use the emulated destructors you need to create the
	76	+ * objects by reference: $obj =& new PEAR_child;
	77	+ *
	78	+ * @category pear
	79	+ * @package PEAR
	80	+ * @author Stig Bakken <[email protected]>
	81	+ * @author Tomas V.V. Cox <[email protected]>
	82	+ * @author Greg Beaver <[email protected]>
	83	+ * @copyright 1997-2006 The PHP Group
	84	+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
	85	+ * @version Release: 1.10.16
	86	+ * @link http://pear.php.net/package/PEAR
	87	+ * @see PEAR_Error
	88	+ * @since Class available since PHP 4.0.2
	89	+ * @link http://pear.php.net/manual/en/core.pear.php#core.pear.pear
	90	+ */
	91	+class Pear
	92	+{
	93	+ /**
	94	+ * Whether to enable internal debug messages.
	95	+ *
	96	+ * @var bool
	97	+ * @access private
	98	+ */
	99	+ var $_debug = false;
	100	+
	101	+ /**
	102	+ * Default error mode for this object.
	103	+ *
	104	+ * @var int
	105	+ * @access private
	106	+ */
	107	+ var $_default_error_mode = null;
	108	+
	109	+ /**
	110	+ * Default error options used for this object when error mode
	111	+ * is PEAR_ERROR_TRIGGER.
	112	+ *
	113	+ * @var int
	114	+ * @access private
	115	+ */
	116	+ var $_default_error_options = null;
	117	+
	118	+ /**
	119	+ * Default error handler (callback) for this object, if error mode is
	120	+ * PEAR_ERROR_CALLBACK.
	121	+ *
	122	+ * @var string
	123	+ * @access private
	124	+ */
	125	+ var $_default_error_handler = '';
	126	+
	127	+ /**
	128	+ * Which class to use for error objects.
	129	+ *
	130	+ * @var string
	131	+ * @access private
	132	+ */
	133	+ var $_error_class = 'AcyMailing\Libraries\Pear\Error';
	134	+
	135	+ /**
	136	+ * An array of expected errors.
	137	+ *
	138	+ * @var array
	139	+ * @access private
	140	+ */
	141	+ var $_expected_errors = [];
	142	+
	143	+ /**
	144	+ * List of methods that can be called both statically and non-statically.
	145	+ * @var array
	146	+ */
	147	+ protected static $bivalentMethods = [
	148	+ 'setErrorHandling' => true,
	149	+ 'raiseError' => true,
	150	+ 'throwError' => true,
	151	+ 'pushErrorHandling' => true,
	152	+ 'popErrorHandling' => true,
	153	+ ];
	154	+
	155	+ /**
	156	+ * Constructor. Registers this object in
	157	+ * $_PEAR_destructor_object_list for destructor emulation if a
	158	+ * destructor object exists.
	159	+ *
	160	+ * @param string $error_class (optional) which class to use for
	161	+ * error objects, defaults to PEAR_Error.
	162	+ *
	163	+ * @access public
	164	+ * @return void
	165	+ */
	166	+ function __construct($error_class = null)
	167	+ {
	168	+ $classname = strtolower(get_class($this));
	169	+ if ($this->_debug) {
	170	+ print "PEAR constructor called, class=$classname\n";
	171	+ }
	172	+
	173	+ if ($error_class !== null) {
	174	+ $this->_error_class = $error_class;
	175	+ }
	176	+
	177	+ while ($classname && strcasecmp($classname, "pear")) {
	178	+ $destructor = "_$classname";
	179	+ if (method_exists($this, $destructor)) {
	180	+ global $_PEAR_destructor_object_list;
	181	+ $_PEAR_destructor_object_list[] = $this;
	182	+ if (!isset($GLOBALS['_PEAR_SHUTDOWN_REGISTERED'])) {
	183	+ register_shutdown_function("_PEAR_call_destructors");
	184	+ $GLOBALS['_PEAR_SHUTDOWN_REGISTERED'] = true;
	185	+ }
	186	+ break;
	187	+ } else {
	188	+ $classname = get_parent_class($classname);
	189	+ }
	190	+ }
	191	+ }
	192	+
	193	+ /**
	194	+ * Only here for backwards compatibility.
	195	+ * E.g. Archive_Tar calls $this->PEAR() in its constructor.
	196	+ *
	197	+ * @param string $error_class Which class to use for error objects,
	198	+ * defaults to PEAR_Error.
	199	+ */
	200	+ public function PEAR($error_class = null)
	201	+ {
	202	+ self::__construct($error_class);
	203	+ }
	204	+
	205	+ /**
	206	+ * Destructor (the emulated type of...). Does nothing right now,
	207	+ * but is included for forward compatibility, so subclass
	208	+ * destructors should always call it.
	209	+ *
	210	+ * See the note in the class desciption about output from
	211	+ * destructors.
	212	+ *
	213	+ * @access public
	214	+ * @return void
	215	+ */
	216	+ function _PEAR()
	217	+ {
	218	+ if ($this->_debug) {
	219	+ printf("PEAR destructor called, class=%s\n", strtolower(get_class($this)));
	220	+ }
	221	+ }
	222	+
	223	+ public function __call($method, $arguments)
	224	+ {
	225	+ if (!isset(self::$bivalentMethods[$method])) {
	226	+ trigger_error(
	227	+ 'Call to undefined method PEAR::'.$method.'()',
	228	+ E_USER_ERROR
	229	+ );
	230	+ }
	231	+
	232	+ return call_user_func_array(
	233	+ [__CLASS__, '_'.$method],
	234	+ array_merge([$this], $arguments)
	235	+ );
	236	+ }
	237	+
	238	+ public static function __callStatic($method, $arguments)
	239	+ {
	240	+ if (!isset(self::$bivalentMethods[$method])) {
	241	+ trigger_error(
	242	+ 'Call to undefined method PEAR::'.$method.'()',
	243	+ E_USER_ERROR
	244	+ );
	245	+ }
	246	+
	247	+ return call_user_func_array(
	248	+ [__CLASS__, '_'.$method],
	249	+ array_merge([null], $arguments)
	250	+ );
	251	+ }
	252	+
	253	+ /**
	254	+ * If you have a class that's mostly/entirely static, and you need static
	255	+ * properties, you can use this method to simulate them. Eg. in your method(s)
	256	+ * do this: $myVar = &PEAR::getStaticProperty('myclass', 'myVar');
	257	+ * You MUST use a reference, or they will not persist!
	258	+ *
	259	+ * @param string $class The calling classname, to prevent clashes
	260	+ * @param string $var The variable to retrieve.
	261	+ *
	262	+ * @return mixed A reference to the variable. If not set it will be
	263	+ * auto initialised to NULL.
	264	+ */
	265	+ public static function &getStaticProperty($class, $var)
	266	+ {
	267	+ static $properties;
	268	+ if (!isset($properties[$class])) {
	269	+ $properties[$class] = [];
	270	+ }
	271	+
	272	+ if (!array_key_exists($var, $properties[$class])) {
	273	+ $properties[$class][$var] = null;
	274	+ }
	275	+
	276	+ return $properties[$class][$var];
	277	+ }
	278	+
	279	+ /**
	280	+ * Use this function to register a shutdown method for static
	281	+ * classes.
	282	+ *
	283	+ * @param mixed $func The function name (or array of class/method) to call
	284	+ * @param mixed $args The arguments to pass to the function
	285	+ *
	286	+ * @return void
	287	+ */
	288	+ public static function registerShutdownFunc($func, $args = [])
	289	+ {
	290	+ // if we are called statically, there is a potential
	291	+ // that no shutdown func is registered. Bug #6445
	292	+ if (!isset($GLOBALS['_PEAR_SHUTDOWN_REGISTERED'])) {
	293	+ register_shutdown_function("_PEAR_call_destructors");
	294	+ $GLOBALS['_PEAR_SHUTDOWN_REGISTERED'] = true;
	295	+ }
	296	+ $GLOBALS['_PEAR_shutdown_funcs'][] = [$func, $args];
	297	+ }
	298	+
	299	+ /**
	300	+ * Tell whether a value is a PEAR error.
	301	+ *
	302	+ * @param mixed $data the value to test
	303	+ * @param int $code if $data is an error object, return true
	304	+ * only if $code is a string and
	305	+ * $obj->getMessage() == $code or
	306	+ * $code is an integer and $obj->getCode() == $code
	307	+ *
	308	+ * @return bool true if parameter is an error
	309	+ */
	310	+ public static function isError($data, $code = null)
	311	+ {
	312	+ if (!is_a($data, 'AcyMailing\Libraries\Pear\Error')) {
	313	+ return false;
	314	+ }
	315	+
	316	+ if (is_null($code)) {
	317	+ return true;
	318	+ } elseif (is_string($code)) {
	319	+ return $data->getMessage() == $code;
	320	+ }
	321	+
	322	+ return $data->getCode() == $code;
	323	+ }
	324	+
	325	+ /**
	326	+ * Sets how errors generated by this object should be handled.
	327	+ * Can be invoked both in objects and statically. If called
	328	+ * statically, setErrorHandling sets the default behaviour for all
	329	+ * PEAR objects. If called in an object, setErrorHandling sets
	330	+ * the default behaviour for that object.
	331	+ *
	332	+ * @param object $object
	333	+ * Object the method was called on (non-static mode)
	334	+ *
	335	+ * @param int $mode
	336	+ * One of PEAR_ERROR_RETURN, PEAR_ERROR_PRINT,
	337	+ * PEAR_ERROR_TRIGGER, PEAR_ERROR_DIE,
	338	+ * PEAR_ERROR_CALLBACK or PEAR_ERROR_EXCEPTION.
	339	+ *
	340	+ * @param mixed $options
	341	+ * When $mode is PEAR_ERROR_TRIGGER, this is the error level (one
	342	+ * of E_USER_NOTICE, E_USER_WARNING or E_USER_ERROR).
	343	+ *
	344	+ * When $mode is PEAR_ERROR_CALLBACK, this parameter is expected
	345	+ * to be the callback function or method. A callback
	346	+ * function is a string with the name of the function, a
	347	+ * callback method is an array of two elements: the element
	348	+ * at index 0 is the object, and the element at index 1 is
	349	+ * the name of the method to call in the object.
	350	+ *
	351	+ * When $mode is PEAR_ERROR_PRINT or PEAR_ERROR_DIE, this is
	352	+ * a printf format string used when printing the error
	353	+ * message.
	354	+ *
	355	+ * @access public
	356	+ * @return void
	357	+ * @see PEAR_ERROR_RETURN
	358	+ * @see PEAR_ERROR_PRINT
	359	+ * @see PEAR_ERROR_TRIGGER
	360	+ * @see PEAR_ERROR_DIE
	361	+ * @see PEAR_ERROR_CALLBACK
	362	+ * @see PEAR_ERROR_EXCEPTION
	363	+ *
	364	+ * @since PHP 4.0.5
	365	+ */
	366	+ protected static function _setErrorHandling(
	367	+ $object,
	368	+ $mode = null,
	369	+ $options = null
	370	+ ) {
	371	+ if ($object !== null) {
	372	+ $setmode = &$object->_default_error_mode;
	373	+ $setoptions = &$object->_default_error_options;
	374	+ } else {
	375	+ $setmode = &$GLOBALS['_PEAR_default_error_mode'];
	376	+ $setoptions = &$GLOBALS['_PEAR_default_error_options'];
	377	+ }
	378	+
	379	+ switch ($mode) {
	380	+ case PEAR_ERROR_EXCEPTION:
	381	+ case PEAR_ERROR_RETURN:
	382	+ case PEAR_ERROR_PRINT:
	383	+ case PEAR_ERROR_TRIGGER:
	384	+ case PEAR_ERROR_DIE:
	385	+ case null:
	386	+ $setmode = $mode;
	387	+ $setoptions = $options;
	388	+ break;
	389	+
	390	+ case PEAR_ERROR_CALLBACK:
	391	+ $setmode = $mode;
	392	+ // class/object method callback
	393	+ if (is_callable($options)) {
	394	+ $setoptions = $options;
	395	+ } else {
	396	+ trigger_error("invalid error callback", E_USER_WARNING);
	397	+ }
	398	+ break;
	399	+
	400	+ default:
	401	+ trigger_error("invalid error mode", E_USER_WARNING);
	402	+ break;
	403	+ }
	404	+ }
	405	+
	406	+ /**
	407	+ * This method is used to tell which errors you expect to get.
	408	+ * Expected errors are always returned with error mode
	409	+ * PEAR_ERROR_RETURN. Expected error codes are stored in a stack,
	410	+ * and this method pushes a new element onto it. The list of
	411	+ * expected errors are in effect until they are popped off the
	412	+ * stack with the popExpect() method.
	413	+ *
	414	+ * Note that this method can not be called statically
	415	+ *
	416	+ * @param mixed $code a single error code or an array of error codes to expect
	417	+ *
	418	+ * @return int the new depth of the "expected errors" stack
	419	+ * @access public
	420	+ */
	421	+ function expectError($code = '*')
	422	+ {
	423	+ if (is_array($code)) {
	424	+ array_push($this->_expected_errors, $code);
	425	+ } else {
	426	+ array_push($this->_expected_errors, [$code]);
	427	+ }
	428	+
	429	+ return count($this->_expected_errors);
	430	+ }
	431	+
	432	+ /**
	433	+ * This method pops one element off the expected error codes
	434	+ * stack.
	435	+ *
	436	+ * @return array the list of error codes that were popped
	437	+ */
	438	+ function popExpect()
	439	+ {
	440	+ return array_pop($this->_expected_errors);
	441	+ }
	442	+
	443	+ /**
	444	+ * This method checks unsets an error code if available
	445	+ *
	446	+ * @param mixed error code
	447	+ *
	448	+ * @return bool true if the error code was unset, false otherwise
	449	+ * @access private
	450	+ * @since PHP 4.3.0
	451	+ */
	452	+ function _checkDelExpect($error_code)
	453	+ {
	454	+ $deleted = false;
	455	+ foreach ($this->_expected_errors as $key => $error_array) {
	456	+ if (in_array($error_code, $error_array)) {
	457	+ unset($this->_expected_errors[$key][array_search($error_code, $error_array)]);
	458	+ $deleted = true;
	459	+ }
	460	+
	461	+ // clean up empty arrays
	462	+ if (0 == count($this->_expected_errors[$key])) {
	463	+ unset($this->_expected_errors[$key]);
	464	+ }
	465	+ }
	466	+
	467	+ return $deleted;
	468	+ }
	469	+
	470	+ /**
	471	+ * This method deletes all occurrences of the specified element from
	472	+ * the expected error codes stack.
	473	+ *
	474	+ * @param mixed $error_code error code that should be deleted
	475	+ *
	476	+ * @return mixed list of error codes that were deleted or error
	477	+ * @access public
	478	+ * @since PHP 4.3.0
	479	+ */
	480	+ function delExpect($error_code)
	481	+ {
	482	+ $deleted = false;
	483	+ if ((is_array($error_code) && (0 != count($error_code)))) {
	484	+ // $error_code is a non-empty array here; we walk through it trying
	485	+ // to unset all values
	486	+ foreach ($error_code as $key => $error) {
	487	+ $deleted = $this->_checkDelExpect($error) ? true : false;
	488	+ }
	489	+
	490	+ return $deleted ? true : PEAR::raiseError("The expected error you submitted does not exist"); // IMPROVE ME
	491	+ } elseif (!empty($error_code)) {
	492	+ // $error_code comes alone, trying to unset it
	493	+ if ($this->_checkDelExpect($error_code)) {
	494	+ return true;
	495	+ }
	496	+
	497	+ return PEAR::raiseError("The expected error you submitted does not exist"); // IMPROVE ME
	498	+ }
	499	+
	500	+ // $error_code is empty
	501	+ return PEAR::raiseError("The expected error you submitted is empty"); // IMPROVE ME
	502	+ }
	503	+
	504	+ /**
	505	+ * This method is a wrapper that returns an instance of the
	506	+ * configured error class with this object's default error
	507	+ * handling applied. If the $mode and $options parameters are not
	508	+ * specified, the object's defaults are used.
	509	+ *
	510	+ * @param mixed $message a text error message or a PEAR error object
	511	+ *
	512	+ * @param int $code a numeric error code (it is up to your class
	513	+ * to define these if you want to use codes)
	514	+ *
	515	+ * @param int $mode One of PEAR_ERROR_RETURN, PEAR_ERROR_PRINT,
	516	+ * PEAR_ERROR_TRIGGER, PEAR_ERROR_DIE,
	517	+ * PEAR_ERROR_CALLBACK, PEAR_ERROR_EXCEPTION.
	518	+ *
	519	+ * @param mixed $options If $mode is PEAR_ERROR_TRIGGER, this parameter
	520	+ * specifies the PHP-internal error level (one of
	521	+ * E_USER_NOTICE, E_USER_WARNING or E_USER_ERROR).
	522	+ * If $mode is PEAR_ERROR_CALLBACK, this
	523	+ * parameter specifies the callback function or
	524	+ * method. In other error modes this parameter
	525	+ * is ignored.
	526	+ *
	527	+ * @param string $userinfo If you need to pass along for example debug
	528	+ * information, this parameter is meant for that.
	529	+ *
	530	+ * @param string $error_class The returned error object will be
	531	+ * instantiated from this class, if specified.
	532	+ *
	533	+ * @param bool $skipmsg If true, raiseError will only pass error codes,
	534	+ * the error message parameter will be dropped.
	535	+ *
	536	+ * @return object a PEAR error object
	537	+ * @see PEAR::setErrorHandling
	538	+ * @since PHP 4.0.5
	539	+ */
	540	+ protected static function _raiseError(
	541	+ $object,
	542	+ $message = null,
	543	+ $code = null,
	544	+ $mode = null,
	545	+ $options = null,
	546	+ $userinfo = null,
	547	+ $error_class = null,
	548	+ $skipmsg = false
	549	+ ) {
	550	+ // The error is yet a PEAR error object
	551	+ if (is_object($message)) {
	552	+ $code = $message->getCode();
	553	+ $userinfo = $message->getUserInfo();
	554	+ $error_class = $message->getType();
	555	+ $message->error_message_prefix = '';
	556	+ $message = $message->getMessage();
	557	+ }
	558	+
	559	+ if (
	560	+ $object !== null &&
	561	+ isset($object->_expected_errors) &&
	562	+ count($object->_expected_errors) > 0 &&
	563	+ count($exp = end($object->_expected_errors))
	564	+ ) {
	565	+ if ($exp[0] === "*" ||
	566	+ (is_int(reset($exp)) && in_array($code, $exp)) ||
	567	+ (is_string(reset($exp)) && in_array($message, $exp))
	568	+ ) {
	569	+ $mode = PEAR_ERROR_RETURN;
	570	+ }
	571	+ }
	572	+
	573	+ // No mode given, try global ones
	574	+ if ($mode === null) {
	575	+ // Class error handler
	576	+ if ($object !== null && isset($object->_default_error_mode)) {
	577	+ $mode = $object->_default_error_mode;
	578	+ $options = $object->_default_error_options;
	579	+ // Global error handler
	580	+ } elseif (isset($GLOBALS['_PEAR_default_error_mode'])) {
	581	+ $mode = $GLOBALS['_PEAR_default_error_mode'];
	582	+ $options = $GLOBALS['_PEAR_default_error_options'];
	583	+ }
	584	+ }
	585	+
	586	+ if ($error_class !== null) {
	587	+ $ec = $error_class;
	588	+ } elseif ($object !== null && isset($object->_error_class)) {
	589	+ $ec = $object->_error_class;
	590	+ } else {
	591	+ $ec = 'AcyMailing\Libraries\Pear\Error';
	592	+ }
	593	+
	594	+ if ($skipmsg) {
	595	+ $a = new $ec($code, $mode, $options, $userinfo);
	596	+ } else {
	597	+ $a = new $ec($message, $code, $mode, $options, $userinfo);
	598	+ }
	599	+
	600	+ return $a;
	601	+ }
	602	+
	603	+ /**
	604	+ * Simpler form of raiseError with fewer options. In most cases
	605	+ * message, code and userinfo are enough.
	606	+ *
	607	+ * @param mixed $message a text error message or a PEAR error object
	608	+ *
	609	+ * @param int $code a numeric error code (it is up to your class
	610	+ * to define these if you want to use codes)
	611	+ *
	612	+ * @param string $userinfo If you need to pass along for example debug
	613	+ * information, this parameter is meant for that.
	614	+ *
	615	+ * @return object a PEAR error object
	616	+ * @see PEAR::raiseError
	617	+ */
	618	+ protected static function _throwError($object, $message = null, $code = null, $userinfo = null)
	619	+ {
	620	+ if ($object !== null) {
	621	+ $a = $object->raiseError($message, $code, null, null, $userinfo);
	622	+
	623	+ return $a;
	624	+ }
	625	+
	626	+ $a = PEAR::raiseError($message, $code, null, null, $userinfo);
	627	+
	628	+ return $a;
	629	+ }
	630	+
	631	+ public static function staticPushErrorHandling($mode, $options = null)
	632	+ {
	633	+ $stack = &$GLOBALS['_PEAR_error_handler_stack'];
	634	+ $def_mode = &$GLOBALS['_PEAR_default_error_mode'];
	635	+ $def_options = &$GLOBALS['_PEAR_default_error_options'];
	636	+ $stack[] = [$def_mode, $def_options];
	637	+ switch ($mode) {
	638	+ case PEAR_ERROR_EXCEPTION:
	639	+ case PEAR_ERROR_RETURN:
	640	+ case PEAR_ERROR_PRINT:
	641	+ case PEAR_ERROR_TRIGGER:
	642	+ case PEAR_ERROR_DIE:
	643	+ case null:
	644	+ $def_mode = $mode;
	645	+ $def_options = $options;
	646	+ break;
	647	+
	648	+ case PEAR_ERROR_CALLBACK:
	649	+ $def_mode = $mode;
	650	+ // class/object method callback
	651	+ if (is_callable($options)) {
	652	+ $def_options = $options;
	653	+ } else {
	654	+ trigger_error("invalid error callback", E_USER_WARNING);
	655	+ }
	656	+ break;
	657	+
	658	+ default:
	659	+ trigger_error("invalid error mode", E_USER_WARNING);
	660	+ break;
	661	+ }
	662	+ $stack[] = [$mode, $options];
	663	+
	664	+ return true;
	665	+ }
	666	+
	667	+ public static function staticPopErrorHandling()
	668	+ {
	669	+ $stack = &$GLOBALS['_PEAR_error_handler_stack'];
	670	+ $setmode = &$GLOBALS['_PEAR_default_error_mode'];
	671	+ $setoptions = &$GLOBALS['_PEAR_default_error_options'];
	672	+ array_pop($stack);
	673	+ [$mode, $options] = $stack[sizeof($stack) - 1];
	674	+ array_pop($stack);
	675	+ switch ($mode) {
	676	+ case PEAR_ERROR_EXCEPTION:
	677	+ case PEAR_ERROR_RETURN:
	678	+ case PEAR_ERROR_PRINT:
	679	+ case PEAR_ERROR_TRIGGER:
	680	+ case PEAR_ERROR_DIE:
	681	+ case null:
	682	+ $setmode = $mode;
	683	+ $setoptions = $options;
	684	+ break;
	685	+
	686	+ case PEAR_ERROR_CALLBACK:
	687	+ $setmode = $mode;
	688	+ // class/object method callback
	689	+ if (is_callable($options)) {
	690	+ $setoptions = $options;
	691	+ } else {
	692	+ trigger_error("invalid error callback", E_USER_WARNING);
	693	+ }
	694	+ break;
	695	+
	696	+ default:
	697	+ trigger_error("invalid error mode", E_USER_WARNING);
	698	+ break;
	699	+ }
	700	+
	701	+ return true;
	702	+ }
	703	+
	704	+ /**
	705	+ * Push a new error handler on top of the error handler options stack. With this
	706	+ * you can easily override the actual error handler for some code and restore
	707	+ * it later with popErrorHandling.
	708	+ *
	709	+ * @param mixed $mode (same as setErrorHandling)
	710	+ * @param mixed $options (same as setErrorHandling)
	711	+ *
	712	+ * @return bool Always true
	713	+ *
	714	+ * @see PEAR::setErrorHandling
	715	+ */
	716	+ protected static function _pushErrorHandling($object, $mode, $options = null)
	717	+ {
	718	+ $stack = &$GLOBALS['_PEAR_error_handler_stack'];
	719	+ if ($object !== null) {
	720	+ $def_mode = &$object->_default_error_mode;
	721	+ $def_options = &$object->_default_error_options;
	722	+ } else {
	723	+ $def_mode = &$GLOBALS['_PEAR_default_error_mode'];
	724	+ $def_options = &$GLOBALS['_PEAR_default_error_options'];
	725	+ }
	726	+ $stack[] = [$def_mode, $def_options];
	727	+
	728	+ if ($object !== null) {
	729	+ $object->setErrorHandling($mode, $options);
	730	+ } else {
	731	+ PEAR::setErrorHandling($mode, $options);
	732	+ }
	733	+ $stack[] = [$mode, $options];
	734	+
	735	+ return true;
	736	+ }
	737	+
	738	+ /**
	739	+ * Pop the last error handler used
	740	+ *
	741	+ * @return bool Always true
	742	+ *
	743	+ * @see PEAR::pushErrorHandling
	744	+ */
	745	+ protected static function _popErrorHandling($object)
	746	+ {
	747	+ $stack = &$GLOBALS['_PEAR_error_handler_stack'];
	748	+ array_pop($stack);
	749	+ [$mode, $options] = $stack[sizeof($stack) - 1];
	750	+ array_pop($stack);
	751	+ if ($object !== null) {
	752	+ $object->setErrorHandling($mode, $options);
	753	+ } else {
	754	+ PEAR::setErrorHandling($mode, $options);
	755	+ }
	756	+
	757	+ return true;
	758	+ }
	759	+
	760	+ /**
	761	+ * OS independent PHP extension load. Remember to take care
	762	+ * on the correct extension name for case sensitive OSes.
	763	+ *
	764	+ * @param string $ext The extension name
	765	+ *
	766	+ * @return bool Success or not on the dl() call
	767	+ */
	768	+ public static function loadExtension($ext)
	769	+ {
	770	+ if (extension_loaded($ext)) {
	771	+ return true;
	772	+ }
	773	+
	774	+ // if either returns true dl() will produce a FATAL error, stop that
	775	+ if (
	776	+ function_exists('dl') === false ||
	777	+ ini_get('enable_dl') != 1
	778	+ ) {
	779	+ return false;
	780	+ }
	781	+
	782	+ if (OS_WINDOWS) {
	783	+ $suffix = '.dll';
	784	+ } elseif (PHP_OS == 'HP-UX') {
	785	+ $suffix = '.sl';
	786	+ } elseif (PHP_OS == 'AIX') {
	787	+ $suffix = '.a';
	788	+ } elseif (PHP_OS == 'OSX') {
	789	+ $suffix = '.bundle';
	790	+ } else {
	791	+ $suffix = '.so';
	792	+ }
	793	+
	794	+ return @dl('php_'.$ext.$suffix) || @dl($ext.$suffix);
	795	+ }
	796	+
	797	+ /**
	798	+ * Get SOURCE_DATE_EPOCH environment variable
	799	+ * See https://reproducible-builds.org/specs/source-date-epoch/
	800	+ *
	801	+ * @return int
	802	+ * @access public
	803	+ */
	804	+ static function getSourceDateEpoch()
	805	+ {
	806	+ if ($source_date_epoch = getenv('SOURCE_DATE_EPOCH')) {
	807	+ if (preg_match('/^\d+$/', $source_date_epoch)) {
	808	+ return (int)$source_date_epoch;
	809	+ } else {
	810	+ // "If the value is malformed, the build process SHOULD exit with a non-zero error code."
	811	+ self::raiseError("Invalid SOURCE_DATE_EPOCH: $source_date_epoch");
	812	+ exit(1);
	813	+ }
	814	+ } else {
	815	+ return time();
	816	+ }
	817	+ }
	818	+}
	819	+
	820	+function _PEAR_call_destructors()
	821	+{
	822	+ global $_PEAR_destructor_object_list;
	823	+ if (is_array($_PEAR_destructor_object_list) &&
	824	+ sizeof($_PEAR_destructor_object_list)) {
	825	+ reset($_PEAR_destructor_object_list);
	826	+
	827	+ $destructLifoExists = PEAR::getStaticProperty('PEAR', 'destructlifo');
	828	+
	829	+ if ($destructLifoExists) {
	830	+ $_PEAR_destructor_object_list = array_reverse($_PEAR_destructor_object_list);
	831	+ }
	832	+
	833	+ foreach ($_PEAR_destructor_object_list as $k => $objref) {
	834	+ $classname = get_class($objref);
	835	+ while ($classname) {
	836	+ $destructor = "_$classname";
	837	+ if (method_exists($objref, $destructor)) {
	838	+ $objref->$destructor();
	839	+ break;
	840	+ } else {
	841	+ $classname = get_parent_class($classname);
	842	+ }
	843	+ }
	844	+ }
	845	+ // Empty the object list to ensure that destructors are
	846	+ // not called more than once.
	847	+ $_PEAR_destructor_object_list = [];
	848	+ }
	849	+
	850	+ // Now call the shutdown functions
	851	+ if (
	852	+ isset($GLOBALS['_PEAR_shutdown_funcs']) &&
	853	+ is_array($GLOBALS['_PEAR_shutdown_funcs']) &&
	854	+ !empty($GLOBALS['_PEAR_shutdown_funcs'])
	855	+ ) {
	856	+ foreach ($GLOBALS['_PEAR_shutdown_funcs'] as $value) {
	857	+ call_user_func_array($value[0], $value[1]);
	858	+ }
	859	+ }
	860	+}
	861	+
	862	+
	863	+/*
	864	+ * Local Variables:
	865	+ * mode: php
	866	+ * tab-width: 4
	867	+ * c-basic-offset: 4
	868	+ * End:
	869	+ */