Collaboration diagram for HTML5:

Public Member Functions
	__construct ($data)

	save ()

Data Fields
const	PCDATA = 0

const	RCDATA = 1

const	CDATA = 2

const	PLAINTEXT = 3

const	DOCTYPE = 0

const	STARTTAG = 1

const	ENDTAG = 2

const	COMMENT = 3

const	CHARACTR = 4

const	EOF = 5

Private Member Functions
	char ()

	character ($s, $l=0)

	characters ($char_class, $start)

	dataState ()

	entityDataState ()

	tagOpenState ()

	closeTagOpenState ()

	tagNameState ()

	beforeAttributeNameState ()

	attributeNameState ()

	afterAttributeNameState ()

	beforeAttributeValueState ()

	attributeValueDoubleQuotedState ()

	attributeValueSingleQuotedState ()

	attributeValueUnquotedState ()

	entityInAttributeValueState ()

	bogusCommentState ()

	markupDeclarationOpenState ()

	commentState ()

	commentDashState ()

	commentEndState ()

	doctypeState ()

	beforeDoctypeNameState ()

	doctypeNameState ()

	afterDoctypeNameState ()

	bogusDoctypeState ()

	entity ()

	emitToken ($token)

	EOF ()

Private Attributes
	$data

	$char

	$EOF

	$state

	$tree

	$token

	$content_model

	$escape = false

	$entities

Detailed Description

Definition at line 71 of file PH5P.php.

Constructor & Destructor Documentation

◆ __construct()

HTML5::__construct ( $data )

Definition at line 462 of file PH5P.php.

References $data, and EOF.

     {
         $this->data = $data;
         $this->char = -1;
         $this->EOF = strlen($data);
         $this->tree = new HTML5TreeConstructer;
         $this->content_model = self::PCDATA;
 
         $this->state = 'data';
 
         while ($this->state !== null) {
             $this->{$this->state . 'State'}();
         }
     }

Member Function Documentation

◆ afterAttributeNameState()

HTML5::afterAttributeNameState ( )

private

Definition at line 956 of file PH5P.php.

References EOF.

     {
         // Consume the next input character:
         $this->char++;
         $char = $this->character($this->char);
 
         if (preg_match('/^[\t\n\x0b\x0c ]$/', $char)) {
             /* U+0009 CHARACTER TABULATION
             U+000A LINE FEED (LF)
             U+000B LINE TABULATION
             U+000C FORM FEED (FF)
             U+0020 SPACE
             Stay in the after attribute name state. */
             $this->state = 'afterAttributeName';
 
         } elseif ($char === '=') {
             /* U+003D EQUALS SIGN (=)
             Switch to the before attribute value state. */
             $this->state = 'beforeAttributeValue';
 
         } elseif ($char === '>') {
             /* U+003E GREATER-THAN SIGN (>)
             Emit the current tag token. Switch to the data state. */
             $this->emitToken($this->token);
             $this->state = 'data';
 
         } elseif ($char === '/' && $this->character($this->char + 1) !== '>') {
             /* U+002F SOLIDUS (/)
             Parse error unless this is a permitted slash. Switch to the
             before attribute name state. */
             $this->state = 'beforeAttributeName';
 
         } elseif ($this->char === $this->EOF) {
             /* EOF
             Parse error. Emit the current tag token. Reconsume the EOF
             character in the data state. */
             $this->emitToken($this->token);
 
             $this->char--;
             $this->state = 'data';
 
         } else {
             /* Anything else
             Start a new attribute in the current tag token. Set that attribute's
             name to the current input character, and its value to the empty string.
             Switch to the attribute name state. */
             $this->token['attr'][] = array(
                 'name' => strtolower($char),
                 'value' => null
             );
 
             $this->state = 'attributeName';
         }
     }

◆ afterDoctypeNameState()

HTML5::afterDoctypeNameState ( )

private

Definition at line 1419 of file PH5P.php.

References EOF.

     {
         /* Consume the next input character: */
         $this->char++;
         $char = $this->char();
 
         if (preg_match('/^[\t\n\x0b\x0c ]$/', $char)) {
             // Stay in the DOCTYPE name state.
 
         } elseif ($char === '>') {
             $this->emitToken($this->token);
             $this->state = 'data';
 
         } elseif ($this->char === $this->EOF) {
             $this->emitToken($this->token);
             $this->char--;
             $this->state = 'data';
 
         } else {
             $this->token['error'] = true;
             $this->state = 'bogusDoctype';
         }
     }

◆ attributeNameState()

HTML5::attributeNameState ( )

private

Definition at line 904 of file PH5P.php.

References EOF.

     {
         // Consume the next input character:
         $this->char++;
         $char = $this->character($this->char);
 
         if (preg_match('/^[\t\n\x0b\x0c ]$/', $char)) {
             /* U+0009 CHARACTER TABULATION
             U+000A LINE FEED (LF)
             U+000B LINE TABULATION
             U+000C FORM FEED (FF)
             U+0020 SPACE
             Stay in the before attribute name state. */
             $this->state = 'afterAttributeName';
 
         } elseif ($char === '=') {
             /* U+003D EQUALS SIGN (=)
             Switch to the before attribute value state. */
             $this->state = 'beforeAttributeValue';
 
         } elseif ($char === '>') {
             /* U+003E GREATER-THAN SIGN (>)
             Emit the current tag token. Switch to the data state. */
             $this->emitToken($this->token);
             $this->state = 'data';
 
         } elseif ($char === '/' && $this->character($this->char + 1) !== '>') {
             /* U+002F SOLIDUS (/)
             Parse error unless this is a permitted slash. Switch to the before
             attribute name state. */
             $this->state = 'beforeAttributeName';
 
         } elseif ($this->char === $this->EOF) {
             /* EOF
             Parse error. Emit the current tag token. Reconsume the EOF
             character in the data state. */
             $this->emitToken($this->token);
 
             $this->char--;
             $this->state = 'data';
 
         } else {
             /* Anything else
             Append the current input character to the current attribute's name.
             Stay in the attribute name state. */
             $last = count($this->token['attr']) - 1;
             $this->token['attr'][$last]['name'] .= strtolower($char);
 
             $this->state = 'attributeName';
         }
     }

◆ attributeValueDoubleQuotedState()

HTML5::attributeValueDoubleQuotedState ( )

private

Definition at line 1060 of file PH5P.php.

References EOF.

     {
         // Consume the next input character:
         $this->char++;
         $char = $this->character($this->char);
 
         if ($char === '"') {
             /* U+0022 QUOTATION MARK (")
             Switch to the before attribute name state. */
             $this->state = 'beforeAttributeName';
 
         } elseif ($char === '&') {
             /* U+0026 AMPERSAND (&)
             Switch to the entity in attribute value state. */
             $this->entityInAttributeValueState('double');
 
         } elseif ($this->char === $this->EOF) {
             /* EOF
             Parse error. Emit the current tag token. Reconsume the character
             in the data state. */
             $this->emitToken($this->token);
 
             $this->char--;
             $this->state = 'data';
 
         } else {
             /* Anything else
             Append the current input character to the current attribute's value.
             Stay in the attribute value (double-quoted) state. */
             $last = count($this->token['attr']) - 1;
             $this->token['attr'][$last]['value'] .= $char;
 
             $this->state = 'attributeValueDoubleQuoted';
         }
     }

◆ attributeValueSingleQuotedState()

HTML5::attributeValueSingleQuotedState ( )

private

Definition at line 1096 of file PH5P.php.

References EOF.

     {
         // Consume the next input character:
         $this->char++;
         $char = $this->character($this->char);
 
         if ($char === '\'') {
             /* U+0022 QUOTATION MARK (')
             Switch to the before attribute name state. */
             $this->state = 'beforeAttributeName';
 
         } elseif ($char === '&') {
             /* U+0026 AMPERSAND (&)
             Switch to the entity in attribute value state. */
             $this->entityInAttributeValueState('single');
 
         } elseif ($this->char === $this->EOF) {
             /* EOF
             Parse error. Emit the current tag token. Reconsume the character
             in the data state. */
             $this->emitToken($this->token);
 
             $this->char--;
             $this->state = 'data';
 
         } else {
             /* Anything else
             Append the current input character to the current attribute's value.
             Stay in the attribute value (single-quoted) state. */
             $last = count($this->token['attr']) - 1;
             $this->token['attr'][$last]['value'] .= $char;
 
             $this->state = 'attributeValueSingleQuoted';
         }
     }

◆ attributeValueUnquotedState()

HTML5::attributeValueUnquotedState ( )

private

Definition at line 1132 of file PH5P.php.

     {
         // Consume the next input character:
         $this->char++;
         $char = $this->character($this->char);
 
         if (preg_match('/^[\t\n\x0b\x0c ]$/', $char)) {
             /* U+0009 CHARACTER TABULATION
             U+000A LINE FEED (LF)
             U+000B LINE TABULATION
             U+000C FORM FEED (FF)
             U+0020 SPACE
             Switch to the before attribute name state. */
             $this->state = 'beforeAttributeName';
 
         } elseif ($char === '&') {
             /* U+0026 AMPERSAND (&)
             Switch to the entity in attribute value state. */
             $this->entityInAttributeValueState();
 
         } elseif ($char === '>') {
             /* U+003E GREATER-THAN SIGN (>)
             Emit the current tag token. Switch to the data state. */
             $this->emitToken($this->token);
             $this->state = 'data';
 
         } else {
             /* Anything else
             Append the current input character to the current attribute's value.
             Stay in the attribute value (unquoted) state. */
             $last = count($this->token['attr']) - 1;
             $this->token['attr'][$last]['value'] .= $char;
 
             $this->state = 'attributeValueUnquoted';
         }
     }

◆ beforeAttributeNameState()

HTML5::beforeAttributeNameState ( )

private

Definition at line 854 of file PH5P.php.

References EOF.

     {
         // Consume the next input character:
         $this->char++;
         $char = $this->character($this->char);
 
         if (preg_match('/^[\t\n\x0b\x0c ]$/', $char)) {
             /* U+0009 CHARACTER TABULATION
             U+000A LINE FEED (LF)
             U+000B LINE TABULATION
             U+000C FORM FEED (FF)
             U+0020 SPACE
             Stay in the before attribute name state. */
             $this->state = 'beforeAttributeName';
 
         } elseif ($char === '>') {
             /* U+003E GREATER-THAN SIGN (>)
             Emit the current tag token. Switch to the data state. */
             $this->emitToken($this->token);
             $this->state = 'data';
 
         } elseif ($char === '/') {
             /* U+002F SOLIDUS (/)
             Parse error unless this is a permitted slash. Stay in the before
             attribute name state. */
             $this->state = 'beforeAttributeName';
 
         } elseif ($this->char === $this->EOF) {
             /* EOF
             Parse error. Emit the current tag token. Reconsume the EOF
             character in the data state. */
             $this->emitToken($this->token);
 
             $this->char--;
             $this->state = 'data';
 
         } else {
             /* Anything else
             Start a new attribute in the current tag token. Set that attribute's
             name to the current input character, and its value to the empty string.
             Switch to the attribute name state. */
             $this->token['attr'][] = array(
                 'name' => strtolower($char),
                 'value' => null
             );
 
             $this->state = 'attributeName';
         }
     }

◆ beforeAttributeValueState()

HTML5::beforeAttributeValueState ( )

private

Definition at line 1011 of file PH5P.php.

     {
         // Consume the next input character:
         $this->char++;
         $char = $this->character($this->char);
 
         if (preg_match('/^[\t\n\x0b\x0c ]$/', $char)) {
             /* U+0009 CHARACTER TABULATION
             U+000A LINE FEED (LF)
             U+000B LINE TABULATION
             U+000C FORM FEED (FF)
             U+0020 SPACE
             Stay in the before attribute value state. */
             $this->state = 'beforeAttributeValue';
 
         } elseif ($char === '"') {
             /* U+0022 QUOTATION MARK (")
             Switch to the attribute value (double-quoted) state. */
             $this->state = 'attributeValueDoubleQuoted';
 
         } elseif ($char === '&') {
             /* U+0026 AMPERSAND (&)
             Switch to the attribute value (unquoted) state and reconsume
             this input character. */
             $this->char--;
             $this->state = 'attributeValueUnquoted';
 
         } elseif ($char === '\'') {
             /* U+0027 APOSTROPHE (')
             Switch to the attribute value (single-quoted) state. */
             $this->state = 'attributeValueSingleQuoted';
 
         } elseif ($char === '>') {
             /* U+003E GREATER-THAN SIGN (>)
             Emit the current tag token. Switch to the data state. */
             $this->emitToken($this->token);
             $this->state = 'data';
 
         } else {
             /* Anything else
             Append the current input character to the current attribute's value.
             Switch to the attribute value (unquoted) state. */
             $last = count($this->token['attr']) - 1;
             $this->token['attr'][$last]['value'] .= $char;
 
             $this->state = 'attributeValueUnquoted';
         }
     }

◆ beforeDoctypeNameState()

HTML5::beforeDoctypeNameState ( )

private

Definition at line 1337 of file PH5P.php.

References EOF.

     {
         /* Consume the next input character: */
         $this->char++;
         $char = $this->char();
 
         if (preg_match('/^[\t\n\x0b\x0c ]$/', $char)) {
             // Stay in the before DOCTYPE name state.
 
         } elseif (preg_match('/^[a-z]$/', $char)) {
             $this->token = array(
                 'name' => strtoupper($char),
                 'type' => self::DOCTYPE,
                 'error' => true
             );
 
             $this->state = 'doctypeName';
 
         } elseif ($char === '>') {
             $this->emitToken(
                 array(
                     'name' => null,
                     'type' => self::DOCTYPE,
                     'error' => true
                 )
             );
 
             $this->state = 'data';
 
         } elseif ($this->char === $this->EOF) {
             $this->emitToken(
                 array(
                     'name' => null,
                     'type' => self::DOCTYPE,
                     'error' => true
                 )
             );
 
             $this->char--;
             $this->state = 'data';
 
         } else {
             $this->token = array(
                 'name' => $char,
                 'type' => self::DOCTYPE,
                 'error' => true
             );
 
             $this->state = 'doctypeName';
         }
     }

◆ bogusCommentState()

HTML5::bogusCommentState ( )

private

Definition at line 1185 of file PH5P.php.

References $data, and EOF.

     {
         /* Consume every character up to the first U+003E GREATER-THAN SIGN
         character (>) or the end of the file (EOF), whichever comes first. Emit
         a comment token whose data is the concatenation of all the characters
         starting from and including the character that caused the state machine
         to switch into the bogus comment state, up to and including the last
         consumed character before the U+003E character, if any, or up to the
         end of the file otherwise. (If the comment was started by the end of
         the file (EOF), the token is empty.) */
         $data = $this->characters('^>', $this->char);
         $this->emitToken(
             array(
                 'data' => $data,
                 'type' => self::COMMENT
             )
         );
 
         $this->char += strlen($data);
 
         /* Switch to the data state. */
         $this->state = 'data';
 
         /* If the end of the file was reached, reconsume the EOF character. */
         if ($this->char === $this->EOF) {
             $this->char = $this->EOF - 1;
         }
     }

◆ bogusDoctypeState()

HTML5::bogusDoctypeState ( )

private

Definition at line 1443 of file PH5P.php.

References EOF.

     {
         /* Consume the next input character: */
         $this->char++;
         $char = $this->char();
 
         if ($char === '>') {
             $this->emitToken($this->token);
             $this->state = 'data';
 
         } elseif ($this->char === $this->EOF) {
             $this->emitToken($this->token);
             $this->char--;
             $this->state = 'data';
 
         } else {
             // Stay in the bogus DOCTYPE state.
         }
     }

◆ char()

HTML5::char ( )

private

Definition at line 482 of file PH5P.php.

References EOF.

     {
         return ($this->char < $this->EOF)
             ? $this->data[$this->char]
             : false;
     }

◆ character()

HTML5::character	(	$s,
		$l = `0`
	)

private

Definition at line 489 of file PH5P.php.

References EOF.

     {
         if ($s + $l < $this->EOF) {
             if ($l === 0) {
                 return $this->data[$s];
             } else {
                 return substr($this->data, $s, $l);
             }
         }
     }

◆ characters()

HTML5::characters	(	$char_class,
		$start
	)

private

Definition at line 500 of file PH5P.php.

     {
         return preg_replace('#^([' . $char_class . ']+).*#s', '\\1', substr($this->data, $start));
     }

◆ closeTagOpenState()

HTML5::closeTagOpenState ( )

private

Definition at line 728 of file PH5P.php.

References EOF.

     {
         $next_node = strtolower($this->characters('A-Za-z', $this->char + 1));
         $the_same = count($this->tree->stack) > 0 && $next_node === end($this->tree->stack)->nodeName;
 
         if (($this->content_model === self::RCDATA || $this->content_model === self::CDATA) &&
             (!$the_same || ($the_same && (!preg_match(
                             '/[\t\n\x0b\x0c >\/]/',
                             $this->character($this->char + 1 + strlen($next_node))
                         ) || $this->EOF === $this->char)))
         ) {
             /* If the content model flag is set to the RCDATA or CDATA states then
             examine the next few characters. If they do not match the tag name of
             the last start tag token emitted (case insensitively), or if they do but
             they are not immediately followed by one of the following characters:
                 * U+0009 CHARACTER TABULATION
                 * U+000A LINE FEED (LF)
                 * U+000B LINE TABULATION
                 * U+000C FORM FEED (FF)
                 * U+0020 SPACE
                 * U+003E GREATER-THAN SIGN (>)
                 * U+002F SOLIDUS (/)
                 * EOF
             ...then there is a parse error. Emit a U+003C LESS-THAN SIGN character
             token, a U+002F SOLIDUS character token, and switch to the data state
             to process the next input character. */
             $this->emitToken(
                 array(
                     'type' => self::CHARACTR,
                     'data' => '</'
                 )
             );
 
             $this->state = 'data';
 
         } else {
             /* Otherwise, if the content model flag is set to the PCDATA state,
             or if the next few characters do match that tag name, consume the
             next input character: */
             $this->char++;
             $char = $this->char();
 
             if (preg_match('/^[A-Za-z]$/', $char)) {
                 /* U+0041 LATIN LETTER A through to U+005A LATIN LETTER Z
                 Create a new end tag token, set its tag name to the lowercase version
                 of the input character (add 0x0020 to the character's code point), then
                 switch to the tag name state. (Don't emit the token yet; further details
                 will be filled in before it is emitted.) */
                 $this->token = array(
                     'name' => strtolower($char),
                     'type' => self::ENDTAG
                 );
 
                 $this->state = 'tagName';
 
             } elseif ($char === '>') {
                 /* U+003E GREATER-THAN SIGN (>)
                 Parse error. Switch to the data state. */
                 $this->state = 'data';
 
             } elseif ($this->char === $this->EOF) {
                 /* EOF
                 Parse error. Emit a U+003C LESS-THAN SIGN character token and a U+002F
                 SOLIDUS character token. Reconsume the EOF character in the data state. */
                 $this->emitToken(
                     array(
                         'type' => self::CHARACTR,
                         'data' => '</'
                     )
                 );
 
                 $this->char--;
                 $this->state = 'data';
 
             } else {
                 /* Parse error. Switch to the bogus comment state. */
                 $this->state = 'bogusComment';
             }
         }
     }

◆ commentDashState()

HTML5::commentDashState ( )

private

Definition at line 1270 of file PH5P.php.

References EOF.

     {
         /* Consume the next input character: */
         $this->char++;
         $char = $this->char();
 
         /* U+002D HYPHEN-MINUS (-) */
         if ($char === '-') {
             /* Switch to the comment end state  */
             $this->state = 'commentEnd';
 
             /* EOF */
         } elseif ($this->char === $this->EOF) {
             /* Parse error. Emit the comment token. Reconsume the EOF character
             in the data state. */
             $this->emitToken($this->token);
             $this->char--;
             $this->state = 'data';
 
             /* Anything else */
         } else {
             /* Append a U+002D HYPHEN-MINUS (-) character and the input
             character to the comment token's data. Switch to the comment state. */
             $this->token['data'] .= '-' . $char;
             $this->state = 'comment';
         }
     }

◆ commentEndState()

HTML5::commentEndState ( )

private

Definition at line 1298 of file PH5P.php.

References EOF.

     {
         /* Consume the next input character: */
         $this->char++;
         $char = $this->char();
 
         if ($char === '>') {
             $this->emitToken($this->token);
             $this->state = 'data';
 
         } elseif ($char === '-') {
             $this->token['data'] .= '-';
 
         } elseif ($this->char === $this->EOF) {
             $this->emitToken($this->token);
             $this->char--;
             $this->state = 'data';
 
         } else {
             $this->token['data'] .= '--' . $char;
             $this->state = 'comment';
         }
     }

◆ commentState()

HTML5::commentState ( )

private

Definition at line 1243 of file PH5P.php.

References EOF.

     {
         /* Consume the next input character: */
         $this->char++;
         $char = $this->char();
 
         /* U+002D HYPHEN-MINUS (-) */
         if ($char === '-') {
             /* Switch to the comment dash state  */
             $this->state = 'commentDash';
 
             /* EOF */
         } elseif ($this->char === $this->EOF) {
             /* Parse error. Emit the comment token. Reconsume the EOF character
             in the data state. */
             $this->emitToken($this->token);
             $this->char--;
             $this->state = 'data';
 
             /* Anything else */
         } else {
             /* Append the input character to the comment token's data. Stay in
             the comment state. */
             $this->token['data'] .= $char;
         }
     }

◆ dataState()

HTML5::dataState ( )

private

Definition at line 505 of file PH5P.php.

References EOF.

     {
         // Consume the next input character
         $this->char++;
         $char = $this->char();
 
         if ($char === '&' && ($this->content_model === self::PCDATA || $this->content_model === self::RCDATA)) {
             /* U+0026 AMPERSAND (&)
             When the content model flag is set to one of the PCDATA or RCDATA
             states: switch to the entity data state. Otherwise: treat it as per
             the "anything else"    entry below. */
             $this->state = 'entityData';
 
         } elseif ($char === '-') {
             /* If the content model flag is set to either the RCDATA state or
             the CDATA state, and the escape flag is false, and there are at
             least three characters before this one in the input stream, and the
             last four characters in the input stream, including this one, are
             U+003C LESS-THAN SIGN, U+0021 EXCLAMATION MARK, U+002D HYPHEN-MINUS,
             and U+002D HYPHEN-MINUS ("<!--"), then set the escape flag to true. */
             if (($this->content_model === self::RCDATA || $this->content_model ===
                     self::CDATA) && $this->escape === false &&
                 $this->char >= 3 && $this->character($this->char - 4, 4) === '<!--'
             ) {
                 $this->escape = true;
             }
 
             /* In any case, emit the input character as a character token. Stay
             in the data state. */
             $this->emitToken(
                 array(
                     'type' => self::CHARACTR,
                     'data' => $char
                 )
             );
 
             /* U+003C LESS-THAN SIGN (<) */
         } elseif ($char === '<' && ($this->content_model === self::PCDATA ||
                 (($this->content_model === self::RCDATA ||
                         $this->content_model === self::CDATA) && $this->escape === false))
         ) {
             /* When the content model flag is set to the PCDATA state: switch
             to the tag open state.
 
             When the content model flag is set to either the RCDATA state or
             the CDATA state and the escape flag is false: switch to the tag
             open state.
 
             Otherwise: treat it as per the "anything else" entry below. */
             $this->state = 'tagOpen';
 
             /* U+003E GREATER-THAN SIGN (>) */
         } elseif ($char === '>') {
             /* If the content model flag is set to either the RCDATA state or
             the CDATA state, and the escape flag is true, and the last three
             characters in the input stream including this one are U+002D
             HYPHEN-MINUS, U+002D HYPHEN-MINUS, U+003E GREATER-THAN SIGN ("-->"),
             set the escape flag to false. */
             if (($this->content_model === self::RCDATA ||
                     $this->content_model === self::CDATA) && $this->escape === true &&
                 $this->character($this->char, 3) === '-->'
             ) {
                 $this->escape = false;
             }
 
             /* In any case, emit the input character as a character token.
             Stay in the data state. */
             $this->emitToken(
                 array(
                     'type' => self::CHARACTR,
                     'data' => $char
                 )
             );
 
         } elseif ($this->char === $this->EOF) {
             /* EOF
             Emit an end-of-file token. */
             $this->EOF();
 
         } elseif ($this->content_model === self::PLAINTEXT) {
             /* When the content model flag is set to the PLAINTEXT state
             THIS DIFFERS GREATLY FROM THE SPEC: Get the remaining characters of
             the text and emit it as a character token. */
             $this->emitToken(
                 array(
                     'type' => self::CHARACTR,
                     'data' => substr($this->data, $this->char)
                 )
             );
 
             $this->EOF();
 
         } else {
             /* Anything else
             THIS DIFFERS GREATLY FROM THE SPEC: Get as many character that
             otherwise would also be treated as a character token and emit it
             as a single character token. Stay in the data state. */
             $len = strcspn($this->data, '<&', $this->char);
             $char = substr($this->data, $this->char, $len);
             $this->char += $len - 1;
 
             $this->emitToken(
                 array(
                     'type' => self::CHARACTR,
                     'data' => $char
                 )
             );
 
             $this->state = 'data';
         }
     }

◆ doctypeNameState()

HTML5::doctypeNameState ( )

private

Definition at line 1389 of file PH5P.php.

References EOF.

     {
         /* Consume the next input character: */
         $this->char++;
         $char = $this->char();
 
         if (preg_match('/^[\t\n\x0b\x0c ]$/', $char)) {
             $this->state = 'AfterDoctypeName';
 
         } elseif ($char === '>') {
             $this->emitToken($this->token);
             $this->state = 'data';
 
         } elseif (preg_match('/^[a-z]$/', $char)) {
             $this->token['name'] .= strtoupper($char);
 
         } elseif ($this->char === $this->EOF) {
             $this->emitToken($this->token);
             $this->char--;
             $this->state = 'data';
 
         } else {
             $this->token['name'] .= $char;
         }
 
         $this->token['error'] = ($this->token['name'] === 'HTML')
             ? false
             : true;
     }

◆ doctypeState()

HTML5::doctypeState ( )

private

Definition at line 1322 of file PH5P.php.

     {
         /* Consume the next input character: */
         $this->char++;
         $char = $this->char();
 
         if (preg_match('/^[\t\n\x0b\x0c ]$/', $char)) {
             $this->state = 'beforeDoctypeName';
 
         } else {
             $this->char--;
             $this->state = 'beforeDoctypeName';
         }
     }

◆ emitToken()

HTML5::emitToken ( $token )

private

Definition at line 1554 of file PH5P.php.

     {
         $emit = $this->tree->emitToken($token);
 
         if (is_int($emit)) {
             $this->content_model = $emit;
 
         } elseif ($token['type'] === self::ENDTAG) {
             $this->content_model = self::PCDATA;
         }
     }

◆ entity()

HTML5::entity ( )

private

Definition at line 1463 of file PH5P.php.

     {
         $start = $this->char;
 
         // This section defines how to consume an entity. This definition is
         // used when parsing entities in text and in attributes.
 
         // The behaviour depends on the identity of the next character (the
         // one immediately after the U+0026 AMPERSAND character):
 
         switch ($this->character($this->char + 1)) {
             // U+0023 NUMBER SIGN (#)
             case '#':
 
                 // The behaviour further depends on the character after the
                 // U+0023 NUMBER SIGN:
                 switch ($this->character($this->char + 1)) {
                     // U+0078 LATIN SMALL LETTER X
                     // U+0058 LATIN CAPITAL LETTER X
                     case 'x':
                     case 'X':
                         // Follow the steps below, but using the range of
                         // characters U+0030 DIGIT ZERO through to U+0039 DIGIT
                         // NINE, U+0061 LATIN SMALL LETTER A through to U+0066
                         // LATIN SMALL LETTER F, and U+0041 LATIN CAPITAL LETTER
                         // A, through to U+0046 LATIN CAPITAL LETTER F (in other
                         // words, 0-9, A-F, a-f).
                         $char = 1;
                         $char_class = '0-9A-Fa-f';
                         break;
 
                     // Anything else
                     default:
                         // Follow the steps below, but using the range of
                         // characters U+0030 DIGIT ZERO through to U+0039 DIGIT
                         // NINE (i.e. just 0-9).
                         $char = 0;
                         $char_class = '0-9';
                         break;
                 }
 
                 // Consume as many characters as match the range of characters
                 // given above.
                 $this->char++;
                 $e_name = $this->characters($char_class, $this->char + $char + 1);
                 $entity = $this->character($start, $this->char);
                 $cond = strlen($e_name) > 0;
 
                 // The rest of the parsing happens bellow.
                 break;
 
             // Anything else
             default:
                 // Consume the maximum number of characters possible, with the
                 // consumed characters case-sensitively matching one of the
                 // identifiers in the first column of the entities table.
                 $e_name = $this->characters('0-9A-Za-z;', $this->char + 1);
                 $len = strlen($e_name);
 
                 for ($c = 1; $c <= $len; $c++) {
                     $id = substr($e_name, 0, $c);
                     $this->char++;
 
                     if (in_array($id, $this->entities)) {
                         if ($e_name[$c - 1] !== ';') {
                             if ($c < $len && $e_name[$c] == ';') {
                                 $this->char++; // consume extra semicolon
                             }
                         }
                         $entity = $id;
                         break;
                     }
                 }
 
                 $cond = isset($entity);
                 // The rest of the parsing happens bellow.
                 break;
         }
 
         if (!$cond) {
             // If no match can be made, then this is a parse error. No
             // characters are consumed, and nothing is returned.
             $this->char = $start;
             return false;
         }
 
         // Return a character token for the character corresponding to the
         // entity name (as given by the second column of the entities table).
         return html_entity_decode('&' . $entity . ';', ENT_QUOTES, 'UTF-8');
     }

◆ entityDataState()

HTML5::entityDataState ( )

private

Definition at line 617 of file PH5P.php.

     {
         // Attempt to consume an entity.
         $entity = $this->entity();
 
         // If nothing is returned, emit a U+0026 AMPERSAND character token.
         // Otherwise, emit the character token that was returned.
         $char = (!$entity) ? '&' : $entity;
         $this->emitToken(
             array(
                 'type' => self::CHARACTR,
                 'data' => $char
             )
         );
 
         // Finally, switch to the data state.
         $this->state = 'data';
     }

◆ entityInAttributeValueState()

HTML5::entityInAttributeValueState ( )

private

Definition at line 1169 of file PH5P.php.

     {
         // Attempt to consume an entity.
         $entity = $this->entity();
 
         // If nothing is returned, append a U+0026 AMPERSAND character to the
         // current attribute's value. Otherwise, emit the character token that
         // was returned.
         $char = (!$entity)
             ? '&'
             : $entity;
 
         $last = count($this->token['attr']) - 1;
         $this->token['attr'][$last]['value'] .= $char;
     }

◆ EOF()

HTML5::EOF ( )

private

Definition at line 1566 of file PH5P.php.

References EOF.

Referenced by HTML5TreeConstructer\initPhase(), HTML5TreeConstructer\mainPhase(), HTML5TreeConstructer\rootElementPhase(), and HTML5TreeConstructer\trailingEndPhase().

     {
         $this->state = null;
         $this->tree->emitToken(
             array(
                 'type' => self::EOF
             )
         );
     }

Here is the caller graph for this function:

◆ markupDeclarationOpenState()

HTML5::markupDeclarationOpenState ( )

private

Definition at line 1214 of file PH5P.php.

     {
         /* If the next two characters are both U+002D HYPHEN-MINUS (-)
         characters, consume those two characters, create a comment token whose
         data is the empty string, and switch to the comment state. */
         if ($this->character($this->char + 1, 2) === '--') {
             $this->char += 2;
             $this->state = 'comment';
             $this->token = array(
                 'data' => null,
                 'type' => self::COMMENT
             );
 
             /* Otherwise if the next seven chacacters are a case-insensitive match
             for the word "DOCTYPE", then consume those characters and switch to the
             DOCTYPE state. */
         } elseif (strtolower($this->character($this->char + 1, 7)) === 'doctype') {
             $this->char += 7;
             $this->state = 'doctype';
 
             /* Otherwise, is is a parse error. Switch to the bogus comment state.
             The next character that is consumed, if any, is the first character
             that will be in the comment. */
         } else {
             $this->char++;
             $this->state = 'bogusComment';
         }
     }

◆ save()

HTML5::save ( )

Definition at line 477 of file PH5P.php.

     {
         return $this->tree->save();
     }

◆ tagNameState()

HTML5::tagNameState ( )

private

Definition at line 809 of file PH5P.php.

References EOF.

     {
         // Consume the next input character:
         $this->char++;
         $char = $this->character($this->char);
 
         if (preg_match('/^[\t\n\x0b\x0c ]$/', $char)) {
             /* U+0009 CHARACTER TABULATION
             U+000A LINE FEED (LF)
             U+000B LINE TABULATION
             U+000C FORM FEED (FF)
             U+0020 SPACE
             Switch to the before attribute name state. */
             $this->state = 'beforeAttributeName';
 
         } elseif ($char === '>') {
             /* U+003E GREATER-THAN SIGN (>)
             Emit the current tag token. Switch to the data state. */
             $this->emitToken($this->token);
             $this->state = 'data';
 
         } elseif ($this->char === $this->EOF) {
             /* EOF
             Parse error. Emit the current tag token. Reconsume the EOF
             character in the data state. */
             $this->emitToken($this->token);
 
             $this->char--;
             $this->state = 'data';
 
         } elseif ($char === '/') {
             /* U+002F SOLIDUS (/)
             Parse error unless this is a permitted slash. Switch to the before
             attribute name state. */
             $this->state = 'beforeAttributeName';
 
         } else {
             /* Anything else
             Append the current input character to the current tag token's tag name.
             Stay in the tag name state. */
             $this->token['name'] .= strtolower($char);
             $this->state = 'tagName';
         }
     }

◆ tagOpenState()

HTML5::tagOpenState ( )

private

Definition at line 636 of file PH5P.php.

     {
         switch ($this->content_model) {
             case self::RCDATA:
             case self::CDATA:
                 /* If the next input character is a U+002F SOLIDUS (/) character,
                 consume it and switch to the close tag open state. If the next
                 input character is not a U+002F SOLIDUS (/) character, emit a
                 U+003C LESS-THAN SIGN character token and switch to the data
                 state to process the next input character. */
                 if ($this->character($this->char + 1) === '/') {
                     $this->char++;
                     $this->state = 'closeTagOpen';
 
                 } else {
                     $this->emitToken(
                         array(
                             'type' => self::CHARACTR,
                             'data' => '<'
                         )
                     );
 
                     $this->state = 'data';
                 }
                 break;
 
             case self::PCDATA:
                 // If the content model flag is set to the PCDATA state
                 // Consume the next input character:
                 $this->char++;
                 $char = $this->char();
 
                 if ($char === '!') {
                     /* U+0021 EXCLAMATION MARK (!)
                     Switch to the markup declaration open state. */
                     $this->state = 'markupDeclarationOpen';
 
                 } elseif ($char === '/') {
                     /* U+002F SOLIDUS (/)
                     Switch to the close tag open state. */
                     $this->state = 'closeTagOpen';
 
                 } elseif (preg_match('/^[A-Za-z]$/', $char)) {
                     /* U+0041 LATIN LETTER A through to U+005A LATIN LETTER Z
                     Create a new start tag token, set its tag name to the lowercase
                     version of the input character (add 0x0020 to the character's code
                     point), then switch to the tag name state. (Don't emit the token
                     yet; further details will be filled in before it is emitted.) */
                     $this->token = array(
                         'name' => strtolower($char),
                         'type' => self::STARTTAG,
                         'attr' => array()
                     );
 
                     $this->state = 'tagName';
 
                 } elseif ($char === '>') {
                     /* U+003E GREATER-THAN SIGN (>)
                     Parse error. Emit a U+003C LESS-THAN SIGN character token and a
                     U+003E GREATER-THAN SIGN character token. Switch to the data state. */
                     $this->emitToken(
                         array(
                             'type' => self::CHARACTR,
                             'data' => '<>'
                         )
                     );
 
                     $this->state = 'data';
 
                 } elseif ($char === '?') {
                     /* U+003F QUESTION MARK (?)
                     Parse error. Switch to the bogus comment state. */
                     $this->state = 'bogusComment';
 
                 } else {
                     /* Anything else
                     Parse error. Emit a U+003C LESS-THAN SIGN character token and
                     reconsume the current input character in the data state. */
                     $this->emitToken(
                         array(
                             'type' => self::CHARACTR,
                             'data' => '<'
                         )
                     );
 
                     $this->char--;
                     $this->state = 'data';
                 }
                 break;
         }
     }

Field Documentation

◆ $char

HTML5::$char

private

Definition at line 74 of file PH5P.php.

◆ $content_model

HTML5::$content_model

private

Definition at line 79 of file PH5P.php.

◆ $data

HTML5::$data

private

Definition at line 73 of file PH5P.php.

◆ $entities

HTML5::$entities

private

Definition at line 81 of file PH5P.php.

◆ $EOF

HTML5::$EOF

private

Definition at line 75 of file PH5P.php.

◆ $escape

HTML5::$escape = false

private

Definition at line 80 of file PH5P.php.

◆ $state

HTML5::$state

private

Definition at line 76 of file PH5P.php.

◆ $token

HTML5::$token

private

Definition at line 78 of file PH5P.php.

◆ $tree

HTML5::$tree

private

Definition at line 77 of file PH5P.php.

◆ CDATA

const HTML5::CDATA = 2

Definition at line 452 of file PH5P.php.

Referenced by HTML5TreeConstructer\inBody(), and HTML5TreeConstructer\inHead().

◆ CHARACTR

const HTML5::CHARACTR = 4

Definition at line 459 of file PH5P.php.

Referenced by HTML5TreeConstructer\afterBody(), HTML5TreeConstructer\afterFrameset(), HTML5TreeConstructer\afterHead(), HTML5TreeConstructer\beforeHead(), HTML5TreeConstructer\inBody(), HTML5TreeConstructer\inColumnGroup(), HTML5TreeConstructer\inFrameset(), HTML5TreeConstructer\inHead(), HTML5TreeConstructer\initPhase(), HTML5TreeConstructer\inSelect(), HTML5TreeConstructer\inTable(), HTML5TreeConstructer\rootElementPhase(), and HTML5TreeConstructer\trailingEndPhase().

◆ COMMENT

const HTML5::COMMENT = 3

Definition at line 458 of file PH5P.php.

Referenced by HTML5TreeConstructer\afterBody(), HTML5TreeConstructer\afterFrameset(), HTML5TreeConstructer\afterHead(), HTML5TreeConstructer\beforeHead(), HTML5TreeConstructer\inBody(), HTML5TreeConstructer\inColumnGroup(), HTML5TreeConstructer\inFrameset(), HTML5TreeConstructer\inHead(), HTML5TreeConstructer\initPhase(), HTML5TreeConstructer\inSelect(), HTML5TreeConstructer\inTable(), HTML5TreeConstructer\rootElementPhase(), and HTML5TreeConstructer\trailingEndPhase().

◆ DOCTYPE

const HTML5::DOCTYPE = 0

Definition at line 455 of file PH5P.php.

Referenced by HTML5TreeConstructer\mainPhase(), HTML5TreeConstructer\rootElementPhase(), and HTML5TreeConstructer\trailingEndPhase().

◆ ENDTAG

const HTML5::ENDTAG = 2

Definition at line 457 of file PH5P.php.

◆ EOF

const HTML5::EOF = 5

Definition at line 460 of file PH5P.php.

◆ PCDATA

const HTML5::PCDATA = 0

Definition at line 450 of file PH5P.php.

Referenced by HTML5TreeConstructer\inHead().

◆ PLAINTEXT

const HTML5::PLAINTEXT = 3

Definition at line 453 of file PH5P.php.

Referenced by HTML5TreeConstructer\inBody().

◆ RCDATA

const HTML5::RCDATA = 1

Definition at line 451 of file PH5P.php.

Referenced by HTML5TreeConstructer\inBody(), and HTML5TreeConstructer\inHead().

◆ STARTTAG

const HTML5::STARTTAG = 1

Definition at line 456 of file PH5P.php.

The documentation for this class was generated from the following file:

Services/Html/HtmlPurifier/library/HTMLPurifier/Lexer/PH5P.php

Public Member Functions

Data Fields

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __construct()

Member Function Documentation

◆ afterAttributeNameState()

◆ afterDoctypeNameState()

◆ attributeNameState()

◆ attributeValueDoubleQuotedState()

◆ attributeValueSingleQuotedState()

◆ attributeValueUnquotedState()

◆ beforeAttributeNameState()

◆ beforeAttributeValueState()

◆ beforeDoctypeNameState()

◆ bogusCommentState()

◆ bogusDoctypeState()

◆ char()

◆ character()

◆ characters()

◆ closeTagOpenState()

◆ commentDashState()

◆ commentEndState()

◆ commentState()

◆ dataState()

◆ doctypeNameState()

◆ doctypeState()

◆ emitToken()

◆ entity()

◆ entityDataState()

◆ entityInAttributeValueState()

◆ EOF()

◆ markupDeclarationOpenState()

◆ save()

◆ tagNameState()

◆ tagOpenState()

Field Documentation

◆ $char

◆ $content_model

◆ $data

◆ $entities

◆ $EOF

◆ $escape

◆ $state

◆ $token

◆ $tree

◆ CDATA

◆ CHARACTR

◆ COMMENT

◆ DOCTYPE

◆ ENDTAG

◆ EOF

◆ PCDATA

◆ PLAINTEXT

◆ RCDATA

◆ STARTTAG