Parses string representations into their corresponding native PHP variable type. More...

Inheritance diagram for HTMLPurifier_VarParser:

Collaboration diagram for HTMLPurifier_VarParser:

Public Member Functions
	parse ($var, $type, $allow_null=false)
	Validate a variable according to type.

Static Public Member Functions
static	getTypeName ($type)

Data Fields
const	STRING = 1
const	ISTRING = 2
const	TEXT = 3
const	ITEXT = 4
const	INT = 5
const	FLOAT = 6
const	BOOL = 7
const	LOOKUP = 8
const	ALIST = 9
const	HASH = 10
const	MIXED = 11

Static Public Attributes
static	$types
	Lookup table of allowed types.
static	$stringTypes
	Lookup table of types that are string, and can have aliases or allowed value lists.

Protected Member Functions
	parseImplementation ($var, $type, $allow_null)
	Actually implements the parsing.
	error ($msg)
	Throws an exception.
	errorInconsistent ($class, $type)
	Throws an inconsistency exception.
	errorGeneric ($var, $type)
	Generic error for if a type didn't work.

Detailed Description

Parses string representations into their corresponding native PHP variable type.

The base implementation does a simple type-check.

Definition at line 7 of file VarParser.php.

Member Function Documentation

HTMLPurifier_VarParser::error ( $msg )

protected

Throws an exception.

Exceptions

HTMLPurifier_VarParserException

Definition at line 147 of file VarParser.php.

Referenced by errorGeneric(), and parse().

    {
        throw new HTMLPurifier_VarParserException($msg);
    }

Here is the caller graph for this function:

HTMLPurifier_VarParser::errorGeneric	(	$var,
		$type
	)

protected

Generic error for if a type didn't work.

Parameters

mixed	$var
int	$type

Definition at line 174 of file VarParser.php.

References error(), and getTypeName().

Referenced by parse(), and HTMLPurifier_VarParser_Flexible\parseImplementation().

    {
        $vtype = gettype($var);
        $this->error("Expected type " . HTMLPurifier_VarParser::getTypeName($type) . ", got $vtype");
    }

Here is the call graph for this function:

Here is the caller graph for this function:

HTMLPurifier_VarParser::errorInconsistent	(	$class,
		$type
	)

protected

Throws an inconsistency exception.

Note: This should not ever be called. It would be called if we extend the allowed values of HTMLPurifier_VarParser without updating subclasses.

Parameters

string	$class
int	$type

Exceptions

HTMLPurifier_Exception

Definition at line 161 of file VarParser.php.

References getTypeName().

Referenced by parse(), and HTMLPurifier_VarParser_Flexible\parseImplementation().

    {
        throw new HTMLPurifier_Exception(
            "Inconsistency in $class: " . HTMLPurifier_VarParser::getTypeName($type) .
            " not implemented"
        );
    }

Here is the call graph for this function:

Here is the caller graph for this function:

static HTMLPurifier_VarParser::getTypeName ( $type )

static

Parameters

int $type

Returns: string

Definition at line 184 of file VarParser.php.

References $types.

Referenced by errorGeneric(), errorInconsistent(), and HTMLPurifier_Config\set().

    {
        static $lookup;
        if (!$lookup) {
            // Lazy load the alternative lookup table
            $lookup = array_flip(HTMLPurifier_VarParser::$types);
        }
        if (!isset($lookup[$type])) {
            return 'unknown';
        }
        return $lookup[$type];
    }

Here is the caller graph for this function:

HTMLPurifier_VarParser::parse	(	$var,
		$type,
		$allow_null = `false`
	)

final

Validate a variable according to type.

It may return NULL as a valid type if $allow_null is true.

Parameters

mixed	$var	Variable to validate
int	$type	Type of variable, see HTMLPurifier_VarParser->types
bool	$allow_null	Whether or not to permit null as a value

Returns: string Validated and type-coerced variable

Exceptions

HTMLPurifier_VarParserException

Definition at line 61 of file VarParser.php.

References $types, error(), errorGeneric(), errorInconsistent(), and parseImplementation().

    {
        if (is_string($type)) {
            if (!isset(HTMLPurifier_VarParser::$types[$type])) {
                throw new HTMLPurifier_VarParserException("Invalid type '$type'");
            } else {
                $type = HTMLPurifier_VarParser::$types[$type];
            }
        }
        $var = $this->parseImplementation($var, $type, $allow_null);
        if ($allow_null && $var === null) {
            return null;
        }
        // These are basic checks, to make sure nothing horribly wrong
        // happened in our implementations.
        switch ($type) {
            case (self::STRING):
            case (self::ISTRING):
            case (self::TEXT):
            case (self::ITEXT):
                if (!is_string($var)) {
                    break;
                }
                if ($type == self::ISTRING || $type == self::ITEXT) {
                    $var = strtolower($var);
                }
                return $var;
            case (self::INT):
                if (!is_int($var)) {
                    break;
                }
                return $var;
            case (self::FLOAT):
                if (!is_float($var)) {
                    break;
                }
                return $var;
            case (self::BOOL):
                if (!is_bool($var)) {
                    break;
                }
                return $var;
            case (self::LOOKUP):
            case (self::ALIST):
            case (self::HASH):
                if (!is_array($var)) {
                    break;
                }
                if ($type === self::LOOKUP) {
                    foreach ($var as $k) {
                        if ($k !== true) {
                            $this->error('Lookup table contains value other than true');
                        }
                    }
                } elseif ($type === self::ALIST) {
                    $keys = array_keys($var);
                    if (array_keys($keys) !== $keys) {
                        $this->error('Indices for list are not uniform');
                    }
                }
                return $var;
            case (self::MIXED):
                return $var;
            default:
                $this->errorInconsistent(get_class($this), $type);
        }
        $this->errorGeneric($var, $type);
    }

Here is the call graph for this function:

HTMLPurifier_VarParser::parseImplementation	(	$var,
		$type,
		$allow_null
	)

protected

Actually implements the parsing.

Base implementation does not do anything to $var. Subclasses should overload this!

Parameters

mixed	$var
int	$type
bool	$allow_null

Returns: string

Reimplemented in HTMLPurifier_VarParser_Flexible, and HTMLPurifier_VarParser_Native.

Definition at line 138 of file VarParser.php.

Referenced by parse().

    {
        return $var;
    }

Here is the caller graph for this function:

Field Documentation

HTMLPurifier_VarParser::$stringTypes

static

Initial value:

 array(
        self::STRING => true,
        self::ISTRING => true,
        self::TEXT => true,
        self::ITEXT => true,
    )

Lookup table of types that are string, and can have aliases or allowed value lists.

Definition at line 44 of file VarParser.php.

Referenced by HTMLPurifier_ConfigSchema_Validator\validateDirective().

HTMLPurifier_VarParser::$types

static

Initial value:

 array(
        'string' => self::STRING,
        'istring' => self::ISTRING,
        'text' => self::TEXT,
        'itext' => self::ITEXT,
        'int' => self::INT,
        'float' => self::FLOAT,
        'bool' => self::BOOL,
        'lookup' => self::LOOKUP,
        'list' => self::ALIST,
        'hash' => self::HASH,
        'mixed' => self::MIXED
    )