aboutsummaryrefslogtreecommitdiffhomepage
path: root/inc/3rdparty/htmlpurifier/HTMLPurifier/VarParser.php
diff options
context:
space:
mode:
Diffstat (limited to 'inc/3rdparty/htmlpurifier/HTMLPurifier/VarParser.php')
-rw-r--r--inc/3rdparty/htmlpurifier/HTMLPurifier/VarParser.php198
1 files changed, 0 insertions, 198 deletions
diff --git a/inc/3rdparty/htmlpurifier/HTMLPurifier/VarParser.php b/inc/3rdparty/htmlpurifier/HTMLPurifier/VarParser.php
deleted file mode 100644
index 4bf7771a..00000000
--- a/inc/3rdparty/htmlpurifier/HTMLPurifier/VarParser.php
+++ /dev/null
@@ -1,198 +0,0 @@
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 */
7class 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 public static $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 public static $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.
53 * It may return NULL as a valid type if $allow_null is true.
54 *
55 * @param mixed $var Variable to validate
56 * @param int $type Type of variable, see HTMLPurifier_VarParser->types
57 * @param bool $allow_null Whether or not to permit null as a value
58 * @return string Validated and type-coerced variable
59 * @throws HTMLPurifier_VarParserException
60 */
61 final public function parse($var, $type, $allow_null = false)
62 {
63 if (is_string($type)) {
64 if (!isset(HTMLPurifier_VarParser::$types[$type])) {
65 throw new HTMLPurifier_VarParserException("Invalid type '$type'");
66 } else {
67 $type = HTMLPurifier_VarParser::$types[$type];
68 }
69 }
70 $var = $this->parseImplementation($var, $type, $allow_null);
71 if ($allow_null && $var === null) {
72 return null;
73 }
74 // These are basic checks, to make sure nothing horribly wrong
75 // happened in our implementations.
76 switch ($type) {
77 case (self::STRING):
78 case (self::ISTRING):
79 case (self::TEXT):
80 case (self::ITEXT):
81 if (!is_string($var)) {
82 break;
83 }
84 if ($type == self::ISTRING || $type == self::ITEXT) {
85 $var = strtolower($var);
86 }
87 return $var;
88 case (self::INT):
89 if (!is_int($var)) {
90 break;
91 }
92 return $var;
93 case (self::FLOAT):
94 if (!is_float($var)) {
95 break;
96 }
97 return $var;
98 case (self::BOOL):
99 if (!is_bool($var)) {
100 break;
101 }
102 return $var;
103 case (self::LOOKUP):
104 case (self::ALIST):
105 case (self::HASH):
106 if (!is_array($var)) {
107 break;
108 }
109 if ($type === self::LOOKUP) {
110 foreach ($var as $k) {
111 if ($k !== true) {
112 $this->error('Lookup table contains value other than true');
113 }
114 }
115 } elseif ($type === self::ALIST) {
116 $keys = array_keys($var);
117 if (array_keys($keys) !== $keys) {
118 $this->error('Indices for list are not uniform');
119 }
120 }
121 return $var;
122 case (self::MIXED):
123 return $var;
124 default:
125 $this->errorInconsistent(get_class($this), $type);
126 }
127 $this->errorGeneric($var, $type);
128 }
129
130 /**
131 * Actually implements the parsing. Base implementation does not
132 * do anything to $var. Subclasses should overload this!
133 * @param mixed $var
134 * @param int $type
135 * @param bool $allow_null
136 * @return string
137 */
138 protected function parseImplementation($var, $type, $allow_null)
139 {
140 return $var;
141 }
142
143 /**
144 * Throws an exception.
145 * @throws HTMLPurifier_VarParserException
146 */
147 protected function error($msg)
148 {
149 throw new HTMLPurifier_VarParserException($msg);
150 }
151
152 /**
153 * Throws an inconsistency exception.
154 * @note This should not ever be called. It would be called if we
155 * extend the allowed values of HTMLPurifier_VarParser without
156 * updating subclasses.
157 * @param string $class
158 * @param int $type
159 * @throws HTMLPurifier_Exception
160 */
161 protected function errorInconsistent($class, $type)
162 {
163 throw new HTMLPurifier_Exception(
164 "Inconsistency in $class: " . HTMLPurifier_VarParser::getTypeName($type) .
165 " not implemented"
166 );
167 }
168
169 /**
170 * Generic error for if a type didn't work.
171 * @param mixed $var
172 * @param int $type
173 */
174 protected function errorGeneric($var, $type)
175 {
176 $vtype = gettype($var);
177 $this->error("Expected type " . HTMLPurifier_VarParser::getTypeName($type) . ", got $vtype");
178 }
179
180 /**
181 * @param int $type
182 * @return string
183 */
184 public static function getTypeName($type)
185 {
186 static $lookup;
187 if (!$lookup) {
188 // Lazy load the alternative lookup table
189 $lookup = array_flip(HTMLPurifier_VarParser::$types);
190 }
191 if (!isset($lookup[$type])) {
192 return 'unknown';
193 }
194 return $lookup[$type];
195 }
196}
197
198// vim: et sw=4 sts=4
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-24 01:54:33 +0000