Source for file VarParser.php

Documentation is available at VarParser.php

  1. <?php
  2.  
  3. /**
  4.  * Parses string representations into their corresponding native PHP
  5.  * variable type. The base implementation does a simple type-check.
  6.  */
  7. class HTMLPurifier_VarParser
  8. {
  9.     
  10.     const STRING    = 1;
  11.     const ISTRING   = 2;
  12.     const TEXT      = 3;
  13.     const ITEXT     = 4;
  14.     const INT       = 5;
  15.     const FLOAT     = 6;
  16.     const BOOL      = 7;
  17.     const LOOKUP    = 8;
  18.     const ALIST     = 9;
  19.     const HASH      = 10;
  20.     const MIXED     = 11;
  21.     
  22.     /**
  23.      * Lookup table of allowed types. Mainly for backwards compatibility, but
  24.      * also convenient for transforming string type names to the integer constants.
  25.      */
  26.     static public $types = array(
  27.         'string'    => self::STRING,
  28.         'istring'   => self::ISTRING,
  29.         'text'      => self::TEXT,
  30.         'itext'     => self::ITEXT,
  31.         'int'       => self::INT,
  32.         'float'     => self::FLOAT,
  33.         'bool'      => self::BOOL,
  34.         'lookup'    => self::LOOKUP,
  35.         'list'      => self::ALIST,
  36.         'hash'      => self::HASH,
  37.         'mixed'     => self::MIXED
  38.     );
  39.     
  40.     /**
  41.      * Lookup table of types that are string, and can have aliases or
  42.      * allowed value lists.
  43.      */
  44.     static public $stringTypes = array(
  45.         self::STRING    => true,
  46.         self::ISTRING   => true,
  47.         self::TEXT      => true,
  48.         self::ITEXT     => true,
  49.     );
  50.     
  51.     /**
  52.      * Validate a variable according to type. Throws
  53.      * HTMLPurifier_VarParserException if invalid.
  54.      * It may return NULL as a valid type if $allow_null is true.
  55.      *
  56.      * @param $var Variable to validate
  57.      * @param $type Type of variable, see HTMLPurifier_VarParser->types
  58.      * @param $allow_null Whether or not to permit null as a value
  59.      * @return Validated and type-coerced variable
  60.      */
  61.     final public function parse($var, $type, $allow_null = false) {
  62.         if (is_string($type)) {
  63.             if (!isset(HTMLPurifier_VarParser::$types[$type])) {
  64.                 throw new HTMLPurifier_VarParserException("Invalid type '$type'");
  65.             } else {
  66.                 $type = HTMLPurifier_VarParser::$types[$type];
  67.             }
  68.         }
  69.         $var = $this->parseImplementation($var, $type, $allow_null);
  70.         if ($allow_null && $var === null) return null;
  71.         // These are basic checks, to make sure nothing horribly wrong
  72.         // happened in our implementations.
  73.         switch ($type) {
  74.             case (self::STRING):
  75.             case (self::ISTRING):
  76.             case (self::TEXT):
  77.             case (self::ITEXT):
  78.                 if (!is_string($var)) break;
  79.                 if ($type == self::ISTRING || $type == self::ITEXT) $var = strtolower($var);
  80.                 return $var;
  81.             case (self::INT):
  82.                 if (!is_int($var)) break;
  83.                 return $var;
  84.             case (self::FLOAT):
  85.                 if (!is_float($var)) break;
  86.                 return $var;
  87.             case (self::BOOL):
  88.                 if (!is_bool($var)) break;
  89.                 return $var;
  90.             case (self::LOOKUP):
  91.             case (self::ALIST):
  92.             case (self::HASH):
  93.                 if (!is_array($var)) break;
  94.                 if ($type === self::LOOKUP) {
  95.                     foreach ($var as $k) if ($k !== true) $this->error('Lookup table contains value other than true');
  96.                 } elseif ($type === self::ALIST) {
  97.                     $keys = array_keys($var);
  98.                     if (array_keys($keys) !== $keys) $this->error('Indices for list are not uniform');
  99.                 }
  100.                 return $var;
  101.             case (self::MIXED):
  102.                 return $var;
  103.             default:
  104.                 $this->errorInconsistent(get_class($this), $type);
  105.         }
  106.         $this->errorGeneric($var, $type);
  107.     }
  108.     
  109.     /**
  110.      * Actually implements the parsing. Base implementation is to not
  111.      * do anything to $var. Subclasses should overload this!
  112.      */
  113.     protected function parseImplementation($var, $type, $allow_null) {
  114.         return $var;
  115.     }
  116.     
  117.     /**
  118.      * Throws an exception.
  119.      */
  120.     protected function error($msg) {
  121.         throw new HTMLPurifier_VarParserException($msg);
  122.     }
  123.     
  124.     /**
  125.      * Throws an inconsistency exception.
  126.      * @note This should not ever be called. It would be called if we
  127.      *        extend the allowed values of HTMLPurifier_VarParser without
  128.      *        updating subclasses.
  129.      */
  130.     protected function errorInconsistent($class, $type) {
  131.         throw new HTMLPurifier_Exception("Inconsistency in $class: ".HTMLPurifier_VarParser::getTypeName($type)." not implemented");
  132.     }
  133.     
  134.     /**
  135.      * Generic error for if a type didn't work.
  136.      */
  137.     protected function errorGeneric($var, $type) {
  138.         $vtype = gettype($var);
  139.         $this->error("Expected type ".HTMLPurifier_VarParser::getTypeName($type).", got $vtype");
  140.     }
  141.     
  142.     static public function getTypeName($type) {
  143.         static $lookup;
  144.         if (!$lookup) {
  145.             // Lazy load the alternative lookup table
  146.             $lookup = array_flip(HTMLPurifier_VarParser::$types);
  147.         }
  148.         if (!isset($lookup[$type])) return 'unknown';
  149.         return $lookup[$type];
  150.     }
  151.     
  152. }

Documentation generated on Thu, 19 Jun 2008 18:50:31 -0400 by phpDocumentor 1.4.2