File indexing completed on 2024-05-05 06:02:16

 <?php
 
 /**
  * Error collection class that enables HTML Purifier to report HTML
  * problems back to the user
  */
 class HTMLPurifier_ErrorCollector
 {
 
     /**
      * Identifiers for the returned error array. These are purposely numeric
      * so list() can be used.
      */
     const LINENO   = 0;
     const SEVERITY = 1;
     const MESSAGE  = 2;
     const CHILDREN = 3;
 
     /**
      * @type array
      */
     protected $errors;
 
     /**
      * @type array
      */
     protected $_current;
 
     /**
      * @type array
      */
     protected $_stacks = array(array());
 
     /**
      * @type HTMLPurifier_Language
      */
     protected $locale;
 
     /**
      * @type HTMLPurifier_Generator
      */
     protected $generator;
 
     /**
      * @type HTMLPurifier_Context
      */
     protected $context;
 
     /**
      * @type array
      */
     protected $lines = array();
 
     /**
      * @param HTMLPurifier_Context $context
      */
     public function __construct($context)
     {
         $this->locale    =& $context->get('Locale');
         $this->context   = $context;
         $this->_current  =& $this->_stacks[0];
         $this->errors    =& $this->_stacks[0];
     }
 
     /**
      * Sends an error message to the collector for later use
      * @param int $severity Error severity, PHP error style (don't use E_USER_)
      * @param string $msg Error message text
      */
     public function send($severity, $msg)
     {
         $args = array();
         if (func_num_args() > 2) {
             $args = func_get_args();
             array_shift($args);
             unset($args[0]);
         }
 
         $token = $this->context->get('CurrentToken', true);
         $line  = $token ? $token->line : $this->context->get('CurrentLine', true);
         $col   = $token ? $token->col  : $this->context->get('CurrentCol', true);
         $attr  = $this->context->get('CurrentAttr', true);
 
         // perform special substitutions, also add custom parameters
         $subst = array();
         if (!is_null($token)) {
             $args['CurrentToken'] = $token;
         }
         if (!is_null($attr)) {
             $subst['$CurrentAttr.Name'] = $attr;
             if (isset($token->attr[$attr])) {
                 $subst['$CurrentAttr.Value'] = $token->attr[$attr];
             }
         }
 
         if (empty($args)) {
             $msg = $this->locale->getMessage($msg);
         } else {
             $msg = $this->locale->formatMessage($msg, $args);
         }
 
         if (!empty($subst)) {
             $msg = strtr($msg, $subst);
         }
 
         // (numerically indexed)
         $error = array(
             self::LINENO   => $line,
             self::SEVERITY => $severity,
             self::MESSAGE  => $msg,
             self::CHILDREN => array()
         );
         $this->_current[] = $error;
 
         // NEW CODE BELOW ...
         // Top-level errors are either:
         //  TOKEN type, if $value is set appropriately, or
         //  "syntax" type, if $value is null
         $new_struct = new HTMLPurifier_ErrorStruct();
         $new_struct->type = HTMLPurifier_ErrorStruct::TOKEN;
         if ($token) {
             $new_struct->value = clone $token;
         }
         if (is_int($line) && is_int($col)) {
             if (isset($this->lines[$line][$col])) {
                 $struct = $this->lines[$line][$col];
             } else {
                 $struct = $this->lines[$line][$col] = $new_struct;
             }
             // These ksorts may present a performance problem
             ksort($this->lines[$line], SORT_NUMERIC);
         } else {
             if (isset($this->lines[-1])) {
                 $struct = $this->lines[-1];
             } else {
                 $struct = $this->lines[-1] = $new_struct;
             }
         }
         ksort($this->lines, SORT_NUMERIC);
 
         // Now, check if we need to operate on a lower structure
         if (!empty($attr)) {
             $struct = $struct->getChild(HTMLPurifier_ErrorStruct::ATTR, $attr);
             if (!$struct->value) {
                 $struct->value = array($attr, 'PUT VALUE HERE');
             }
         }
         if (!empty($cssprop)) {
             $struct = $struct->getChild(HTMLPurifier_ErrorStruct::CSSPROP, $cssprop);
             if (!$struct->value) {
                 // if we tokenize CSS this might be a little more difficult to do
                 $struct->value = array($cssprop, 'PUT VALUE HERE');
             }
         }
 
         // Ok, structs are all setup, now time to register the error
         $struct->addError($severity, $msg);
     }
 
     /**
      * Retrieves raw error data for custom formatter to use
      */
     public function getRaw()
     {
         return $this->errors;
     }
 
     /**
      * Default HTML formatting implementation for error messages
      * @param HTMLPurifier_Config $config Configuration, vital for HTML output nature
      * @param array $errors Errors array to display; used for recursion.
      * @return string
      */
     public function getHTMLFormatted($config, $errors = null)
     {
         $ret = array();
 
         $this->generator = new HTMLPurifier_Generator($config, $this->context);
         if ($errors === null) {
             $errors = $this->errors;
         }
 
         // 'At line' message needs to be removed
 
         // generation code for new structure goes here. It needs to be recursive.
         foreach ($this->lines as $line => $col_array) {
             if ($line == -1) {
                 continue;
             }
             foreach ($col_array as $col => $struct) {
                 $this->_renderStruct($ret, $struct, $line, $col);
             }
         }
         if (isset($this->lines[-1])) {
             $this->_renderStruct($ret, $this->lines[-1]);
         }
 
         if (empty($errors)) {
             return '<p>' . $this->locale->getMessage('ErrorCollector: No errors') . '</p>';
         } else {
             return '<ul><li>' . implode('</li><li>', $ret) . '</li></ul>';
         }
 
     }
 
     private function _renderStruct(&$ret, $struct, $line = null, $col = null)
     {
         $stack = array($struct);
         $context_stack = array(array());
         while ($current = array_pop($stack)) {
             $context = array_pop($context_stack);
             foreach ($current->errors as $error) {
                 list($severity, $msg) = $error;
                 $string = '';
                 $string .= '<div>';
                 // W3C uses an icon to indicate the severity of the error.
                 $error = $this->locale->getErrorName($severity);
                 $string .= "<span class=\"error e$severity\"><strong>$error</strong></span> ";
                 if (!is_null($line) && !is_null($col)) {
                     $string .= "<em class=\"location\">Line $line, Column $col: </em> ";
                 } else {
                     $string .= '<em class="location">End of Document: </em> ';
                 }
                 $string .= '<strong class="description">' . $this->generator->escape($msg) . '</strong> ';
                 $string .= '</div>';
                 // Here, have a marker for the character on the column appropriate.
                 // Be sure to clip extremely long lines.
                 //$string .= '<pre>';
                 //$string .= '';
                 //$string .= '</pre>';
                 $ret[] = $string;
             }
             foreach ($current->children as $array) {
                 $context[] = $current;
                 $stack = array_merge($stack, array_reverse($array, true));
                 for ($i = count($array); $i > 0; $i--) {
                     $context_stack[] = $context;
                 }
             }
         }
     }
 }
 
 // vim: et sw=4 sts=4