library/HTMLPurifier/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 }
 153
 154 // vim: et sw=4 sts=4