tiki  21.2
About: Tiki Wiki is a Groupware/CMS (Content Management System) solution that has features like Wikis, Forums, Blogs, Articles, Image Gallery, Map Server, Link Directory, Multilingual Support, Bug Tracker, RSS Feeds etc. Latest release 21 with Long Term Support (LTS).
  Fossies Dox: tiki-21.2.tar.xz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

PEAR.php
Go to the documentation of this file.
1 <?php
24 define('PEAR_ERROR_RETURN', 1);
25 define('PEAR_ERROR_PRINT', 2);
26 define('PEAR_ERROR_TRIGGER', 4);
27 define('PEAR_ERROR_DIE', 8);
28 define('PEAR_ERROR_CALLBACK', 16);
33 define('PEAR_ERROR_EXCEPTION', 32);
36 if (substr(PHP_OS, 0, 3) == 'WIN') {
37  define('OS_WINDOWS', true);
38  define('OS_UNIX', false);
39  define('PEAR_OS', 'Windows');
40 } else {
41  define('OS_WINDOWS', false);
42  define('OS_UNIX', true);
43  define('PEAR_OS', 'Unix'); // blatant assumption
44 }
45 
46 $GLOBALS['_PEAR_default_error_mode'] = PEAR_ERROR_RETURN;
47 $GLOBALS['_PEAR_default_error_options'] = E_USER_NOTICE;
48 $GLOBALS['_PEAR_destructor_object_list'] = array();
49 $GLOBALS['_PEAR_shutdown_funcs'] = array();
50 $GLOBALS['_PEAR_error_handler_stack'] = array();
51 
52 @ini_set('track_errors', true);
53 
84 class PEAR
85 {
92  var $_debug = false;
93 
101 
110 
119 
126  var $_error_class = 'PEAR_Error';
127 
134  var $_expected_errors = array();
135 
140  protected static $bivalentMethods = array(
141  'setErrorHandling' => true,
142  'raiseError' => true,
143  'throwError' => true,
144  'pushErrorHandling' => true,
145  'popErrorHandling' => true,
146  );
147 
158  function __construct($error_class = null)
159  {
160  $classname = strtolower(get_class($this));
161  if ($this->_debug) {
162  print "PEAR constructor called, class=$classname\n";
163  }
164 
165  if ($error_class !== null) {
166  $this->_error_class = $error_class;
167  }
168 
169  while ($classname && strcasecmp($classname, "pear")) {
170  $destructor = "_$classname";
171  if (method_exists($this, $destructor)) {
172  global $_PEAR_destructor_object_list;
173  $_PEAR_destructor_object_list[] = $this;
174  if (!isset($GLOBALS['_PEAR_SHUTDOWN_REGISTERED'])) {
175  register_shutdown_function("_PEAR_call_destructors");
176  $GLOBALS['_PEAR_SHUTDOWN_REGISTERED'] = true;
177  }
178  break;
179  } else {
180  $classname = get_parent_class($classname);
181  }
182  }
183  }
184 
192  public function PEAR($error_class = null)
193  {
194  self::__construct($error_class);
195  }
196 
208  function _PEAR() {
209  if ($this->_debug) {
210  printf("PEAR destructor called, class=%s\n", strtolower(get_class($this)));
211  }
212  }
213 
214  public function __call($method, $arguments)
215  {
216  if (!isset(self::$bivalentMethods[$method])) {
217  trigger_error(
218  'Call to undefined method PEAR::' . $method . '()', E_USER_ERROR
219  );
220  }
221  return call_user_func_array(
222  array(get_class(), '_' . $method),
223  array_merge(array($this), $arguments)
224  );
225  }
226 
227  public static function __callStatic($method, $arguments)
228  {
229  if (!isset(self::$bivalentMethods[$method])) {
230  trigger_error(
231  'Call to undefined method PEAR::' . $method . '()', E_USER_ERROR
232  );
233  }
234  return call_user_func_array(
235  array(get_class(), '_' . $method),
236  array_merge(array(null), $arguments)
237  );
238  }
239 
251  public static function &getStaticProperty($class, $var)
252  {
253  static $properties;
254  if (!isset($properties[$class])) {
255  $properties[$class] = array();
256  }
257 
258  if (!array_key_exists($var, $properties[$class])) {
259  $properties[$class][$var] = null;
260  }
261 
262  return $properties[$class][$var];
263  }
264 
274  public static function registerShutdownFunc($func, $args = array())
275  {
276  // if we are called statically, there is a potential
277  // that no shutdown func is registered. Bug #6445
278  if (!isset($GLOBALS['_PEAR_SHUTDOWN_REGISTERED'])) {
279  register_shutdown_function("_PEAR_call_destructors");
280  $GLOBALS['_PEAR_SHUTDOWN_REGISTERED'] = true;
281  }
282  $GLOBALS['_PEAR_shutdown_funcs'][] = array($func, $args);
283  }
284 
296  public static function isError($data, $code = null)
297  {
298  if (!is_a($data, 'PEAR_Error')) {
299  return false;
300  }
301 
302  if (is_null($code)) {
303  return true;
304  } elseif (is_string($code)) {
305  return $data->getMessage() == $code;
306  }
307 
308  return $data->getCode() == $code;
309  }
310 
352  protected static function _setErrorHandling(
353  $object, $mode = null, $options = null
354  ) {
355  if ($object !== null) {
356  $setmode = &$object->_default_error_mode;
357  $setoptions = &$object->_default_error_options;
358  } else {
359  $setmode = &$GLOBALS['_PEAR_default_error_mode'];
360  $setoptions = &$GLOBALS['_PEAR_default_error_options'];
361  }
362 
363  switch ($mode) {
365  case PEAR_ERROR_RETURN:
366  case PEAR_ERROR_PRINT:
367  case PEAR_ERROR_TRIGGER:
368  case PEAR_ERROR_DIE:
369  case null:
370  $setmode = $mode;
371  $setoptions = $options;
372  break;
373 
374  case PEAR_ERROR_CALLBACK:
375  $setmode = $mode;
376  // class/object method callback
377  if (is_callable($options)) {
378  $setoptions = $options;
379  } else {
380  trigger_error("invalid error callback", E_USER_WARNING);
381  }
382  break;
383 
384  default:
385  trigger_error("invalid error mode", E_USER_WARNING);
386  break;
387  }
388  }
389 
405  function expectError($code = '*')
406  {
407  if (is_array($code)) {
408  array_push($this->_expected_errors, $code);
409  } else {
410  array_push($this->_expected_errors, array($code));
411  }
412  return count($this->_expected_errors);
413  }
414 
421  function popExpect()
422  {
423  return array_pop($this->_expected_errors);
424  }
425 
434  function _checkDelExpect($error_code)
435  {
436  $deleted = false;
437  foreach ($this->_expected_errors as $key => $error_array) {
438  if (in_array($error_code, $error_array)) {
439  unset($this->_expected_errors[$key][array_search($error_code, $error_array)]);
440  $deleted = true;
441  }
442 
443  // clean up empty arrays
444  if (0 == count($this->_expected_errors[$key])) {
445  unset($this->_expected_errors[$key]);
446  }
447  }
448 
449  return $deleted;
450  }
451 
461  function delExpect($error_code)
462  {
463  $deleted = false;
464  if ((is_array($error_code) && (0 != count($error_code)))) {
465  // $error_code is a non-empty array here; we walk through it trying
466  // to unset all values
467  foreach ($error_code as $key => $error) {
468  $deleted = $this->_checkDelExpect($error) ? true : false;
469  }
470 
471  return $deleted ? true : PEAR::raiseError("The expected error you submitted does not exist"); // IMPROVE ME
472  } elseif (!empty($error_code)) {
473  // $error_code comes alone, trying to unset it
474  if ($this->_checkDelExpect($error_code)) {
475  return true;
476  }
477 
478  return PEAR::raiseError("The expected error you submitted does not exist"); // IMPROVE ME
479  }
480 
481  // $error_code is empty
482  return PEAR::raiseError("The expected error you submitted is empty"); // IMPROVE ME
483  }
484 
521  protected static function _raiseError($object,
522  $message = null,
523  $code = null,
524  $mode = null,
525  $options = null,
526  $userinfo = null,
527  $error_class = null,
528  $skipmsg = false)
529  {
530  // The error is yet a PEAR error object
531  if (is_object($message)) {
532  $code = $message->getCode();
533  $userinfo = $message->getUserInfo();
534  $error_class = $message->getType();
535  $message->error_message_prefix = '';
536  $message = $message->getMessage();
537  }
538 
539  if (
540  $object !== null &&
541  isset($object->_expected_errors) &&
542  count($object->_expected_errors) > 0 &&
543  count($exp = end($object->_expected_errors))
544  ) {
545  if ($exp[0] === "*" ||
546  (is_int(reset($exp)) && in_array($code, $exp)) ||
547  (is_string(reset($exp)) && in_array($message, $exp))
548  ) {
550  }
551  }
552 
553  // No mode given, try global ones
554  if ($mode === null) {
555  // Class error handler
556  if ($object !== null && isset($object->_default_error_mode)) {
557  $mode = $object->_default_error_mode;
558  $options = $object->_default_error_options;
559  // Global error handler
560  } elseif (isset($GLOBALS['_PEAR_default_error_mode'])) {
561  $mode = $GLOBALS['_PEAR_default_error_mode'];
562  $options = $GLOBALS['_PEAR_default_error_options'];
563  }
564  }
565 
566  if ($error_class !== null) {
567  $ec = $error_class;
568  } elseif ($object !== null && isset($object->_error_class)) {
569  $ec = $object->_error_class;
570  } else {
571  $ec = 'PEAR_Error';
572  }
573 
574  if ($skipmsg) {
575  $a = new $ec($code, $mode, $options, $userinfo);
576  } else {
577  $a = new $ec($message, $code, $mode, $options, $userinfo);
578  }
579 
580  return $a;
581  }
582 
598  protected static function _throwError($object, $message = null, $code = null, $userinfo = null)
599  {
600  if ($object !== null) {
601  $a = $object->raiseError($message, $code, null, null, $userinfo);
602  return $a;
603  }
604 
605  $a = PEAR::raiseError($message, $code, null, null, $userinfo);
606  return $a;
607  }
608 
609  public static function staticPushErrorHandling($mode, $options = null)
610  {
611  $stack = &$GLOBALS['_PEAR_error_handler_stack'];
612  $def_mode = &$GLOBALS['_PEAR_default_error_mode'];
613  $def_options = &$GLOBALS['_PEAR_default_error_options'];
614  $stack[] = array($def_mode, $def_options);
615  switch ($mode) {
617  case PEAR_ERROR_RETURN:
618  case PEAR_ERROR_PRINT:
619  case PEAR_ERROR_TRIGGER:
620  case PEAR_ERROR_DIE:
621  case null:
622  $def_mode = $mode;
623  $def_options = $options;
624  break;
625 
626  case PEAR_ERROR_CALLBACK:
627  $def_mode = $mode;
628  // class/object method callback
629  if (is_callable($options)) {
630  $def_options = $options;
631  } else {
632  trigger_error("invalid error callback", E_USER_WARNING);
633  }
634  break;
635 
636  default:
637  trigger_error("invalid error mode", E_USER_WARNING);
638  break;
639  }
640  $stack[] = array($mode, $options);
641  return true;
642  }
643 
644  public static function staticPopErrorHandling()
645  {
646  $stack = &$GLOBALS['_PEAR_error_handler_stack'];
647  $setmode = &$GLOBALS['_PEAR_default_error_mode'];
648  $setoptions = &$GLOBALS['_PEAR_default_error_options'];
649  array_pop($stack);
650  list($mode, $options) = $stack[sizeof($stack) - 1];
651  array_pop($stack);
652  switch ($mode) {
654  case PEAR_ERROR_RETURN:
655  case PEAR_ERROR_PRINT:
656  case PEAR_ERROR_TRIGGER:
657  case PEAR_ERROR_DIE:
658  case null:
659  $setmode = $mode;
660  $setoptions = $options;
661  break;
662 
663  case PEAR_ERROR_CALLBACK:
664  $setmode = $mode;
665  // class/object method callback
666  if (is_callable($options)) {
667  $setoptions = $options;
668  } else {
669  trigger_error("invalid error callback", E_USER_WARNING);
670  }
671  break;
672 
673  default:
674  trigger_error("invalid error mode", E_USER_WARNING);
675  break;
676  }
677  return true;
678  }
679 
692  protected static function _pushErrorHandling($object, $mode, $options = null)
693  {
694  $stack = &$GLOBALS['_PEAR_error_handler_stack'];
695  if ($object !== null) {
696  $def_mode = &$object->_default_error_mode;
697  $def_options = &$object->_default_error_options;
698  } else {
699  $def_mode = &$GLOBALS['_PEAR_default_error_mode'];
700  $def_options = &$GLOBALS['_PEAR_default_error_options'];
701  }
702  $stack[] = array($def_mode, $def_options);
703 
704  if ($object !== null) {
705  $object->setErrorHandling($mode, $options);
706  } else {
707  PEAR::setErrorHandling($mode, $options);
708  }
709  $stack[] = array($mode, $options);
710  return true;
711  }
712 
720  protected static function _popErrorHandling($object)
721  {
722  $stack = &$GLOBALS['_PEAR_error_handler_stack'];
723  array_pop($stack);
724  list($mode, $options) = $stack[sizeof($stack) - 1];
725  array_pop($stack);
726  if ($object !== null) {
727  $object->setErrorHandling($mode, $options);
728  } else {
729  PEAR::setErrorHandling($mode, $options);
730  }
731  return true;
732  }
733 
741  public static function loadExtension($ext)
742  {
743  if (extension_loaded($ext)) {
744  return true;
745  }
746 
747  // if either returns true dl() will produce a FATAL error, stop that
748  if (
749  function_exists('dl') === false ||
750  ini_get('enable_dl') != 1
751  ) {
752  return false;
753  }
754 
755  if (OS_WINDOWS) {
756  $suffix = '.dll';
757  } elseif (PHP_OS == 'HP-UX') {
758  $suffix = '.sl';
759  } elseif (PHP_OS == 'AIX') {
760  $suffix = '.a';
761  } elseif (PHP_OS == 'OSX') {
762  $suffix = '.bundle';
763  } else {
764  $suffix = '.so';
765  }
766 
767  return @dl('php_'.$ext.$suffix) || @dl($ext.$suffix);
768  }
769 
777  static function getSourceDateEpoch()
778  {
779  if ($source_date_epoch = getenv('SOURCE_DATE_EPOCH')) {
780  if (preg_match('/^\d+$/', $source_date_epoch)) {
781  return (int) $source_date_epoch;
782  } else {
783  // "If the value is malformed, the build process SHOULD exit with a non-zero error code."
784  self::raiseError("Invalid SOURCE_DATE_EPOCH: $source_date_epoch");
785  exit(1);
786  }
787  } else {
788  return time();
789  }
790  }
791 }
792 
794 {
795  global $_PEAR_destructor_object_list;
796  if (is_array($_PEAR_destructor_object_list) &&
797  sizeof($_PEAR_destructor_object_list))
798  {
799  reset($_PEAR_destructor_object_list);
800 
801  $destructLifoExists = PEAR::getStaticProperty('PEAR', 'destructlifo');
802 
803  if ($destructLifoExists) {
804  $_PEAR_destructor_object_list = array_reverse($_PEAR_destructor_object_list);
805  }
806 
807  foreach ($_PEAR_destructor_object_list as $k => $objref) {
808  $classname = get_class($objref);
809  while ($classname) {
810  $destructor = "_$classname";
811  if (method_exists($objref, $destructor)) {
812  $objref->$destructor();
813  break;
814  } else {
815  $classname = get_parent_class($classname);
816  }
817  }
818  }
819  // Empty the object list to ensure that destructors are
820  // not called more than once.
821  $_PEAR_destructor_object_list = array();
822  }
823 
824  // Now call the shutdown functions
825  if (
826  isset($GLOBALS['_PEAR_shutdown_funcs']) &&
827  is_array($GLOBALS['_PEAR_shutdown_funcs']) &&
828  !empty($GLOBALS['_PEAR_shutdown_funcs'])
829  ) {
830  foreach ($GLOBALS['_PEAR_shutdown_funcs'] as $value) {
831  call_user_func_array($value[0], $value[1]);
832  }
833  }
834 }
835 
854 {
857  var $level = E_USER_NOTICE;
858  var $code = -1;
859  var $message = '';
860  var $userinfo = '';
861  var $backtrace = null;
862 
883  function __construct($message = 'unknown error', $code = null,
884  $mode = null, $options = null, $userinfo = null)
885  {
886  if ($mode === null) {
888  }
889  $this->message = $message;
890  $this->code = $code;
891  $this->mode = $mode;
892  $this->userinfo = $userinfo;
893 
894  $skiptrace = PEAR::getStaticProperty('PEAR_Error', 'skiptrace');
895 
896  if (!$skiptrace) {
897  $this->backtrace = debug_backtrace();
898  if (isset($this->backtrace[0]) && isset($this->backtrace[0]['object'])) {
899  unset($this->backtrace[0]['object']);
900  }
901  }
902 
903  if ($mode & PEAR_ERROR_CALLBACK) {
904  $this->level = E_USER_NOTICE;
905  $this->callback = $options;
906  } else {
907  if ($options === null) {
908  $options = E_USER_NOTICE;
909  }
910 
911  $this->level = $options;
912  $this->callback = null;
913  }
914 
915  if ($this->mode & PEAR_ERROR_PRINT) {
916  if (is_null($options) || is_int($options)) {
917  $format = "%s";
918  } else {
919  $format = $options;
920  }
921 
922  printf($format, $this->getMessage());
923  }
924 
925  if ($this->mode & PEAR_ERROR_TRIGGER) {
926  trigger_error($this->getMessage(), $this->level);
927  }
928 
929  if ($this->mode & PEAR_ERROR_DIE) {
930  $msg = $this->getMessage();
931  if (is_null($options) || is_int($options)) {
932  $format = "%s";
933  if (substr($msg, -1) != "\n") {
934  $msg .= "\n";
935  }
936  } else {
937  $format = $options;
938  }
939  printf($format, $msg);
940  exit($code);
941  }
942 
943  if ($this->mode & PEAR_ERROR_CALLBACK && is_callable($this->callback)) {
944  call_user_func($this->callback, $this);
945  }
946 
947  if ($this->mode & PEAR_ERROR_EXCEPTION) {
948  trigger_error("PEAR_ERROR_EXCEPTION is obsolete, use class PEAR_Exception for exceptions", E_USER_WARNING);
949  eval('$e = new Exception($this->message, $this->code);throw($e);');
950  }
951  }
952 
964  public function PEAR_Error(
965  $message = 'unknown error', $code = null, $mode = null,
966  $options = null, $userinfo = null
967  ) {
969  }
970 
977  function getMode()
978  {
979  return $this->mode;
980  }
981 
988  function getCallback()
989  {
990  return $this->callback;
991  }
992 
999  function getMessage()
1000  {
1001  return ($this->error_message_prefix . $this->message);
1002  }
1003 
1010  function getCode()
1011  {
1012  return $this->code;
1013  }
1014 
1021  function getType()
1022  {
1023  return get_class($this);
1024  }
1025 
1032  function getUserInfo()
1033  {
1034  return $this->userinfo;
1035  }
1036 
1043  function getDebugInfo()
1044  {
1045  return $this->getUserInfo();
1046  }
1047 
1056  function getBacktrace($frame = null)
1057  {
1058  if (defined('PEAR_IGNORE_BACKTRACE')) {
1059  return null;
1060  }
1061  if ($frame === null) {
1062  return $this->backtrace;
1063  }
1064  return $this->backtrace[$frame];
1065  }
1066 
1067  function addUserInfo($info)
1068  {
1069  if (empty($this->userinfo)) {
1070  $this->userinfo = $info;
1071  } else {
1072  $this->userinfo .= " ** $info";
1073  }
1074  }
1075 
1076  function __toString()
1077  {
1078  return $this->getMessage();
1079  }
1080 
1087  function toString()
1088  {
1089  $modes = array();
1090  $levels = array(E_USER_NOTICE => 'notice',
1091  E_USER_WARNING => 'warning',
1092  E_USER_ERROR => 'error');
1093  if ($this->mode & PEAR_ERROR_CALLBACK) {
1094  if (is_array($this->callback)) {
1095  $callback = (is_object($this->callback[0]) ?
1096  strtolower(get_class($this->callback[0])) :
1097  $this->callback[0]) . '::' .
1098  $this->callback[1];
1099  } else {
1100  $callback = $this->callback;
1101  }
1102  return sprintf('[%s: message="%s" code=%d mode=callback '.
1103  'callback=%s prefix="%s" info="%s"]',
1104  strtolower(get_class($this)), $this->message, $this->code,
1105  $callback, $this->error_message_prefix,
1106  $this->userinfo);
1107  }
1108  if ($this->mode & PEAR_ERROR_PRINT) {
1109  $modes[] = 'print';
1110  }
1111  if ($this->mode & PEAR_ERROR_TRIGGER) {
1112  $modes[] = 'trigger';
1113  }
1114  if ($this->mode & PEAR_ERROR_DIE) {
1115  $modes[] = 'die';
1116  }
1117  if ($this->mode & PEAR_ERROR_RETURN) {
1118  $modes[] = 'return';
1119  }
1120  return sprintf('[%s: message="%s" code=%d mode=%s level=%s '.
1121  'prefix="%s" info="%s"]',
1122  strtolower(get_class($this)), $this->message, $this->code,
1123  implode("|", $modes), $levels[$this->level],
1124  $this->error_message_prefix,
1125  $this->userinfo);
1126  }
1127 }
1128 
1129 /*
1130  * Local Variables:
1131  * mode: php
1132  * tab-width: 4
1133  * c-basic-offset: 4
1134  * End:
1135  */
PEAR_Error\$userinfo
$userinfo
Definition: PEAR.php:860
PEAR\PEAR
PEAR($error_class=null)
Definition: PEAR.php:192
PEAR\getSourceDateEpoch
static getSourceDateEpoch()
Definition: PEAR.php:777
PEAR
PEAR\registerShutdownFunc
static registerShutdownFunc($func, $args=array())
Definition: PEAR.php:274
PEAR\_pushErrorHandling
static _pushErrorHandling($object, $mode, $options=null)
Definition: PEAR.php:692
PEAR\_PEAR
_PEAR()
Definition: PEAR.php:208
PEAR_Error\getMessage
getMessage()
Definition: PEAR.php:999
PEAR\$_default_error_handler
$_default_error_handler
Definition: PEAR.php:118
PEAR_Error\$level
$level
Definition: PEAR.php:857
PEAR\popExpect
popExpect()
Definition: PEAR.php:421
PEAR_Error\$error_message_prefix
$error_message_prefix
Definition: PEAR.php:855
PEAR_Error\addUserInfo
addUserInfo($info)
Definition: PEAR.php:1067
$code
$code
Definition: tiki-admin_integrator_rules.php:28
PEAR_ERROR_EXCEPTION
const PEAR_ERROR_EXCEPTION
Definition: PEAR.php:33
PEAR\expectError
expectError($code=' *')
Definition: PEAR.php:405
PEAR_Error\__toString
__toString()
Definition: PEAR.php:1076
elseif
if(isset($_GET['msg'])) elseif(isset( $_SESSION[ 'msg']))
Definition: tiki-setup.php:370
php
$data
$data
Definition: banner_image.php:47
PEAR\staticPopErrorHandling
static staticPopErrorHandling()
Definition: PEAR.php:644
PEAR_Error\PEAR_Error
PEAR_Error( $message='unknown error', $code=null, $mode=null, $options=null, $userinfo=null)
Definition: PEAR.php:964
PEAR\isError
static isError($data, $code=null)
Definition: PEAR.php:296
_PEAR_call_destructors
_PEAR_call_destructors()
Definition: PEAR.php:793
$msg
$msg
Definition: messu-read.php:58
PEAR_Error\getCallback
getCallback()
Definition: PEAR.php:988
$info
if(strpos($_SERVER['SCRIPT_NAME'], basename(__FILE__)) !=false) global $info
Definition: editmode.php:12
PEAR_Error\getUserInfo
getUserInfo()
Definition: PEAR.php:1032
PEAR_Error\__construct
__construct($message='unknown error', $code=null, $mode=null, $options=null, $userinfo=null)
Definition: PEAR.php:883
$error
$error
Definition: tiki-download_file.php:51
PEAR_Error\getType
getType()
Definition: PEAR.php:1021
PEAR\getStaticProperty
static & getStaticProperty($class, $var)
Definition: PEAR.php:251
PEAR\_raiseError
static _raiseError($object, $message=null, $code=null, $mode=null, $options=null, $userinfo=null, $error_class=null, $skipmsg=false)
Definition: PEAR.php:521
PEAR_ERROR_PRINT
const PEAR_ERROR_PRINT
Definition: PEAR.php:25
PEAR_Error\$backtrace
$backtrace
Definition: PEAR.php:861
PEAR_Error\getBacktrace
getBacktrace($frame=null)
Definition: PEAR.php:1056
PEAR\_throwError
static _throwError($object, $message=null, $code=null, $userinfo=null)
Definition: PEAR.php:598
exit
exit
Definition: reindex_file.php:61
PEAR\$bivalentMethods
static $bivalentMethods
Definition: PEAR.php:140
PEAR\__call
__call($method, $arguments)
Definition: PEAR.php:214
PEAR\__construct
__construct($error_class=null)
Definition: PEAR.php:158
PEAR\$_error_class
$_error_class
Definition: PEAR.php:126
$options
$options
Definition: get_strings.php:50
PEAR\loadExtension
static loadExtension($ext)
Definition: PEAR.php:741
PEAR_Error\getDebugInfo
getDebugInfo()
Definition: PEAR.php:1043
PEAR\$_debug
$_debug
Definition: PEAR.php:92
PEAR_Error\getCode
getCode()
Definition: PEAR.php:1010
PEAR\_checkDelExpect
_checkDelExpect($error_code)
Definition: PEAR.php:434
PEAR\$_default_error_options
$_default_error_options
Definition: PEAR.php:109
$args
$args
Definition: texttest.php:53
$GLOBALS
$GLOBALS['_PEAR_default_error_mode']
Definition: PEAR.php:46
$a
$a
Definition: auth_adodb_example.php:19
PEAR_Error\$code
$code
Definition: PEAR.php:858
PEAR_Error\$mode
$mode
Definition: PEAR.php:856
PEAR_ERROR_CALLBACK
const PEAR_ERROR_CALLBACK
Definition: PEAR.php:28
PEAR\__callStatic
static __callStatic($method, $arguments)
Definition: PEAR.php:227
PEAR_Error\toString
toString()
Definition: PEAR.php:1087
PEAR_Error
Definition: PEAR.php:854
$stack
$stack
Definition: ErrorStack.php:977
PEAR_ERROR_DIE
const PEAR_ERROR_DIE
Definition: PEAR.php:27
$suffix
$suffix
Definition: filesave.php:31
PEAR_ERROR_TRIGGER
const PEAR_ERROR_TRIGGER
Definition: PEAR.php:26
$userinfo
$userinfo['registrationDate']
Definition: tiki-adminusers.php:567
PEAR_ERROR_RETURN
const PEAR_ERROR_RETURN
Definition: PEAR.php:24
PEAR\_popErrorHandling
static _popErrorHandling($object)
Definition: PEAR.php:720
PEAR_Error\$message
$message
Definition: PEAR.php:859
PEAR\staticPushErrorHandling
static staticPushErrorHandling($mode, $options=null)
Definition: PEAR.php:609
E_USER_ERROR
if(!defined('ADODB_ERROR_HANDLER_TYPE')) define('ADODB_ERROR_HANDLER_TYPE' E_USER_ERROR
Definition: adodb-errorhandler.inc.php:18
PEAR\$_expected_errors
$_expected_errors
Definition: PEAR.php:134
PEAR\$_default_error_mode
$_default_error_mode
Definition: PEAR.php:100
PEAR_Error\getMode
getMode()
Definition: PEAR.php:977
$mode
if(! empty($_REQUEST['mixId'])) if(! empty($_REQUEST['mediaId'])) $mode
Definition: tiki-kaltura_video.php:36
PEAR\delExpect
delExpect($error_code)
Definition: PEAR.php:461
PEAR\_setErrorHandling
static _setErrorHandling( $object, $mode=null, $options=null)
Definition: PEAR.php:352