dd/d0f/DOMLex_8php_source.html

<?php


class HTMLPurifier_Lexer_DOMLex extends HTMLPurifier_Lexer

{


    private $factory;


    public function __construct()

    {

        // setup the factory

        parent::__construct();

        $this->factory = new HTMLPurifier_TokenFactory();

    }


    public function tokenizeHTML($html, $config, $context)

    {

        $html = $this->normalize($html, $config, $context);


        // attempt to armor stray angled brackets that cannot possibly

        // form tags and thus are probably being used as emoticons

        if ($config->get('Core.AggressivelyFixLt')) {

            $char = '[^a-z!\/]';

            $comment = "/<!--(.*?)(-->|\z)/is";

            $html = preg_replace_callback($comment, array($this, 'callbackArmorCommentEntities'), $html);

            do {

                $old = $html;

                $html = preg_replace("/<($char)/i", '&lt;\\1', $html);

            } while ($html !== $old);

            $html = preg_replace_callback($comment, array($this, 'callbackUndoCommentSubst'), $html); // fix comments

        }


        // preprocess html, essential for UTF-8

        $html = $this->wrapHTML($html, $config, $context);


        $doc = new DOMDocument();

        $doc->encoding = 'UTF-8'; // theoretically, the above has this covered


        set_error_handler(array($this, 'muteErrorHandler'));

        $doc->loadHTML($html);

        restore_error_handler();


        $tokens = array();

        $this->tokenizeDOM(

            $doc->getElementsByTagName('html')->item(0)-> // <html>

            getElementsByTagName('body')->item(0), //   <body>

            $tokens

        );

        return $tokens;

    }


    protected function tokenizeDOM($node, &$tokens)

    {

        $level = 0;

        $nodes = array($level => new HTMLPurifier_Queue(array($node)));

        $closingNodes = array();

        do {

            while (!$nodes[$level]->isEmpty()) {

                $node = $nodes[$level]->shift(); // FIFO

                $collect = $level > 0 ? true : false;

                $needEndingTag = $this->createStartNode($node, $tokens, $collect);

                if ($needEndingTag) {

                    $closingNodes[$level][] = $node;

                }

                if ($node->childNodes && $node->childNodes->length) {

                    $level++;

                    $nodes[$level] = new HTMLPurifier_Queue();

                    foreach ($node->childNodes as $childNode) {

                        $nodes[$level]->push($childNode);

                    }

                }

            }

            $level--;

            if ($level && isset($closingNodes[$level])) {

                while ($node = array_pop($closingNodes[$level])) {

                    $this->createEndNode($node, $tokens);

                }

            }

        } while ($level > 0);

    }


    protected function createStartNode($node, &$tokens, $collect)

    {

        // intercept non element nodes. WE MUST catch all of them,

        // but we're not getting the character reference nodes because

        // those should have been preprocessed

        if ($node->nodeType === XML_TEXT_NODE) {

            $tokens[] = $this->factory->createText($node->data);

            return false;

        } elseif ($node->nodeType === XML_CDATA_SECTION_NODE) {

            // undo libxml's special treatment of <script> and <style> tags

            $last = end($tokens);

            $data = $node->data;

            // (note $node->tagname is already normalized)

            if ($last instanceof HTMLPurifier_Token_Start && ($last->name == 'script' || $last->name == 'style')) {

                $new_data = trim($data);

                if (substr($new_data, 0, 4) === '<!--') {

                    $data = substr($new_data, 4);

                    if (substr($data, -3) === '-->') {

                        $data = substr($data, 0, -3);

                    } else {

                        // Highly suspicious! Not sure what to do...

                    }

                }

            }

            $tokens[] = $this->factory->createText($this->parseData($data));

            return false;

        } elseif ($node->nodeType === XML_COMMENT_NODE) {

            // this is code is only invoked for comments in script/style in versions

            // of libxml pre-2.6.28 (regular comments, of course, are still

            // handled regularly)

            $tokens[] = $this->factory->createComment($node->data);

            return false;

        } elseif ($node->nodeType !== XML_ELEMENT_NODE) {

            // not-well tested: there may be other nodes we have to grab

            return false;

        }


        $attr = $node->hasAttributes() ? $this->transformAttrToAssoc($node->attributes) : array();


        // We still have to make sure that the element actually IS empty

        if (!$node->childNodes->length) {

            if ($collect) {

                $tokens[] = $this->factory->createEmpty($node->tagName, $attr);

            }

            return false;

        } else {

            if ($collect) {

                $tokens[] = $this->factory->createStart(

                    $tag_name = $node->tagName, // somehow, it get's dropped

                    $attr

                );

            }

            return true;

        }

    }


    protected function createEndNode($node, &$tokens)

    {

        $tokens[] = $this->factory->createEnd($node->tagName);

    }


    protected function transformAttrToAssoc($node_map)

    {

        // NamedNodeMap is documented very well, so we're using undocumented

        // features, namely, the fact that it implements Iterator and

        // has a ->length attribute

        if ($node_map->length === 0) {

            return array();

        }

        $array = array();

        foreach ($node_map as $attr) {

            $array[$attr->name] = $attr->value;

        }

        return $array;

    }


    public function muteErrorHandler($errno, $errstr)

    {

    }


    public function callbackUndoCommentSubst($matches)

    {

        return '<!--' . strtr($matches[1], array('&amp;' => '&', '&lt;' => '<')) . $matches[2];

    }


    public function callbackArmorCommentEntities($matches)

    {

        return '<!--' . str_replace('&', '&amp;', $matches[1]) . $matches[2];

    }


    protected function wrapHTML($html, $config, $context)

    {

        $def = $config->getDefinition('HTML');

        $ret = '';


        if (!empty($def->doctype->dtdPublic) || !empty($def->doctype->dtdSystem)) {

            $ret .= '<!DOCTYPE html ';

            if (!empty($def->doctype->dtdPublic)) {

                $ret .= 'PUBLIC "' . $def->doctype->dtdPublic . '" ';

            }

            if (!empty($def->doctype->dtdSystem)) {

                $ret .= '"' . $def->doctype->dtdSystem . '" ';

            }

            $ret .= '>';

        }


        $ret .= '<html><head>';

        $ret .= '<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />';

        // No protection if $html contains a stray </div>!

        $ret .= '</head><body>' . $html . '</body></html>';

        return $ret;

    }

}


// vim: et sw=4 sts=4

$comment
$comment
Definition: buildRTE.php:83

php
An exception for terminatinating execution or to throw for unit testing.

HTMLPurifier_Lexer_DOMLex
Parser that uses PHP 5's DOM extension (part of the core).
Definition: DOMLex.php:28

HTMLPurifier_Lexer_DOMLex\__construct
__construct()
Definition: DOMLex.php:35

HTMLPurifier_Lexer_DOMLex\callbackArmorCommentEntities
callbackArmorCommentEntities($matches)
Callback function that entity-izes ampersands in comments so that callbackUndoCommentSubst doesn't cl...
Definition: DOMLex.php:243

HTMLPurifier_Lexer_DOMLex\callbackUndoCommentSubst
callbackUndoCommentSubst($matches)
Callback function for undoing escaping of stray angled brackets in comments.
Definition: DOMLex.php:232

HTMLPurifier_Lexer_DOMLex\createEndNode
createEndNode($node, &$tokens)
Definition: DOMLex.php:190

HTMLPurifier_Lexer_DOMLex\wrapHTML
wrapHTML($html, $config, $context)
Wraps an HTML fragment in the necessary HTML.
Definition: DOMLex.php:255

HTMLPurifier_Lexer_DOMLex\tokenizeHTML
tokenizeHTML($html, $config, $context)
Definition: DOMLex.php:48

HTMLPurifier_Lexer_DOMLex\transformAttrToAssoc
transformAttrToAssoc($node_map)
Converts a DOMNamedNodeMap of DOMAttr objects into an assoc array.
Definition: DOMLex.php:202

HTMLPurifier_Lexer_DOMLex\muteErrorHandler
muteErrorHandler($errno, $errstr)
An error handler that mutes all errors.
Definition: DOMLex.php:222

HTMLPurifier_Lexer_DOMLex\tokenizeDOM
tokenizeDOM($node, &$tokens)
Iterative function that tokenizes a node, putting it into an accumulator.
Definition: DOMLex.php:91

HTMLPurifier_Lexer_DOMLex\createStartNode
createStartNode($node, &$tokens, $collect)
Definition: DOMLex.php:130

HTMLPurifier_Lexer_DOMLex\$factory
$factory
@type HTMLPurifier_TokenFactory
Definition: DOMLex.php:33

HTMLPurifier_Lexer
Forgivingly lexes HTML (SGML-style) markup into tokens.
Definition: Lexer.php:43

HTMLPurifier_Lexer\normalize
normalize($html, $config, $context)
Takes a piece of HTML and normalizes it by converting entities, fixing encoding, extracting bits,...
Definition: Lexer.php:294

HTMLPurifier_Lexer\parseData
parseData($string)
Parses special entities into the proper characters.
Definition: Lexer.php:186

HTMLPurifier_Queue
A simple array-backed queue, based off of the classic Okasaki persistent amortized queue.
Definition: Queue.php:20

HTMLPurifier_TokenFactory
Factory for token generation.
Definition: TokenFactory.php:15

HTMLPurifier_Token_Start
Concrete start token class.
Definition: Start.php:7

$html
$html
Definition: example_001.php:87

$config
$config
Definition: flush-definition-cache.php:23

$ret
$ret
Definition: parser.php:6

$old
$old
Definition: rename-config.php:25

$data
$data
Definition: test-settings.sample.php:14