Source for file error.php

Documentation is available at error.php

  1. <?php
  2. /**
  3.  * @package     Joomla.Legacy
  4.  * @subpackage  Error
  5.  *
  6.  * @copyright   Copyright (C) 2005 - 2013 Open Source Matters, Inc. All rights reserved.
  7.  * @license     GNU General Public License version 2 or later; see LICENSE
  8.  */
  9.  
  10. defined('JPATH_PLATFORM') or die;
  11.  
  12. // Error Definition: Illegal Options
  13. const JERROR_ILLEGAL_OPTIONS = 1;
  14.  
  15. // Error Definition: Callback does not exist
  16. const JERROR_CALLBACK_NOT_CALLABLE = 2;
  17.  
  18. // Error Definition: Illegal Handler
  19. const JERROR_ILLEGAL_MODE = 3;
  20.  
  21. /**
  22.  * Error Handling Class
  23.  *
  24.  * This class is inspired in design and concept by patErrorManager <http://www.php-tools.net>
  25.  *
  26.  * patErrorManager contributors include:
  27.  * - gERD Schaufelberger    <gerd@php-tools.net>
  28.  * - Sebastian Mordziol    <argh@php-tools.net>
  29.  * - Stephan Schmidt        <scst@php-tools.net>
  30.  *
  31.  * @package     Joomla.Legacy
  32.  * @subpackage  Error
  33.  * @since       11.1
  34.  * @deprecated  12.1 (Platform) & 4.0 (CMS) - Use PHP Exception
  35.  */
  36. abstract class JError
  37. {
  38.     /**
  39.      * Legacy error handling marker
  40.      *
  41.      * @var    boolean  True to enable legacy error handling using JError, false to use exception handling.  This flag
  42.      *                   is present to allow an easy transition into exception handling for code written against the
  43.      *                   existing JError API in Joomla.
  44.      * @since  11.1
  45.      */
  46.     public static $legacy = false;
  47.  
  48.     /**
  49.      * Array of message levels
  50.      *
  51.      * @var    array 
  52.      * @since  11.1
  53.      */
  54.     protected static $levels = array(E_NOTICE => 'Notice', E_WARNING => 'Warning', E_ERROR => 'Error');
  55.  
  56.     /**
  57.      * Array of message handlers
  58.      * @var    array 
  59.      * @since  11.1
  60.      */
  61.     protected static $handlers = array(
  62.         E_NOTICE => array('mode' => 'ignore'),
  63.         E_WARNING => array('mode' => 'ignore'),
  64.         E_ERROR => array('mode' => 'ignore')
  65.     );
  66.  
  67.     /**
  68.      * Array containing the error stack
  69.      *
  70.      * @var    array 
  71.      * @since  11.1
  72.      */
  73.     protected static $stack = array();
  74.  
  75.     /**
  76.      * Method to determine if a value is an exception object.
  77.      *
  78.      * @param   mixed  $object  Object to check.
  79.      *
  80.      * @return  boolean  True if argument is an exception, false otherwise.
  81.      *
  82.      * @deprecated  12.1
  83.      * @since   11.1
  84.      */
  85.     public static function isError($object)
  86.     {
  87.         JLog::add('JError::isError() is deprecated.', JLog::WARNING, 'deprecated');
  88.  
  89.         return $object instanceof Exception;
  90.     }
  91.  
  92.     /**
  93.      * Method for retrieving the last exception object in the error stack
  94.      *
  95.      * @param   boolean  $unset  True to remove the error from the stack.
  96.      *
  97.      * @return  mixed  Last exception object in the error stack or boolean false if none exist
  98.      *
  99.      * @deprecated  12.1
  100.      * @since   11.1
  101.      */
  102.     public static function getError($unset = false)
  103.     {
  104.         JLog::add('JError::getError() is deprecated.', JLog::WARNING, 'deprecated');
  105.  
  106.         if (!isset(self::$stack[0]))
  107.         {
  108.             return false;
  109.         }
  110.  
  111.         if ($unset)
  112.         {
  113.             $error = array_shift(self::$stack);
  114.         }
  115.         else
  116.         {
  117.             $error = &self::$stack[0];
  118.         }
  119.         return $error;
  120.     }
  121.  
  122.     /**
  123.      * Method for retrieving the exception stack
  124.      *
  125.      * @return  array  Chronological array of errors that have been stored during script execution
  126.      *
  127.      * @deprecated  12.1
  128.      * @since   11.1
  129.      */
  130.     public static function getErrors()
  131.     {
  132.         JLog::add('JError::getErrors() is deprecated.', JLog::WARNING, 'deprecated');
  133.  
  134.         return self::$stack;
  135.     }
  136.  
  137.     /**
  138.      * Method to add non-JError thrown JExceptions to the JError stack for debugging purposes
  139.      *
  140.      * @param   JException  &$e  Add an exception to the stack.
  141.      *
  142.      * @return  void 
  143.      *
  144.      * @since       11.1
  145.      * @deprecated  12.1
  146.      */
  147.     public static function addToStack(JException &$e)
  148.     {
  149.         JLog::add('JError::addToStack() is deprecated.', JLog::WARNING, 'deprecated');
  150.  
  151.         self::$stack[] = &$e;
  152.     }
  153.  
  154.     /**
  155.      * Create a new JException object given the passed arguments
  156.      *
  157.      * @param   integer  $level      The error level - use any of PHP's own error levels for
  158.      *                                this: E_ERROR, E_WARNING, E_NOTICE, E_USER_ERROR,
  159.      *                                E_USER_WARNING, E_USER_NOTICE.
  160.      * @param   string   $code       The application-internal error code for this error
  161.      * @param   string   $msg        The error message, which may also be shown the user if need be.
  162.      * @param   mixed    $info       Optional: Additional error information (usually only
  163.      *                                developer-relevant information that the user should never see,
  164.      *                                like a database DSN).
  165.      * @param   boolean  $backtrace  Add a stack backtrace to the exception.
  166.      *
  167.      * @return  mixed    The JException object
  168.      *
  169.      * @since       11.1
  170.      * @deprecated  12.1  Use PHP Exception
  171.      * @see         JException
  172.      */
  173.     public static function raise($level, $code, $msg, $info = null, $backtrace = false)
  174.     {
  175.         JLog::add('JError::raise() is deprecated.', JLog::WARNING, 'deprecated');
  176.  
  177.         // Build error object
  178.         $exception = new JException($msg, $code, $level, $info, $backtrace);
  179.         return self::throwError($exception);
  180.     }
  181.  
  182.     /**
  183.      * Throw an error
  184.      *
  185.      * @param   object  &$exception  An exception to throw.
  186.      *
  187.      * @return  reference 
  188.      *
  189.      * @deprecated  12.1  Use PHP Exception
  190.      * @see     JException
  191.      * @since   11.1
  192.      */
  193.     public static function throwError(&$exception)
  194.     {
  195.         JLog::add('JError::throwError() is deprecated.', JLog::WARNING, 'deprecated');
  196.  
  197.         static $thrown = false;
  198.  
  199.         // If thrown is hit again, we've come back to JError in the middle of throwing another JError, so die!
  200.         if ($thrown)
  201.         {
  202.             self::handleEcho($exception, array());
  203.  
  204.             // Inifite loop.
  205.             jexit();
  206.         }
  207.  
  208.         $thrown = true;
  209.         $level = $exception->get('level');
  210.  
  211.         // See what to do with this kind of error
  212.         $handler = self::getErrorHandling($level);
  213.  
  214.         $function = 'handle' . ucfirst($handler['mode']);
  215.         if (is_callable(array('JError', $function)))
  216.         {
  217.             $reference = call_user_func_array(array('JError', $function), array(&$exception, (isset($handler['options'])) ? $handler['options'] : array()));
  218.         }
  219.         else
  220.         {
  221.             // This is required to prevent a very unhelpful white-screen-of-death
  222.             jexit(
  223.                 'JError::raise -> Static method JError::' . $function . ' does not exist. Contact a developer to debug' .
  224.                 '<br /><strong>Error was</strong> <br />' . $exception->getMessage()
  225.             );
  226.         }
  227.         // We don't need to store the error, since JException already does that for us!
  228.         // Remove loop check
  229.         $thrown = false;
  230.  
  231.         return $reference;
  232.     }
  233.  
  234.     /**
  235.      * Wrapper method for the raise() method with predefined error level of E_ERROR and backtrace set to true.
  236.      *
  237.      * @param   string  $code  The application-internal error code for this error
  238.      * @param   string  $msg   The error message, which may also be shown the user if need be.
  239.      * @param   mixed   $info  Optional: Additional error information (usually only
  240.      *                          developer-relevant information that the user should
  241.      *                          never see, like a database DSN).
  242.      *
  243.      * @return  object  $error  The configured JError object
  244.      *
  245.      * @deprecated   12.1       Use PHP Exception
  246.      * @see        JError::raise()
  247.      * @since   11.1
  248.      */
  249.     public static function raiseError($code, $msg, $info = null)
  250.     {
  251.         JLog::add('JError::raiseError() is deprecated.', JLog::WARNING, 'deprecated');
  252.  
  253.         return self::raise(E_ERROR, $code, $msg, $info, true);
  254.     }
  255.  
  256.     /**
  257.      * Wrapper method for the {@link raise()} method with predefined error level of E_WARNING and
  258.      * backtrace set to false.
  259.      *
  260.      * @param   string  $code  The application-internal error code for this error
  261.      * @param   string  $msg   The error message, which may also be shown the user if need be.
  262.      * @param   mixed   $info  Optional: Additional error information (usually only
  263.      *                          developer-relevant information that
  264.      *                          the user should never see, like a database DSN).
  265.      *
  266.      * @return  object  The configured JError object
  267.      *
  268.      * @deprecated  12.1  Use PHP Exception
  269.      * @see        JError::raise()
  270.      * @since      11.1
  271.      */
  272.     public static function raiseWarning($code, $msg, $info = null)
  273.     {
  274.         JLog::add('JError::raiseWarning() is deprecated.', JLog::WARNING, 'deprecated');
  275.  
  276.         return self::raise(E_WARNING, $code, $msg, $info);
  277.     }
  278.  
  279.     /**
  280.      * Wrapper method for the {@link raise()} method with predefined error
  281.      * level of E_NOTICE and backtrace set to false.
  282.      *
  283.      * @param   string  $code  The application-internal error code for this error
  284.      * @param   string  $msg   The error message, which may also be shown the user if need be.
  285.      * @param   mixed   $info  Optional: Additional error information (usually only
  286.      *                          developer-relevant information that the user
  287.      *                          should never see, like a database DSN).
  288.      *
  289.      * @return  object   The configured JError object
  290.      *
  291.      * @deprecated       12.1   Use PHP Exception
  292.      * @see     raise()
  293.      * @since   11.1
  294.      */
  295.     public static function raiseNotice($code, $msg, $info = null)
  296.     {
  297.         JLog::add('JError::raiseNotice() is deprecated.', JLog::WARNING, 'deprecated');
  298.  
  299.         return self::raise(E_NOTICE, $code, $msg, $info);
  300.     }
  301.  
  302.     /**
  303.      * Method to get the current error handler settings for a specified error level.
  304.      *
  305.      * @param   integer  $level  The error level to retrieve. This can be any of PHP's
  306.      *                            own error levels, e.g. E_ALL, E_NOTICE...
  307.      *
  308.      * @return  array    All error handling details
  309.      *
  310.      * @deprecated   12.1  Use PHP Exception
  311.      * @since   11.1
  312.      */
  313.     public static function getErrorHandling($level)
  314.     {
  315.         JLog::add('JError::getErrorHandling() is deprecated.', JLog::WARNING, 'deprecated');
  316.  
  317.         return self::$handlers[$level];
  318.     }
  319.  
  320.     /**
  321.      * Method to set the way the JError will handle different error levels. Use this if you want to override the default settings.
  322.      *
  323.      * Error handling modes:
  324.      * - ignore
  325.      * - echo
  326.      * - verbose
  327.      * - die
  328.      * - message
  329.      * - log
  330.      * - callback
  331.      *
  332.      * You may also set the error handling for several modes at once using PHP's bit operations.
  333.      * Examples:
  334.      * - E_ALL = Set the handling for all levels
  335.      * - E_ERROR | E_WARNING = Set the handling for errors and warnings
  336.      * - E_ALL ^ E_ERROR = Set the handling for all levels except errors
  337.      *
  338.      * @param   integer  $level    The error level for which to set the error handling
  339.      * @param   string   $mode     The mode to use for the error handling.
  340.      * @param   mixed    $options  Optional: Any options needed for the given mode.
  341.      *
  342.      * @return  mixed  True on success or a JException object if failed.
  343.      *
  344.      * @deprecated  12.1  Use PHP Exception
  345.      * @since   11.1
  346.      */
  347.     public static function setErrorHandling($level, $mode, $options = null)
  348.     {
  349.         JLog::add('JError::setErrorHandling() is deprecated.', JLog::WARNING, 'deprecated');
  350.  
  351.         $levels = self::$levels;
  352.  
  353.         $function = 'handle' . ucfirst($mode);
  354.  
  355.         if (!is_callable(array('JError', $function)))
  356.         {
  357.             return self::raiseError(E_ERROR, 'JError:' . JERROR_ILLEGAL_MODE, 'Error Handling mode is not known', 'Mode: ' . $mode . ' is not implemented.');
  358.         }
  359.  
  360.         foreach ($levels as $eLevel => $eTitle)
  361.         {
  362.             if (($level & $eLevel) != $eLevel)
  363.             {
  364.                 continue;
  365.             }
  366.  
  367.             // Set callback options
  368.             if ($mode == 'callback')
  369.             {
  370.                 if (!is_array($options))
  371.                 {
  372.                     return self::raiseError(E_ERROR, 'JError:' . JERROR_ILLEGAL_OPTIONS, 'Options for callback not valid');
  373.                 }
  374.  
  375.                 if (!is_callable($options))
  376.                 {
  377.                     $tmp = array('GLOBAL');
  378.                     if (is_array($options))
  379.                     {
  380.                         $tmp[0] = $options[0];
  381.                         $tmp[1] = $options[1];
  382.                     }
  383.                     else
  384.                     {
  385.                         $tmp[1] = $options;
  386.                     }
  387.  
  388.                     return self::raiseError(
  389.                         E_ERROR,
  390.                         'JError:' . JERROR_CALLBACK_NOT_CALLABLE,
  391.                         'Function is not callable',
  392.                         'Function:' . $tmp[1] . ' scope ' . $tmp[0] . '.'
  393.                     );
  394.                 }
  395.             }
  396.  
  397.             // Save settings
  398.             self::$handlers[$eLevel] = array('mode' => $mode);
  399.             if ($options != null)
  400.             {
  401.                 self::$handlers[$eLevel]['options'] = $options;
  402.             }
  403.         }
  404.  
  405.         return true;
  406.     }
  407.  
  408.     /**
  409.      * Method that attaches the error handler to JError
  410.      *
  411.      * @return  void 
  412.      *
  413.      * @deprecated  12.1
  414.      * @see     set_error_handler
  415.      * @since   11.1
  416.      */
  417.     public static function attachHandler()
  418.     {
  419.         JLog::add('JError::getErrorHandling() is deprecated.', JLog::WARNING, 'deprecated');
  420.  
  421.         set_error_handler(array('JError', 'customErrorHandler'));
  422.     }
  423.  
  424.     /**
  425.      * Method that detaches the error handler from JError
  426.      *
  427.      * @return  void 
  428.      *
  429.      * @deprecated  12.1
  430.      * @see     restore_error_handler
  431.      * @since   11.1
  432.      */
  433.     public static function detachHandler()
  434.     {
  435.         JLog::add('JError::detachHandler() is deprecated.', JLog::WARNING, 'deprecated');
  436.  
  437.         restore_error_handler();
  438.     }
  439.  
  440.     /**
  441.      * Method to register a new error level for handling errors
  442.      *
  443.      * This allows you to add custom error levels to the built-in
  444.      * - E_NOTICE
  445.      * - E_WARNING
  446.      * - E_NOTICE
  447.      *
  448.      * @param   integer  $level    Error level to register
  449.      * @param   string   $name     Human readable name for the error level
  450.      * @param   string   $handler  Error handler to set for the new error level [optional]
  451.      *
  452.      * @return  boolean  True on success; false if the level already has been registered
  453.      *
  454.      * @deprecated  12.1
  455.      * @since   11.1
  456.      */
  457.     public static function registerErrorLevel($level, $name, $handler = 'ignore')
  458.     {
  459.         JLog::add('JError::registerErrorLevel() is deprecated.', JLog::WARNING, 'deprecated');
  460.  
  461.         if (isset(self::$levels[$level]))
  462.         {
  463.             return false;
  464.         }
  465.  
  466.         self::$levels[$level] = $name;
  467.         self::setErrorHandling($level, $handler);
  468.  
  469.         return true;
  470.     }
  471.  
  472.     /**
  473.      * Translate an error level integer to a human readable string
  474.      * e.g. E_ERROR will be translated to 'Error'
  475.      *
  476.      * @param   integer  $level  Error level to translate
  477.      *
  478.      * @return  mixed  Human readable error level name or boolean false if it doesn't exist
  479.      *
  480.      * @deprecated  12.1
  481.      * @since   11.1
  482.      */
  483.  
  484.     public static function translateErrorLevel($level)
  485.     {
  486.         JLog::add('JError::translateErrorLevel() is deprecated.', JLog::WARNING, 'deprecated');
  487.  
  488.         if (isset(self::$levels[$level]))
  489.         {
  490.             return self::$levels[$level];
  491.         }
  492.  
  493.         return false;
  494.     }
  495.  
  496.     /**
  497.      * Ignore error handler
  498.      * - Ignores the error
  499.      *
  500.      * @param   object  &$error   Exception object to handle
  501.      * @param   array   $options  Handler options
  502.      *
  503.      * @return  object   The exception object
  504.      *
  505.      * @deprecated  12.1
  506.      * @see     JError::raise()
  507.      * @since   11.1
  508.      */
  509.     public static function handleIgnore(&$error, $options)
  510.     {
  511.         JLog::add('JError::handleIgnore() is deprecated.', JLog::WARNING, 'deprecated');
  512.  
  513.         return $error;
  514.     }
  515.  
  516.     /**
  517.      * Echo error handler
  518.      * - Echos the error message to output
  519.      *
  520.      * @param   object  &$error   Exception object to handle
  521.      * @param   array   $options  Handler options
  522.      *
  523.      * @return  object  The exception object
  524.      *
  525.      * @deprecated  12.1
  526.      * @see         JError::raise()
  527.      * @since       11.1
  528.      */
  529.     public static function handleEcho(&$error, $options)
  530.     {
  531.         JLog::add('JError::handleEcho() is deprecated.', JLog::WARNING, 'deprecated');
  532.  
  533.         $level_human = self::translateErrorLevel($error->get('level'));
  534.  
  535.         // If system debug is set, then output some more information.
  536.         if (defined('JDEBUG'))
  537.         {
  538.             $backtrace = $error->getTrace();
  539.             $trace = '';
  540.             for ($i = count($backtrace) - 1; $i >= 0; $i--)
  541.             {
  542.                 if (isset($backtrace[$i]['class']))
  543.                 {
  544.                     $trace .= sprintf("\n%s %s %s()", $backtrace[$i]['class'], $backtrace[$i]['type'], $backtrace[$i]['function']);
  545.                 }
  546.                 else
  547.                 {
  548.                     $trace .= sprintf("\n%s()", $backtrace[$i]['function']);
  549.                 }
  550.  
  551.                 if (isset($backtrace[$i]['file']))
  552.                 {
  553.                     $trace .= sprintf(' @ %s:%d', $backtrace[$i]['file'], $backtrace[$i]['line']);
  554.                 }
  555.             }
  556.         }
  557.  
  558.         if (isset($_SERVER['HTTP_HOST']))
  559.         {
  560.             // Output as html
  561.             echo "<br /><b>jos-$level_human</b>: "
  562.                 . $error->get('message') . "<br />\n"
  563.                 . (defined('JDEBUG') ? nl2br($trace) : '');
  564.         }
  565.         else
  566.         {
  567.             // Output as simple text
  568.             if (defined('STDERR'))
  569.             {
  570.                 fwrite(STDERR, "J$level_human: " . $error->get('message') . "\n");
  571.                 if (defined('JDEBUG'))
  572.                 {
  573.                     fwrite(STDERR, $trace);
  574.                 }
  575.             }
  576.             else
  577.             {
  578.                 echo "J$level_human: " . $error->get('message') . "\n";
  579.                 if (defined('JDEBUG'))
  580.                 {
  581.                     echo $trace;
  582.                 }
  583.             }
  584.         }
  585.  
  586.         return $error;
  587.     }
  588.  
  589.     /**
  590.      * Verbose error handler
  591.      * - Echos the error message to output as well as related info
  592.      *
  593.      * @param   object  &$error   Exception object to handle
  594.      * @param   array   $options  Handler options
  595.      *
  596.      * @return  object  The exception object
  597.      *
  598.      * @deprecated  12.1
  599.      * @see         JError::raise()
  600.      * @since       11.1
  601.      */
  602.     public static function handleVerbose(&$error, $options)
  603.     {
  604.         JLog::add('JError::handleVerbose() is deprecated.', JLog::WARNING, 'deprecated');
  605.  
  606.         $level_human = self::translateErrorLevel($error->get('level'));
  607.         $info = $error->get('info');
  608.  
  609.         if (isset($_SERVER['HTTP_HOST']))
  610.         {
  611.             // Output as html
  612.             echo "<br /><b>J$level_human</b>: " . $error->get('message') . "<br />\n";
  613.  
  614.             if ($info != null)
  615.             {
  616.                 echo "&#160;&#160;&#160;" . $info . "<br />\n";
  617.             }
  618.  
  619.             echo $error->getBacktrace(true);
  620.         }
  621.         else
  622.         {
  623.             // Output as simple text
  624.             echo "J$level_human: " . $error->get('message') . "\n";
  625.             if ($info != null)
  626.             {
  627.                 echo "\t" . $info . "\n";
  628.             }
  629.  
  630.         }
  631.  
  632.         return $error;
  633.     }
  634.  
  635.     /**
  636.      * Die error handler
  637.      * - Echos the error message to output and then dies
  638.      *
  639.      * @param   object  &$error   Exception object to handle
  640.      * @param   array   $options  Handler options
  641.      *
  642.      * @return  object  The exception object
  643.      *
  644.      * @deprecated  12.1
  645.      * @see         JError::raise()
  646.      * @since       11.1
  647.      */
  648.     public static function handleDie(&$error, $options)
  649.     {
  650.         JLog::add('JError::handleDie() is deprecated.', JLog::WARNING, 'deprecated');
  651.  
  652.         $level_human = self::translateErrorLevel($error->get('level'));
  653.  
  654.         if (isset($_SERVER['HTTP_HOST']))
  655.         {
  656.             // Output as html
  657.             jexit("<br /><b>J$level_human</b>: " . $error->get('message') . "<br />\n");
  658.         }
  659.         else
  660.         {
  661.             // Output as simple text
  662.             if (defined('STDERR'))
  663.             {
  664.                 fwrite(STDERR, "J$level_human: " . $error->get('message') . "\n");
  665.                 jexit();
  666.             }
  667.             else
  668.             {
  669.                 jexit("J$level_human: " . $error->get('message') . "\n");
  670.             }
  671.         }
  672.  
  673.         return $error;
  674.     }
  675.  
  676.     /**
  677.      * Message error handler
  678.      * Enqueues the error message into the system queue
  679.      *
  680.      * @param   object  &$error   Exception object to handle
  681.      * @param   array   $options  Handler options
  682.      *
  683.      * @return  object  The exception object
  684.      *
  685.      * @deprecated  12.1
  686.      * @see         JError::raise()
  687.      * @since       11.1
  688.      */
  689.     public static function handleMessage(&$error, $options)
  690.     {
  691.         JLog::add('JError::hanleMessage() is deprecated.', JLog::WARNING, 'deprecated');
  692.  
  693.         $appl = JFactory::getApplication();
  694.         $type = ($error->get('level') == E_NOTICE) ? 'notice' : 'error';
  695.         $appl->enqueueMessage($error->get('message'), $type);
  696.  
  697.         return $error;
  698.     }
  699.  
  700.     /**
  701.      * Log error handler
  702.      * Logs the error message to a system log file
  703.      *
  704.      * @param   object  &$error   Exception object to handle
  705.      * @param   array   $options  Handler options
  706.      *
  707.      * @return  object  The exception object
  708.      *
  709.      * @deprecated  12.1
  710.      * @see         JError::raise()
  711.      * @since       11.1
  712.      */
  713.     public static function handleLog(&$error, $options)
  714.     {
  715.         JLog::add('JError::handleLog() is deprecated.', JLog::WARNING, 'deprecated');
  716.  
  717.         static $log;
  718.  
  719.         if ($log == null)
  720.         {
  721.             $options['text_file'] = date('Y-m-d') . '.error.log';
  722.             $options['format'] = "{DATE}\t{TIME}\t{LEVEL}\t{CODE}\t{MESSAGE}";
  723.             JLog::addLogger($options, JLog::ALL, array('error'));
  724.         }
  725.  
  726.         $entry = new JLogEntry(
  727.             str_replace(array("\r", "\n"), array('', '\\n'), $error->get('message')),
  728.             $error->get('level'),
  729.             'error'
  730.         );
  731.         $entry->code = $error->get('code');
  732.         JLog::add($entry);
  733.  
  734.         return $error;
  735.     }
  736.  
  737.     /**
  738.      * Callback error handler
  739.      * - Send the error object to a callback method for error handling
  740.      *
  741.      * @param   object  &$error   Exception object to handle
  742.      * @param   array   $options  Handler options
  743.      *
  744.      * @return  object  The exception object
  745.      *
  746.      * @deprecated  12.1
  747.      * @see         JError::raise()
  748.      * @since       11.1
  749.      */
  750.     public static function handleCallback(&$error, $options)
  751.     {
  752.         JLog::add('JError::handleCallback() is deprecated.', JLog::WARNING, 'deprecated');
  753.  
  754.         return call_user_func($options, $error);
  755.     }
  756.  
  757.     /**
  758.      * Display a custom error page and exit gracefully
  759.      *
  760.      * @param   object  &$error  Exception object
  761.      *
  762.      * @return  void 
  763.      *
  764.      * @deprecated  12.1
  765.      * @since   11.1
  766.      */
  767.     public static function customErrorPage(&$error)
  768.     {
  769.         JLog::add('JError::customErrorPage() is deprecated.', JLog::WARNING, 'deprecated');
  770.  
  771.         $app = JFactory::getApplication();
  772.         $document = JDocument::getInstance('error');
  773.         if ($document)
  774.         {
  775.             $config = JFactory::getConfig();
  776.  
  777.             // Get the current template from the application
  778.             $template = $app->getTemplate();
  779.  
  780.             // Push the error object into the document
  781.             $document->setError($error);
  782.  
  783.             // If site is offline and it's a 404 error, just go to index (to see offline message, instead of 404)
  784.             if ($error->getCode() == '404' && JFactory::getConfig()->get('offline') == 1)
  785.             {
  786.                 JFactory::getApplication()->redirect('index.php');
  787.             }
  788.  
  789.             @ob_end_clean();
  790.             $document->setTitle(JText::_('Error') . ': ' . $error->getCode());
  791.             $data = $document->render(false, array('template' => $template, 'directory' => JPATH_THEMES, 'debug' => $config->get('debug')));
  792.  
  793.             // Failsafe to get the error displayed.
  794.             if (empty($data))
  795.             {
  796.                 self::handleEcho($error, array());
  797.             }
  798.             else
  799.             {
  800.                 // Do not allow cache
  801.                 $app->allowCache(false);
  802.  
  803.                 $app->setBody($data);
  804.                 echo $app->toString();
  805.             }
  806.         }
  807.         else
  808.         {
  809.             // Just echo the error since there is no document
  810.             // This is a common use case for Command Line Interface applications.
  811.             self::handleEcho($error, array());
  812.         }
  813.         $app->close(0);
  814.     }
  815.  
  816.     /**
  817.      * Display a message to the user
  818.      *
  819.      * @param   integer  $level  The error level - use any of PHP's own error levels
  820.      *                    for this: E_ERROR, E_WARNING, E_NOTICE, E_USER_ERROR,
  821.      *                    E_USER_WARNING, E_USER_NOTICE.
  822.      * @param   string   $msg    Error message, shown to user if need be.
  823.      *
  824.      * @return  void 
  825.      *
  826.      * @deprecated  12.1
  827.      * @since   11.1
  828.      */
  829.     public static function customErrorHandler($level, $msg)
  830.     {
  831.         JLog::add('JError::customErrorHandler() is deprecated.', JLog::WARNING, 'deprecated');
  832.  
  833.         self::raise($level, '', $msg);
  834.     }
  835.  
  836.     /**
  837.      * Render the backtrace
  838.      *
  839.      * @param   integer  $error  The error
  840.      *
  841.      * @return  string  Contents of the backtrace
  842.      *
  843.      * @deprecated  12.1
  844.      * @since   11.1
  845.      */
  846.     public static function renderBacktrace($error)
  847.     {
  848.         JLog::add('JError::renderBacktrace() is deprecated.', JLog::WARNING, 'deprecated');
  849.  
  850.         $contents = null;
  851.         $backtrace = $error->getTrace();
  852.  
  853.         if (is_array($backtrace))
  854.         {
  855.             ob_start();
  856.             $j = 1;
  857.             echo '<table cellpadding="0" cellspacing="0" class="Table">';
  858.             echo '        <tr>';
  859.             echo '                <td colspan="3" class="TD"><strong>Call stack</strong></td>';
  860.             echo '        </tr>';
  861.             echo '        <tr>';
  862.             echo '                <td class="TD"><strong>#</strong></td>';
  863.             echo '                <td class="TD"><strong>Function</strong></td>';
  864.             echo '                <td class="TD"><strong>Location</strong></td>';
  865.             echo '        </tr>';
  866.  
  867.             for ($i = count($backtrace) - 1; $i >= 0; $i--)
  868.             {
  869.                 echo '        <tr>';
  870.                 echo '                <td class="TD">' . $j . '</td>';
  871.  
  872.                 if (isset($backtrace[$i]['class']))
  873.                 {
  874.                     echo '        <td class="TD">' . $backtrace[$i]['class'] . $backtrace[$i]['type'] . $backtrace[$i]['function'] . '()</td>';
  875.                 }
  876.                 else
  877.                 {
  878.                     echo '        <td class="TD">' . $backtrace[$i]['function'] . '()</td>';
  879.                 }
  880.  
  881.                 if (isset($backtrace[$i]['file']))
  882.                 {
  883.                     echo '                <td class="TD">' . $backtrace[$i]['file'] . ':' . $backtrace[$i]['line'] . '</td>';
  884.                 }
  885.                 else
  886.                 {
  887.                     echo '                <td class="TD">&#160;</td>';
  888.                 }
  889.  
  890.                 echo '        </tr>';
  891.                 $j++;
  892.             }
  893.  
  894.             echo '</table>';
  895.             $contents = ob_get_contents();
  896.             ob_end_clean();
  897.         }
  898.  
  899.         return $contents;
  900.     }
  901. }

Documentation generated on Tue, 19 Nov 2013 15:02:38 +0100 by phpDocumentor 1.4.3