remove autoload section in composer.json

[github/wallabag/wallabag.git] / inc / 3rdparty / htmlpurifier / HTMLPurifier / Lexer.php

<?php\r
\r
/**\r
 * Forgivingly lexes HTML (SGML-style) markup into tokens.\r
 *\r
 * A lexer parses a string of SGML-style markup and converts them into\r
 * corresponding tokens.  It doesn't check for well-formedness, although its\r
 * internal mechanism may make this automatic (such as the case of\r
 * HTMLPurifier_Lexer_DOMLex).  There are several implementations to choose\r
 * from.\r
 *\r
 * A lexer is HTML-oriented: it might work with XML, but it's not\r
 * recommended, as we adhere to a subset of the specification for optimization\r
 * reasons. This might change in the future. Also, most tokenizers are not\r
 * expected to handle DTDs or PIs.\r
 *\r
 * This class should not be directly instantiated, but you may use create() to\r
 * retrieve a default copy of the lexer.  Being a supertype, this class\r
 * does not actually define any implementation, but offers commonly used\r
 * convenience functions for subclasses.\r
 *\r
 * @note The unit tests will instantiate this class for testing purposes, as\r
 *       many of the utility functions require a class to be instantiated.\r
 *       This means that, even though this class is not runnable, it will\r
 *       not be declared abstract.\r
 *\r
 * @par\r
 *\r
 * @note\r
 * We use tokens rather than create a DOM representation because DOM would:\r
 *\r
 * @par\r
 *  -# Require more processing and memory to create,\r
 *  -# Is not streamable, and\r
 *  -# Has the entire document structure (html and body not needed).\r
 *\r
 * @par\r
 * However, DOM is helpful in that it makes it easy to move around nodes\r
 * without a lot of lookaheads to see when a tag is closed. This is a\r
 * limitation of the token system and some workarounds would be nice.\r
 */\r
class HTMLPurifier_Lexer\r
{\r
\r
    /**\r
     * Whether or not this lexer implements line-number/column-number tracking.\r
     * If it does, set to true.\r
     */\r
    public $tracksLineNumbers = false;\r
\r
    // -- STATIC ----------------------------------------------------------\r
\r
    /**\r
     * Retrieves or sets the default Lexer as a Prototype Factory.\r
     *\r
     * By default HTMLPurifier_Lexer_DOMLex will be returned. There are\r
     * a few exceptions involving special features that only DirectLex\r
     * implements.\r
     *\r
     * @note The behavior of this class has changed, rather than accepting\r
     *       a prototype object, it now accepts a configuration object.\r
     *       To specify your own prototype, set %Core.LexerImpl to it.\r
     *       This change in behavior de-singletonizes the lexer object.\r
     *\r
     * @param HTMLPurifier_Config $config\r
     * @return HTMLPurifier_Lexer\r
     * @throws HTMLPurifier_Exception\r
     */\r
    public static function create($config)\r
    {\r
        if (!($config instanceof HTMLPurifier_Config)) {\r
            $lexer = $config;\r
            trigger_error(\r
                "Passing a prototype to\r
                HTMLPurifier_Lexer::create() is deprecated, please instead\r
                use %Core.LexerImpl",\r
                E_USER_WARNING\r
            );\r
        } else {\r
            $lexer = $config->get('Core.LexerImpl');\r
        }\r
\r
        $needs_tracking =\r
            $config->get('Core.MaintainLineNumbers') ||\r
            $config->get('Core.CollectErrors');\r
\r
        $inst = null;\r
        if (is_object($lexer)) {\r
            $inst = $lexer;\r
        } else {\r
            if (is_null($lexer)) {\r
                do {\r
                    // auto-detection algorithm\r
                    if ($needs_tracking) {\r
                        $lexer = 'DirectLex';\r
                        break;\r
                    }\r
\r
                    if (class_exists('DOMDocument') &&\r
                        method_exists('DOMDocument', 'loadHTML') &&\r
                        !extension_loaded('domxml')\r
                    ) {\r
                        // check for DOM support, because while it's part of the\r
                        // core, it can be disabled compile time. Also, the PECL\r
                        // domxml extension overrides the default DOM, and is evil\r
                        // and nasty and we shan't bother to support it\r
                        $lexer = 'DOMLex';\r
                    } else {\r
                        $lexer = 'DirectLex';\r
                    }\r
                } while (0);\r
            } // do..while so we can break\r
\r
            // instantiate recognized string names\r
            switch ($lexer) {\r
                case 'DOMLex':\r
                    $inst = new HTMLPurifier_Lexer_DOMLex();\r
                    break;\r
                case 'DirectLex':\r
                    $inst = new HTMLPurifier_Lexer_DirectLex();\r
                    break;\r
                case 'PH5P':\r
                    $inst = new HTMLPurifier_Lexer_PH5P();\r
                    break;\r
                default:\r
                    throw new HTMLPurifier_Exception(\r
                        "Cannot instantiate unrecognized Lexer type " .\r
                        htmlspecialchars($lexer)\r
                    );\r
            }\r
        }\r
\r
        if (!$inst) {\r
            throw new HTMLPurifier_Exception('No lexer was instantiated');\r
        }\r
\r
        // once PHP DOM implements native line numbers, or we\r
        // hack out something using XSLT, remove this stipulation\r
        if ($needs_tracking && !$inst->tracksLineNumbers) {\r
            throw new HTMLPurifier_Exception(\r
                'Cannot use lexer that does not support line numbers with ' .\r
                'Core.MaintainLineNumbers or Core.CollectErrors (use DirectLex instead)'\r
            );\r
        }\r
\r
        return $inst;\r
\r
    }\r
\r
    // -- CONVENIENCE MEMBERS ---------------------------------------------\r
\r
    public function __construct()\r
    {\r
        $this->_entity_parser = new HTMLPurifier_EntityParser();\r
    }\r
\r
    /**\r
     * Most common entity to raw value conversion table for special entities.\r
     * @type array\r
     */\r
    protected $_special_entity2str =\r
        array(\r
            '&quot;' => '"',\r
            '&amp;' => '&',\r
            '&lt;' => '<',\r
            '&gt;' => '>',\r
            '&#39;' => "'",\r
            '&#039;' => "'",\r
            '&#x27;' => "'"\r
        );\r
\r
    /**\r
     * Parses special entities into the proper characters.\r
     *\r
     * This string will translate escaped versions of the special characters\r
     * into the correct ones.\r
     *\r
     * @warning\r
     * You should be able to treat the output of this function as\r
     * completely parsed, but that's only because all other entities should\r
     * have been handled previously in substituteNonSpecialEntities()\r
     *\r
     * @param string $string String character data to be parsed.\r
     * @return string Parsed character data.\r
     */\r
    public function parseData($string)\r
    {\r
        // following functions require at least one character\r
        if ($string === '') {\r
            return '';\r
        }\r
\r
        // subtracts amps that cannot possibly be escaped\r
        $num_amp = substr_count($string, '&') - substr_count($string, '& ') -\r
            ($string[strlen($string) - 1] === '&' ? 1 : 0);\r
\r
        if (!$num_amp) {\r
            return $string;\r
        } // abort if no entities\r
        $num_esc_amp = substr_count($string, '&amp;');\r
        $string = strtr($string, $this->_special_entity2str);\r
\r
        // code duplication for sake of optimization, see above\r
        $num_amp_2 = substr_count($string, '&') - substr_count($string, '& ') -\r
            ($string[strlen($string) - 1] === '&' ? 1 : 0);\r
\r
        if ($num_amp_2 <= $num_esc_amp) {\r
            return $string;\r
        }\r
\r
        // hmm... now we have some uncommon entities. Use the callback.\r
        $string = $this->_entity_parser->substituteSpecialEntities($string);\r
        return $string;\r
    }\r
\r
    /**\r
     * Lexes an HTML string into tokens.\r
     * @param $string String HTML.\r
     * @param HTMLPurifier_Config $config\r
     * @param HTMLPurifier_Context $context\r
     * @return HTMLPurifier_Token[] array representation of HTML.\r
     */\r
    public function tokenizeHTML($string, $config, $context)\r
    {\r
        trigger_error('Call to abstract class', E_USER_ERROR);\r
    }\r
\r
    /**\r
     * Translates CDATA sections into regular sections (through escaping).\r
     * @param string $string HTML string to process.\r
     * @return string HTML with CDATA sections escaped.\r
     */\r
    protected static function escapeCDATA($string)\r
    {\r
        return preg_replace_callback(\r
            '/<!\[CDATA\[(.+?)\]\]>/s',\r
            array('HTMLPurifier_Lexer', 'CDATACallback'),\r
            $string\r
        );\r
    }\r
\r
    /**\r
     * Special CDATA case that is especially convoluted for <script>\r
     * @param string $string HTML string to process.\r
     * @return string HTML with CDATA sections escaped.\r
     */\r
    protected static function escapeCommentedCDATA($string)\r
    {\r
        return preg_replace_callback(\r
            '#<!--//--><!\[CDATA\[//><!--(.+?)//--><!\]\]>#s',\r
            array('HTMLPurifier_Lexer', 'CDATACallback'),\r
            $string\r
        );\r
    }\r
\r
    /**\r
     * Special Internet Explorer conditional comments should be removed.\r
     * @param string $string HTML string to process.\r
     * @return string HTML with conditional comments removed.\r
     */\r
    protected static function removeIEConditional($string)\r
    {\r
        return preg_replace(\r
            '#<!--\[if [^>]+\]>.*?<!\[endif\]-->#si', // probably should generalize for all strings\r
            '',\r
            $string\r
        );\r
    }\r
\r
    /**\r
     * Callback function for escapeCDATA() that does the work.\r
     *\r
     * @warning Though this is public in order to let the callback happen,\r
     *          calling it directly is not recommended.\r
     * @param array $matches PCRE matches array, with index 0 the entire match\r
     *                  and 1 the inside of the CDATA section.\r
     * @return string Escaped internals of the CDATA section.\r
     */\r
    protected static function CDATACallback($matches)\r
    {\r
        // not exactly sure why the character set is needed, but whatever\r
        return htmlspecialchars($matches[1], ENT_COMPAT, 'UTF-8');\r
    }\r
\r
    /**\r
     * Takes a piece of HTML and normalizes it by converting entities, fixing\r
     * encoding, extracting bits, and other good stuff.\r
     * @param string $html HTML.\r
     * @param HTMLPurifier_Config $config\r
     * @param HTMLPurifier_Context $context\r
     * @return string\r
     * @todo Consider making protected\r
     */\r
    public function normalize($html, $config, $context)\r
    {\r
        // normalize newlines to \n\r
        if ($config->get('Core.NormalizeNewlines')) {\r
            $html = str_replace("\r\n", "\n", $html);\r
            $html = str_replace("\r", "\n", $html);\r
        }\r
\r
        if ($config->get('HTML.Trusted')) {\r
            // escape convoluted CDATA\r
            $html = $this->escapeCommentedCDATA($html);\r
        }\r
\r
        // escape CDATA\r
        $html = $this->escapeCDATA($html);\r
\r
        $html = $this->removeIEConditional($html);\r
\r
        // extract body from document if applicable\r
        if ($config->get('Core.ConvertDocumentToFragment')) {\r
            $e = false;\r
            if ($config->get('Core.CollectErrors')) {\r
                $e =& $context->get('ErrorCollector');\r
            }\r
            $new_html = $this->extractBody($html);\r
            if ($e && $new_html != $html) {\r
                $e->send(E_WARNING, 'Lexer: Extracted body');\r
            }\r
            $html = $new_html;\r
        }\r
\r
        // expand entities that aren't the big five\r
        $html = $this->_entity_parser->substituteNonSpecialEntities($html);\r
\r
        // clean into wellformed UTF-8 string for an SGML context: this has\r
        // to be done after entity expansion because the entities sometimes\r
        // represent non-SGML characters (horror, horror!)\r
        $html = HTMLPurifier_Encoder::cleanUTF8($html);\r
\r
        // if processing instructions are to removed, remove them now\r
        if ($config->get('Core.RemoveProcessingInstructions')) {\r
            $html = preg_replace('#<\?.+?\?>#s', '', $html);\r
        }\r
\r
        return $html;\r
    }\r
\r
    /**\r
     * Takes a string of HTML (fragment or document) and returns the content\r
     * @todo Consider making protected\r
     */\r
    public function extractBody($html)\r
    {\r
        $matches = array();\r
        $result = preg_match('!<body[^>]*>(.*)</body>!is', $html, $matches);\r
        if ($result) {\r
            return $matches[1];\r
        } else {\r
            return $html;\r
        }\r
    }\r
}\r
\r
// vim: et sw=4 sts=4\r