Tronque une chaine de caractères en XHTML

                    

                    

                    
<?php
/*------------------------------*/
/*
 Titre : Tronque une chaine de caractères en XHTML                                                                     
                                                                                                                          
 Auteur           : KOogar                                                                                                
 Date édition     : 14 Mars 2026                                                                                       
 Date mise a jour : 14 Mars 2026
                                                                                         
 Rapport de la maj:                                                                                                       
  - fonctionnement du code vérifié                                                                                  
 Date mise a jour : 15 Avril 2026
                                                                                        
 Rapport de la maj:                                                                                                       
  - correction du code                                                                                                    
  - fonctionnement du code vérifié en PHP 8                                                                         
 Date mise a jour : 18 Avril 2026
                                                                                        
 Rapport de la maj:                                                                                                       
  - correction du code                                                                                                    
*/
/*------------------------------*/
/*
 * Script base sur le parser html disponible ici :
 http://php-html.sourceforge.net/
 */

define("NODE_TYPE_START", 0);
define("NODE_TYPE_ELEMENT", 1);
define("NODE_TYPE_ENDELEMENT", 2);
define("NODE_TYPE_TEXT", 3);
define("NODE_TYPE_COMMENT", 4);
define("NODE_TYPE_DONE", 5);
define("NODE_TYPE_ELEMENT_END", 6);

/**
 * Class HtmlParser.
 * To use, create an instance of the class passing
 * HTML text. Then invoke parse() until it's false.
 * When parse() returns true, $iNodeType, $iNodeName
 * $iNodeValue and $iNodeAttributes are updated.
 *
 * To create an HtmlParser instance you may also
 * use convenience functions HtmlParser_ForFile
 * and HtmlParser_ForURL.
 */
class HtmlParser
{
    /**
     * Field iNodeType.
     * May be one of the NODE_TYPE_* constants above.
     */
    public $iNodeType;

    /**
     * Field iNodeName.
     * For elements, it's the name of the element.
     */
    public $iNodeName = "";

    /**
     * Field iNodeValue.
     * For text nodes, it's the text.
     */
    public $iNodeValue = "";

    /**
     * Field iNodeAttributes.
     * A string-indexed array containing attribute values
     * of the current node. Indexes are always lowercase.
     */
    public $iNodeAttributes;

    /**
     * Field iNodeStart.
     * The position of the first char.
     */
    public $iNodeStart;

    /**
     * Field iNodeEnd.
     * The position of the last char.
     */
    public $iNodeEnd;

    // The following fields should be considered private:
    public $iHtmlText;
    public $iHtmlTextLength;
    public $iHtmlTextIndex = 0;
    public $iCurrentChar;           
// renommé iHtmlCurrentChar ? iCurrentChar (comme utilisé dans le code)
    public $BOE_ARRAY;
    public $B_ARRAY;
    public $BOS_ARRAY;
    public $no_comment = false;

    // Liste des balises autofermantes
    public $BalisesSimples = ['hr', 'br', 'input', 'meta', 'link', 'img', 'area'
, 'param'];

    /**
     * Constructor.
     * Constructs an HtmlParser instance with the HTML text given.
     */
    public function __construct($aHtmlText)
    {
        $this->iHtmlText = $aHtmlText;
        $this->iHtmlTextLength = strlen($aHtmlText);
        $this->iNodeAttributes = [];
        $this->setTextIndex(0);

        $this->BOE_ARRAY = [" ", "\t", "\r", "\n", "="];
        $this->B_ARRAY   = [" ", "\t", "\r", "\n"];
        $this->BOS_ARRAY = [" ", "\t", "\r", "\n", "/"];
    }

    /**
     * Method parse.
     * Parses the next node. Returns false only if
     * the end of the HTML text has been reached.
     * Updates values of iNode* fields.
     */
    public function parse()
    {
        $this->iNodeStart = $this->iHtmlTextIndex;
        $text = $this->skipToElement();

        if ($text !== "") {
            $this->iNodeType  = NODE_TYPE_TEXT;
            $this->iNodeName  = "Text";
            $this->iNodeValue = $text;
            $this->iNodeEnd   = $this->iHtmlTextIndex;
            return true;
        }

        return $this->readTag();
    }

    public function clearAttributes()
    {
        $this->iNodeAttributes = [];
    }

    public function readTag()
    {
        if ($this->iCurrentChar !== "<") {
            $this->iNodeType = NODE_TYPE_DONE;
            return false;
        }

        $this->clearAttributes();
        $this->skipMaxInTag("<", 1);

        if ($this->iCurrentChar === '/') {
            $this->moveNext();
            $name = $this->skipToBlanksInTag();

            if (strtolower($name) === 'script') {
                $this->no_comment = false;
            }

            $this->iNodeType  = NODE_TYPE_ENDELEMENT;
            $this->iNodeName  = $name;
            $this->iNodeValue = "";
            $this->skipEndOfTag();
            $this->iNodeEnd = $this->iHtmlTextIndex;
            return true;
        }

        $name = $this->skipToBlanksOrSlashInTag();

        if (!$this->isValidTagIdentifier($name)) {
            $comment = false;

            if (strpos($name, "!--") === 0 && !$this->no_comment) {
                if (strpos($name, "--", 3) === (strlen($name) - 2)) {
                    $this->iNodeType  = NODE_TYPE_COMMENT;
                    $this->iNodeName  = "Comment";
                    $this->iNodeValue = "<" . $name . ">";
                    $comment = true;
                } else {
                    $rest = $this->skipToStringInTag("-->");
                    if ($rest !== "") {
                        $this->iNodeType  = NODE_TYPE_COMMENT;
                        $this->iNodeName  = "Comment";
                        $this->iNodeValue = "<" . $name . $rest;
                        $comment = true;
                        $this->iNodeEnd = $this->iHtmlTextIndex;
                        return true;
                    }
                }
            }

            if (!$comment) {
                $this->iNodeType  = NODE_TYPE_TEXT;
                $this->iNodeName  = "Text";
                $this->iNodeValue = "<" . $name;
                $this->iNodeEnd   = $this->iHtmlTextIndex;
                return true;
            }
        } else {
            if (strtolower($name) === 'script') {
                $this->no_comment = true;
            }

            $this->iNodeType  = NODE_TYPE_ELEMENT;
            $this->iNodeValue = "";
            $this->iNodeName  = $name;

            while ($this->skipBlanksInTag()) {
                $attrName = $this->skipToBlanksOrEqualsInTag();

                if ($attrName !== "" && $attrName !== "/") {
                    $this->skipBlanksInTag();

                    if ($this->iCurrentChar === "=") {
                        $this->skipEqualsInTag();
                        $this->skipBlanksInTag();
                        $value = $this->readValueInTag();
                        $this->iNodeAttributes[strtolower($attrName)] = $value;
                    } else {
                        $this->iNodeAttributes[strtolower($attrName)] = "";
                        $this->setTextIndex($this->iHtmlTextIndex - 1);
                    }
                }
            }
        }

        // Balise auto-fermante ?
        if (($this->iHtmlText[$this->iHtmlTextIndex - 1] ?? '') === '/' || 
in_array($this->iNodeName, $this->BalisesSimples, true)) {
            $this->iNodeType = NODE_TYPE_ELEMENT_END;
        }

        $this->skipEndOfTag();
        $this->iNodeEnd = $this->iHtmlTextIndex;

        return true;
    }

    public function isValidTagIdentifier($name)
    {
        return (bool)$name;
    }

    public function skipBlanksInTag()
    {
        return "" !== $this->skipInTag($this->B_ARRAY);
    }

    public function skipToBlanksOrEqualsInTag()
    {
        return $this->skipToInTag($this->BOE_ARRAY);
    }

    public function skipToBlanksInTag()
    {
        return $this->skipToInTag($this->B_ARRAY);
    }

    public function skipToBlanksOrSlashInTag()
    {
        return $this->skipToInTag($this->BOS_ARRAY);
    }

    public function skipEqualsInTag()
    {
        return $this->skipMaxInTag("=", 1);
    }

    public function readValueInTag()
    {
        $ch = $this->iCurrentChar;
        $value = "";

        if ($ch === "\"") {
            $this->skipMaxInTag("\"", 1);
            $value = $this->skipToInTag("\"");
            $this->skipMaxInTag("\"", 1);
        } elseif ($ch === "'") {
            $this->skipMaxInTag("'", 1);
            $value = $this->skipToInTag("'");
            $this->skipMaxInTag("'", 1);
        } else {
            $value = $this->skipToBlanksInTag();
        }

        return $value;
    }

    public function setTextIndex($index)
    {
        $this->iHtmlTextIndex = $index;

        if ($index >= $this->iHtmlTextLength) {
            $this->iCurrentChar = -1;
        } else {
            $this->iCurrentChar = $this->iHtmlText[$index];
        }
    }

    public function moveNext()
    {
        if ($this->iHtmlTextIndex < $this->iHtmlTextLength) {
            $this->setTextIndex($this->iHtmlTextIndex + 1);
            return true;
        }
        return false;
    }

    public function skipEndOfTag()
    {
        while (($ch = $this->iCurrentChar) !== -1) {
            if ($ch === ">") {
                $this->moveNext();
                return;
            }
            $this->moveNext();
        }
    }

    public function skipInTag($chars)
    {
        $sb = "";
        while (($ch = $this->iCurrentChar) !== -1) {
            if ($ch === ">") {
                return $sb;
            }

            $match = false;
            foreach ($chars as $char) {
                if ($ch === $char) {
                    $match = true;
                    break;
                }
            }

            if (!$match) {
                return $sb;
            }

            $sb .= $ch;
            $this->moveNext();
        }
        return $sb;
    }

       public function skipMaxInTag($chars, $maxChars)
    {
        if (is_string($chars)) {
            $chars = [$chars];
        }

        $sb = "";
        $count = 0;
        while (($ch = $this->iCurrentChar) !== -1 && $count++ < $maxChars) {
            if ($ch === ">") {
                return $sb;
            }

            $match = false;
            foreach ($chars as $char) {
                if ($ch === $char) {
                    $match = true;
                    break;
                }
            }

            if (!$match) {
                return $sb;
            }

            $sb .= $ch;
            $this->moveNext();
        }
        return $sb;
    }

        public function skipToInTag($chars)
    {
        // Conversion automatique si on passe une string (cas des " ou ')
        if (is_string($chars)) {
            $chars = [$chars];          // transforme " en ["]
        }

        $sb = "";
        while (($ch = $this->iCurrentChar) !== -1) {
            $match = ($ch === ">");

            if (!$match && is_array($chars)) {
                foreach ($chars as $char) {
                    if ($ch === $char) {
                        $match = true;
                        break;
                    }
                }
            }

            if ($match) {
                return $sb;
            }

            $sb .= $ch;
            $this->moveNext();
        }
        return $sb;
    }

    public function skipToElement()
    {
        $sb = "";
        while (($ch = $this->iCurrentChar) !== -1) {
            if ($ch === "<") {
                return $sb;
            }
            $sb .= $ch;
            $this->moveNext();
        }
        return $sb;
    }

    /**
     * Returns text between current position and $needle,
     * inclusive, or "" if not found.
     */
    public function skipToStringInTag($needle)
    {
        $pos = strpos($this->iHtmlText, $needle, $this->iHtmlTextIndex);
        if ($pos === false) {
            return "";
        }

        $top = $pos + strlen($needle);
        $retvalue = substr($this->iHtmlText, $this->iHtmlTextIndex, $top - $this
->iHtmlTextIndex);
        $this->setTextIndex($top);

        return $retvalue;
    }
}

// ==================== Fonctions de commodité ====================

function HtmlParser_ForFile($fileName)
{
    return HtmlParser_ForURL($fileName);
}

function HtmlParser_ForURL($url)
{
    $fp = fopen($url, "r");
    $content = "";

    while (true) {
        $data = fread($fp, 8192);
        if ($data === false || $data === "") {
            break;
        }
        $content .= $data;
    }

    fclose($fp);
    return new HtmlParser($content);
}

// ==================== Fonction TronqueHtml ====================

function TronqueHtml($chaine, $max, $separateur = ' ', $suffix = ' ...')
{
    // Si le texte sans balises ne dépasse pas la limite, on retourne tel quel
    if (strlen(strip_tags($chaine)) <= $max) {
        return $chaine;
    }

    $tabElements = [];        // Pile des balises ouvertes
    $cur_len = 0;             // Longueur cumulée de texte "visible"
    $parser = new HtmlParser($chaine);
    $iteration = 0;
    $maxIterations = 100000;  // Protection anti-boucle infinie

    while ($parser->parse() && $iteration++ < $maxIterations) {

        if ($parser->iNodeType === NODE_TYPE_ELEMENT) {
            // Balise ouvrante ? on l'ajoute à la pile
            $tabElements[] = $parser->iNodeName;

        } elseif ($parser->iNodeType === NODE_TYPE_ENDELEMENT) {
            // === CORRECTION PRINCIPALE : fermeture sécurisée ===
            $found = false;
            while (!empty($tabElements)) {
                $opened = array_pop($tabElements);
                if ($opened === $parser->iNodeName) {
                    $found = true;
                    break;
                }
                // Sinon on continue de dépiler (HTML mal formé)
            }
            // Si $found === false ? balise fermante sans ouvrante ? on ignore

        } elseif ($parser->iNodeType === NODE_TYPE_TEXT) {

            $cur_max = $cur_len + ($parser->iNodeEnd - $parser->iNodeStart);

            if ($cur_max === $max) {
                $resultat = substr($chaine, 0, $parser->iNodeEnd) . $suffix;
                // On ferme toutes les balises encore ouvertes
                while (!empty($tabElements)) {
                    $balise = array_pop($tabElements);
                    $resultat .= '</' . $balise . '>';
                }
                return $resultat;

            } elseif ($cur_max > $max) {
                // On coupe au milieu du texte
                $temp = substr($parser->iNodeValue, 0, ($max - $cur_len + strlen
($separateur)));

                if (($pos = strrpos($temp, $separateur)) !== false) {
                    $resultat = substr($chaine, 0, $parser->iNodeStart + $pos) .
 $suffix;
                } else {
                    $resultat = substr($chaine, 0, $parser->iNodeEnd) . $suffix;
                }

                // On ferme toutes les balises encore ouvertes
                while (!empty($tabElements)) {
                    $balise = array_pop($tabElements);
                    $resultat .= '</' . $balise . '>';
                }
                return $resultat;

            } else {
                // Le texte rentre encore entièrement
                $cur_len += $parser->iNodeEnd - $parser->iNodeStart;
            }
        }
    }

    // Sécurité : si on arrive ici (très rare), on retourne le texte original
    return $chaine;
}