www/ecrire/inc/filtres.php

   1 <?php
   2
   3 /***************************************************************************\
   4  *  SPIP, Systeme de publication pour l'internet                           *
   5  *                                                                         *
   6  *  Copyright (c) 2001-2019                                                *
   7  *  Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James  *
   8  *                                                                         *
   9  *  Ce programme est un logiciel libre distribue sous licence GNU/GPL.     *
  10  *  Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne.   *
  11 \***************************************************************************/
  12
  13 /**
  14  * Déclaration de filtres pour les squelettes
  15  *
  16  * @package SPIP\Core\Filtres
  17  **/
  18 if (!defined('_ECRIRE_INC_VERSION')) {
  19         return;
  20 }
  21
  22 include_spip('inc/charsets');
  23 include_spip('inc/filtres_mini');
  24 include_spip('inc/filtres_dates');
  25 include_spip('inc/filtres_selecteur_generique');
  26 include_spip('base/objets');
  27 include_spip('public/parametrer'); // charger les fichiers fonctions
  28
  29 /**
  30  * Charger un filtre depuis le php
  31  *
  32  * - on inclue tous les fichiers fonctions des plugins et du skel
  33  * - on appelle chercher_filtre
  34  *
  35  * Pour éviter de perdre le texte si le filtre demandé est introuvable,
  36  * on transmet `filtre_identite_dist` en filtre par défaut.
  37  *
  38  * @uses filtre_identite_dist() Comme fonction par défaut
  39  *
  40  * @param string $fonc Nom du filtre
  41  * @param string $default Filtre par défaut
  42  * @return string Fonction PHP correspondante du filtre
  43  */
  44 function charger_filtre($fonc, $default = 'filtre_identite_dist') {
  45         include_spip('public/parametrer'); // inclure les fichiers fonctions
  46         return chercher_filtre($fonc, $default);
  47 }
  48
  49 /**
  50  * Retourne le texte tel quel
  51  *
  52  * @param string $texte Texte
  53  * @return string Texte
  54  **/
  55 function filtre_identite_dist($texte) { return $texte; }
  56
  57 /**
  58  * Cherche un filtre
  59  *
  60  * Pour une filtre `F` retourne la première fonction trouvée parmis :
  61  *
  62  * - filtre_F
  63  * - filtre_F_dist
  64  * - F
  65  *
  66  * Peut gérer des appels par des fonctions statiques de classes tel que `Foo::Bar`
  67  *
  68  * En absence de fonction trouvée, retourne la fonction par défaut indiquée.
  69  *
  70  * @param string $fonc
  71  *     Nom du filtre
  72  * @param null $default
  73  *     Nom du filtre appliqué par défaut si celui demandé n'est pas trouvé
  74  * @return string
  75  *     Fonction PHP correspondante du filtre demandé
  76  */
  77 function chercher_filtre($fonc, $default = null) {
  78         if (!$fonc) {
  79                 return $default;
  80         }
  81         // Cas des types mime, sans confondre avec les appels de fonction de classe
  82         // Foo::Bar
  83         // qui peuvent etre avec un namespace : space\Foo::Bar
  84         if (preg_match(',^[\w]+/,', $fonc)) {
  85                 $nom = preg_replace(',\W,', '_', $fonc);
  86                 $f = chercher_filtre($nom);
  87                 // cas du sous-type MIME sans filtre associe, passer au type:
  88                 // si filtre_text_plain pas defini, passe a filtre_text
  89                 if (!$f and $nom !== $fonc) {
  90                         $f = chercher_filtre(preg_replace(',\W.*$,', '', $fonc));
  91                 }
  92
  93                 return $f;
  94         }
  95         foreach (array('filtre_' . $fonc, 'filtre_' . $fonc . '_dist', $fonc) as $f) {
  96                 trouver_filtre_matrice($f); // charge des fichiers spécifiques éventuels
  97                 // fonction ou name\space\fonction
  98                 if (is_callable($f)) {
  99                         return $f;
 100                 }
 101                 // méthode statique d'une classe Classe::methode ou name\space\Classe::methode
 102                 elseif (false === strpos($f, '::') and is_callable(array($f))) {
 103                         return $f;
 104                 }
 105         }
 106
 107         return $default;
 108 }
 109
 110 /**
 111  * Applique un filtre
 112  *
 113  * Fonction générique qui prend en argument l’objet (texte, etc) à modifier
 114  * et le nom du filtre. Retrouve les arguments du filtre demandé dans les arguments
 115  * transmis à cette fonction, via func_get_args().
 116  *
 117  * @see filtrer() Assez proche
 118  *
 119  * @param mixed $arg
 120  *     Texte (le plus souvent) sur lequel appliquer le filtre
 121  * @param string $filtre
 122  *     Nom du filtre à appliquer
 123  * @param bool $force
 124  *     La fonction doit-elle retourner le texte ou rien si le filtre est absent ?
 125  * @return string
 126  *     Texte traité par le filtre si le filtre existe,
 127  *     Texte d'origine si le filtre est introuvable et si $force à `true`
 128  *     Chaîne vide sinon (filtre introuvable).
 129  **/
 130 function appliquer_filtre($arg, $filtre, $force = null) {
 131         $f = chercher_filtre($filtre);
 132         if (!$f) {
 133                 if (!$force) {
 134                         return '';
 135                 } else {
 136                         return $arg;
 137                 }
 138         }
 139
 140         $args = func_get_args();
 141         array_shift($args); // enlever $arg
 142         array_shift($args); // enlever $filtre
 143         array_unshift($args, $arg); // remettre $arg
 144         return call_user_func_array($f, $args);
 145 }
 146
 147 /**
 148  * Retourne la version de SPIP
 149  *
 150  * Si l'on retrouve un numéro de révision SVN, il est ajouté entre crochets.
 151  * Si effectivement le SPIP est installé par SVN, 'SVN' est ajouté avant sa révision.
 152  *
 153  * @global spip_version_affichee Contient la version de SPIP
 154  * @uses version_svn_courante() Pour trouver le numéro de révision SVN
 155  *
 156  * @return string
 157  *     Version de SPIP
 158  **/
 159 function spip_version() {
 160         $version = $GLOBALS['spip_version_affichee'];
 161         if ($svn_revision = version_svn_courante(_DIR_RACINE)) {
 162                 $version .= ($svn_revision < 0 ? ' SVN' : '') . ' [' . abs($svn_revision) . ']';
 163         }
 164
 165         return $version;
 166 }
 167
 168
 169 /**
 170  * Retrouve un numéro de révision SVN d'un répertoire
 171  *
 172  * Mention de la révision SVN courante d'un répertoire
 173  * Retourne un nombre négatif si on est sur .svn, et positif si on utilise svn.revision
 174  *
 175  * @param string $dir Chemin du répertoire
 176  * @return int
 177  *
 178  *     - 0 si aucune info trouvée
 179  *     - NN (entier) si info trouvée par svn.revision (créé par le générateur de paquet Zip)
 180  *     - -NN (entier) si info trouvée par .svn/entries
 181  *
 182  **/
 183 function version_svn_courante($dir) {
 184         if (!$dir) {
 185                 $dir = '.';
 186         }
 187
 188         // version installee par paquet ZIP
 189         if (lire_fichier($dir . '/svn.revision', $c)
 190                 and preg_match(',Revision: (\d+),', $c, $d)
 191         ) {
 192                 return intval($d[1]);
 193         }
 194
 195         // version installee par SVN
 196         if (file_exists($dir . '/.svn/wc.db') && class_exists('SQLite3')) {
 197                 $db = new SQLite3($dir . '/.svn/wc.db');
 198                 $result = $db->query('SELECT changed_revision FROM nodes WHERE local_relpath = "" LIMIT 1');
 199                 if ($result) {
 200                         $row = $result->fetchArray();
 201                         if ($row['changed_revision'] != "") {
 202                                 return -$row['changed_revision'];
 203                         }
 204                 }
 205         } else if (lire_fichier($dir . '/.svn/entries', $c)
 206                 and (
 207                         (preg_match_all(
 208                                         ',committed-rev="([0-9]+)",', $c, $r1, PREG_PATTERN_ORDER)
 209                                 and $v = max($r1[1])
 210                         )
 211                         or
 212                         (preg_match(',^\d.*dir[\r\n]+(\d+),ms', $c, $r1) # svn >= 1.4
 213                                 and $v = $r1[1]
 214                         ))
 215         ) {
 216                 return -$v;
 217         }
 218
 219         // Bug ou paquet fait main
 220         return 0;
 221 }
 222
 223 // La matrice est necessaire pour ne filtrer _que_ des fonctions definies dans filtres_images
 224 // et laisser passer les fonctions personnelles baptisees image_...
 225 $GLOBALS['spip_matrice']['image_graver'] = true;//'inc/filtres_images_mini.php';
 226 $GLOBALS['spip_matrice']['image_select'] = true;//'inc/filtres_images_mini.php';
 227 $GLOBALS['spip_matrice']['image_reduire'] = true;//'inc/filtres_images_mini.php';
 228 $GLOBALS['spip_matrice']['image_reduire_par'] = true;//'inc/filtres_images_mini.php';
 229 $GLOBALS['spip_matrice']['image_passe_partout'] = true;//'inc/filtres_images_mini.php';
 230
 231 $GLOBALS['spip_matrice']['couleur_html_to_hex'] = 'inc/filtres_images_mini.php';
 232 $GLOBALS['spip_matrice']['couleur_foncer'] = 'inc/filtres_images_mini.php';
 233 $GLOBALS['spip_matrice']['couleur_eclaircir'] = 'inc/filtres_images_mini.php';
 234
 235 // ou pour inclure un script au moment ou l'on cherche le filtre
 236 $GLOBALS['spip_matrice']['filtre_image_dist'] = 'inc/filtres_mime.php';
 237 $GLOBALS['spip_matrice']['filtre_audio_dist'] = 'inc/filtres_mime.php';
 238 $GLOBALS['spip_matrice']['filtre_video_dist'] = 'inc/filtres_mime.php';
 239 $GLOBALS['spip_matrice']['filtre_application_dist'] = 'inc/filtres_mime.php';
 240 $GLOBALS['spip_matrice']['filtre_message_dist'] = 'inc/filtres_mime.php';
 241 $GLOBALS['spip_matrice']['filtre_multipart_dist'] = 'inc/filtres_mime.php';
 242 $GLOBALS['spip_matrice']['filtre_text_dist'] = 'inc/filtres_mime.php';
 243 $GLOBALS['spip_matrice']['filtre_text_csv_dist'] = 'inc/filtres_mime.php';
 244 $GLOBALS['spip_matrice']['filtre_text_html_dist'] = 'inc/filtres_mime.php';
 245 $GLOBALS['spip_matrice']['filtre_audio_x_pn_realaudio'] = 'inc/filtres_mime.php';
 246
 247
 248 /**
 249  * Charge et exécute un filtre (graphique ou non)
 250  *
 251  * Recherche la fonction prévue pour un filtre (qui peut être un filtre graphique `image_*`)
 252  * et l'exécute avec les arguments transmis à la fonction, obtenus avec `func_get_args()`
 253  *
 254  * @api
 255  * @uses image_filtrer() Pour un filtre image
 256  * @uses chercher_filtre() Pour un autre filtre
 257  *
 258  * @param string $filtre
 259  *     Nom du filtre à appliquer
 260  * @return string
 261  *     Code HTML retourné par le filtre
 262  **/
 263 function filtrer($filtre) {
 264         $tous = func_get_args();
 265         if (trouver_filtre_matrice($filtre) and substr($filtre, 0, 6) == 'image_') {
 266                 return image_filtrer($tous);
 267         } elseif ($f = chercher_filtre($filtre)) {
 268                 array_shift($tous);
 269                 return call_user_func_array($f, $tous);
 270         } else {
 271                 // le filtre n'existe pas, on provoque une erreur
 272                 $msg = array('zbug_erreur_filtre', array('filtre' => texte_script($filtre)));
 273                 erreur_squelette($msg);
 274                 return '';
 275         }
 276 }
 277
 278 /**
 279  * Cherche un filtre spécial indiqué dans la globale `spip_matrice`
 280  * et charge le fichier éventuellement associé contenant le filtre.
 281  *
 282  * Les filtres d'images par exemple sont déclarés de la sorte, tel que :
 283  * ```
 284  * $GLOBALS['spip_matrice']['image_reduire'] = true;
 285  * $GLOBALS['spip_matrice']['image_monochrome'] = 'filtres/images_complements.php';
 286  * ```
 287  *
 288  * @param string $filtre
 289  * @return bool true si on trouve le filtre dans la matrice, false sinon.
 290  */
 291 function trouver_filtre_matrice($filtre) {
 292         if (isset($GLOBALS['spip_matrice'][$filtre]) and is_string($f = $GLOBALS['spip_matrice'][$filtre])) {
 293                 find_in_path($f, '', true);
 294                 $GLOBALS['spip_matrice'][$filtre] = true;
 295         }
 296         return !empty($GLOBALS['spip_matrice'][$filtre]);
 297 }
 298
 299
 300 /**
 301  * Filtre `set` qui sauve la valeur en entrée dans une variable
 302  *
 303  * La valeur pourra être retrouvée avec `#GET{variable}`.
 304  *
 305  * @example
 306  *     `[(#CALCUL|set{toto})]` enregistre le résultat de `#CALCUL`
 307  *     dans la variable `toto` et renvoie vide.
 308  *     C'est équivalent à `[(#SET{toto, #CALCUL})]` dans ce cas.
 309  *     `#GET{toto}` retourne la valeur sauvegardée.
 310  *
 311  * @example
 312  *     `[(#CALCUL|set{toto,1})]` enregistre le résultat de `#CALCUL`
 313  *      dans la variable toto et renvoie la valeur. Cela permet d'utiliser
 314  *      d'autres filtres ensuite. `#GET{toto}` retourne la valeur.
 315  *
 316  * @filtre
 317  * @param array $Pile Pile de données
 318  * @param mixed $val Valeur à sauver
 319  * @param string $key Clé d'enregistrement
 320  * @param bool $continue True pour retourner la valeur
 321  * @return mixed
 322  */
 323 function filtre_set(&$Pile, $val, $key, $continue = null) {
 324         $Pile['vars'][$key] = $val;
 325         return $continue ? $val : '';
 326 }
 327
 328 /**
 329  * Filtre `setenv` qui enregistre une valeur dans l'environnement du squelette
 330  *
 331  * La valeur pourra être retrouvée avec `#ENV{variable}`.
 332  *
 333  * @example
 334  *     `[(#CALCUL|setenv{toto})]` enregistre le résultat de `#CALCUL`
 335  *      dans l'environnement toto et renvoie vide.
 336  *      `#ENV{toto}` retourne la valeur.
 337  *
 338  *      `[(#CALCUL|setenv{toto,1})]` enregistre le résultat de `#CALCUL`
 339  *      dans l'environnement toto et renvoie la valeur.
 340  *      `#ENV{toto}` retourne la valeur.
 341  *
 342  * @filtre
 343  *
 344  * @param array $Pile
 345  * @param mixed $val Valeur à enregistrer
 346  * @param mixed $key Nom de la variable
 347  * @param null|mixed $continue Si présent, retourne la valeur en sortie
 348  * @return string|mixed Retourne `$val` si `$continue` présent, sinon ''.
 349  */
 350 function filtre_setenv(&$Pile, $val, $key, $continue = null) {
 351         $Pile[0][$key] = $val;
 352         return $continue ? $val : '';
 353 }
 354
 355 /**
 356  * @param array $Pile
 357  * @param array|string $keys
 358  * @return string
 359  */
 360 function filtre_sanitize_env(&$Pile, $keys) {
 361         $Pile[0] = spip_sanitize_from_request($Pile[0], $keys);
 362         return '';
 363 }
 364
 365
 366 /**
 367  * Filtre `debug` qui affiche un debug de la valeur en entrée
 368  *
 369  * Log la valeur dans `debug.log` et l'affiche si on est webmestre.
 370  *
 371  * @example
 372  *     `[(#TRUC|debug)]` affiche et log la valeur de `#TRUC`
 373  * @example
 374  *     `[(#TRUC|debug{avant}|calcul|debug{apres}|etc)]`
 375  *     affiche la valeur de `#TRUC` avant et après le calcul,
 376  *     en précisant "avant" et "apres".
 377  *
 378  * @filtre
 379  * @link http://www.spip.net/5695
 380  * @param mixed $val La valeur à debugguer
 381  * @param mixed|null $key Clé pour s'y retrouver
 382  * @return mixed Retourne la valeur (sans la modifier).
 383  */
 384 function filtre_debug($val, $key = null) {
 385         $debug = (
 386                 is_null($key) ? '' : (var_export($key, true) . " = ")
 387                 ) . var_export($val, true);
 388
 389         include_spip('inc/autoriser');
 390         if (autoriser('webmestre')) {
 391                 echo "<div class='spip_debug'>\n", $debug, "</div>\n";
 392         }
 393
 394         spip_log($debug, 'debug');
 395
 396         return $val;
 397 }
 398
 399
 400 /**
 401  * Exécute un filtre image
 402  *
 403  * Fonction générique d'entrée des filtres images.
 404  * Accepte en entrée :
 405  *
 406  * - un texte complet,
 407  * - un img-log (produit par #LOGO_XX),
 408  * - un tag `<img ...>` complet,
 409  * - un nom de fichier *local* (passer le filtre `|copie_locale` si on veut
 410  *   l'appliquer à un document distant).
 411  *
 412  * Applique le filtre demande à chacune des occurrences
 413  *
 414  * @param array $args
 415  *     Liste des arguments :
 416  *
 417  *     - le premier est le nom du filtre image à appliquer
 418  *     - le second est le texte sur lequel on applique le filtre
 419  *     - les suivants sont les arguments du filtre image souhaité.
 420  * @return string
 421  *     Texte qui a reçu les filtres
 422  **/
 423 function image_filtrer($args) {
 424         $filtre = array_shift($args); # enlever $filtre
 425         $texte = array_shift($args);
 426         if (!strlen($texte)) {
 427                 return;
 428         }
 429         find_in_path('filtres_images_mini.php', 'inc/', true);
 430         statut_effacer_images_temporaires(true); // activer la suppression des images temporaires car le compilo finit la chaine par un image_graver
 431         // Cas du nom de fichier local
 432         if (strpos(substr($texte, strlen(_DIR_RACINE)), '..') === false
 433                 and !preg_match(',^/|[<>]|\s,S', $texte)
 434                 and (
 435                         file_exists(preg_replace(',[?].*$,', '', $texte))
 436                         or tester_url_absolue($texte)
 437                 )
 438         ) {
 439                 array_unshift($args, "<img src='$texte' />");
 440                 $res = call_user_func_array($filtre, $args);
 441                 statut_effacer_images_temporaires(false); // desactiver pour les appels hors compilo
 442                 return $res;
 443         }
 444
 445         // Cas general : trier toutes les images, avec eventuellement leur <span>
 446         if (preg_match_all(
 447                 ',(<([a-z]+) [^<>]*spip_documents[^<>]*>)?\s*(<img\s.*>),UimsS',
 448                 $texte, $tags, PREG_SET_ORDER)) {
 449                 foreach ($tags as $tag) {
 450                         $class = extraire_attribut($tag[3], 'class');
 451                         if (!$class or
 452                                 (strpos($class, 'filtre_inactif') === false
 453                                         // compat historique a virer en 3.2
 454                                         and strpos($class, 'no_image_filtrer') === false)
 455                         ) {
 456                                 array_unshift($args, $tag[3]);
 457                                 if ($reduit = call_user_func_array($filtre, $args)) {
 458                                         // En cas de span spip_documents, modifier le style=...width:
 459                                         if ($tag[1]) {
 460                                                 $w = extraire_attribut($reduit, 'width');
 461                                                 if (!$w and preg_match(",width:\s*(\d+)px,S", extraire_attribut($reduit, 'style'), $regs)) {
 462                                                         $w = $regs[1];
 463                                                 }
 464                                                 if ($w and ($style = extraire_attribut($tag[1], 'style'))) {
 465                                                         $style = preg_replace(",width:\s*\d+px,S", "width:${w}px", $style);
 466                                                         $replace = inserer_attribut($tag[1], 'style', $style);
 467                                                         $texte = str_replace($tag[1], $replace, $texte);
 468                                                 }
 469                                         }
 470                                         // traiter aussi un eventuel mouseover
 471                                         if ($mouseover = extraire_attribut($reduit, 'onmouseover')) {
 472                                                 if (preg_match(",this[.]src=['\"]([^'\"]+)['\"],ims", $mouseover, $match)) {
 473                                                         $srcover = $match[1];
 474                                                         array_shift($args);
 475                                                         array_unshift($args, "<img src='" . $match[1] . "' />");
 476                                                         $srcover_filter = call_user_func_array($filtre, $args);
 477                                                         $srcover_filter = extraire_attribut($srcover_filter, 'src');
 478                                                         $reduit = str_replace($srcover, $srcover_filter, $reduit);
 479                                                 }
 480                                         }
 481                                         $texte = str_replace($tag[3], $reduit, $texte);
 482                                 }
 483                                 array_shift($args);
 484                         }
 485                 }
 486         }
 487         statut_effacer_images_temporaires(false); // desactiver pour les appels hors compilo
 488         return $texte;
 489 }
 490
 491
 492 /**
 493  * Retourne les tailles d'une image
 494  *
 495  * Pour les filtres `largeur` et `hauteur`
 496  *
 497  * @param string $img
 498  *     Balise HTML `<img ... />` ou chemin de l'image (qui peut être une URL distante).
 499  * @return array
 500  *     Liste (hauteur, largeur) en pixels
 501  **/
 502 function taille_image($img) {
 503
 504         static $largeur_img = array(), $hauteur_img = array();
 505         $srcWidth = 0;
 506         $srcHeight = 0;
 507
 508         $logo = extraire_attribut($img, 'src');
 509
 510         if (!$logo) {
 511                 $logo = $img;
 512         } else {
 513                 $srcWidth = extraire_attribut($img, 'width');
 514                 $srcHeight = extraire_attribut($img, 'height');
 515         }
 516
 517         // ne jamais operer directement sur une image distante pour des raisons de perfo
 518         // la copie locale a toutes les chances d'etre la ou de resservir
 519         if (tester_url_absolue($logo)) {
 520                 include_spip('inc/distant');
 521                 $fichier = copie_locale($logo);
 522                 $logo = $fichier ? _DIR_RACINE . $fichier : $logo;
 523         }
 524         if (($p = strpos($logo, '?')) !== false) {
 525                 $logo = substr($logo, 0, $p);
 526         }
 527
 528         $srcsize = false;
 529         if (isset($largeur_img[$logo])) {
 530                 $srcWidth = $largeur_img[$logo];
 531         }
 532         if (isset($hauteur_img[$logo])) {
 533                 $srcHeight = $hauteur_img[$logo];
 534         }
 535         if (!$srcWidth or !$srcHeight) {
 536                 if (file_exists($logo)
 537                         and $srcsize = @getimagesize($logo)
 538                 ) {
 539                         if (!$srcWidth) {
 540                                 $largeur_img[$logo] = $srcWidth = $srcsize[0];
 541                         }
 542                         if (!$srcHeight) {
 543                                 $hauteur_img[$logo] = $srcHeight = $srcsize[1];
 544                         }
 545                 }
 546                 // $logo peut etre une reference a une image temporaire dont a n'a que le log .src
 547                 // on s'y refere, l'image sera reconstruite en temps utile si necessaire
 548                 elseif (@file_exists($f = "$logo.src")
 549                         and lire_fichier($f, $valeurs)
 550                         and $valeurs = unserialize($valeurs)
 551                 ) {
 552                         if (!$srcWidth) {
 553                                 $largeur_img[$logo] = $srcWidth = $valeurs["largeur_dest"];
 554                         }
 555                         if (!$srcHeight) {
 556                                 $hauteur_img[$logo] = $srcHeight = $valeurs["hauteur_dest"];
 557                         }
 558                 }
 559         }
 560
 561         return array($srcHeight, $srcWidth);
 562 }
 563
 564
 565 /**
 566  * Retourne la largeur d'une image
 567  *
 568  * @filtre
 569  * @link http://www.spip.net/4296
 570  * @uses taille_image()
 571  * @see  hauteur()
 572  *
 573  * @param string $img
 574  *     Balise HTML `<img ... />` ou chemin de l'image (qui peut être une URL distante).
 575  * @return int|null
 576  *     Largeur en pixels, NULL ou 0 si aucune image.
 577  **/
 578 function largeur($img) {
 579         if (!$img) {
 580                 return;
 581         }
 582         list($h, $l) = taille_image($img);
 583
 584         return $l;
 585 }
 586
 587 /**
 588  * Retourne la hauteur d'une image
 589  *
 590  * @filtre
 591  * @link http://www.spip.net/4291
 592  * @uses taille_image()
 593  * @see  largeur()
 594  *
 595  * @param string $img
 596  *     Balise HTML `<img ... />` ou chemin de l'image (qui peut être une URL distante).
 597  * @return int|null
 598  *     Hauteur en pixels, NULL ou 0 si aucune image.
 599  **/
 600 function hauteur($img) {
 601         if (!$img) {
 602                 return;
 603         }
 604         list($h, $l) = taille_image($img);
 605
 606         return $h;
 607 }
 608
 609
 610 /**
 611  * Échappement des entités HTML avec correction des entités « brutes »
 612  *
 613  * Ces entités peuvent être générées par les butineurs lorsqu'on rentre des
 614  * caractères n'appartenant pas au charset de la page [iso-8859-1 par défaut]
 615  *
 616  * Attention on limite cette correction aux caracteres « hauts » (en fait > 99
 617  * pour aller plus vite que le > 127 qui serait logique), de manière à
 618  * préserver des eéhappements de caractères « bas » (par exemple `[` ou `"`)
 619  * et au cas particulier de `&amp;` qui devient `&amp;amp;` dans les URL
 620  *
 621  * @see corriger_toutes_entites_html()
 622  * @param string $texte
 623  * @return string
 624  **/
 625 function corriger_entites_html($texte) {
 626         if (strpos($texte, '&amp;') === false) {
 627                 return $texte;
 628         }
 629
 630         return preg_replace(',&amp;(#[0-9][0-9][0-9]+;|amp;),iS', '&\1', $texte);
 631 }
 632
 633 /**
 634  * Échappement des entités HTML avec correction des entités « brutes » ainsi
 635  * que les `&amp;eacute;` en `&eacute;`
 636  *
 637  * Identique à `corriger_entites_html()` en corrigeant aussi les
 638  * `&amp;eacute;` en `&eacute;`
 639  *
 640  * @see corriger_entites_html()
 641  * @param string $texte
 642  * @return string
 643  **/
 644 function corriger_toutes_entites_html($texte) {
 645         if (strpos($texte, '&amp;') === false) {
 646                 return $texte;
 647         }
 648
 649         return preg_replace(',&amp;(#?[a-z0-9]+;),iS', '&\1', $texte);
 650 }
 651
 652 /**
 653  * Échappe les `&` en `&amp;`
 654  *
 655  * @param string $texte
 656  * @return string
 657  **/
 658 function proteger_amp($texte) {
 659         return str_replace('&', '&amp;', $texte);
 660 }
 661
 662
 663 /**
 664  * Échappe en entités HTML certains caractères d'un texte
 665  *
 666  * Traduira un code HTML en transformant en entités HTML les caractères
 667  * en dehors du charset de la page ainsi que les `"`, `<` et `>`.
 668  *
 669  * Ceci permet d’insérer le texte d’une balise dans un `<textarea> </textarea>`
 670  * sans dommages.
 671  *
 672  * @filtre
 673  * @link http://www.spip.net/4280
 674  *
 675  * @uses echappe_html()
 676  * @uses echappe_retour()
 677  * @uses proteger_amp()
 678  * @uses corriger_entites_html()
 679  * @uses corriger_toutes_entites_html()
 680  *
 681  * @param string $texte
 682  *   chaine a echapper
 683  * @param bool $tout
 684  *   corriger toutes les `&amp;xx;` en `&xx;`
 685  * @param bool $quote
 686  *   Échapper aussi les simples quotes en `&#039;`
 687  * @return mixed|string
 688  */
 689 function entites_html($texte, $tout = false, $quote = true) {
 690         if (!is_string($texte) or !$texte
 691                 or strpbrk($texte, "&\"'<>") == false
 692         ) {
 693                 return $texte;
 694         }
 695         include_spip('inc/texte');
 696         $flags = ($quote ? ENT_QUOTES : ENT_NOQUOTES);
 697         if (defined('ENT_HTML401')) {
 698                 $flags |= ENT_HTML401;
 699         }
 700         $texte = spip_htmlspecialchars(echappe_retour(echappe_html($texte, '', true), '', 'proteger_amp'), $flags);
 701         if ($tout) {
 702                 return corriger_toutes_entites_html($texte);
 703         } else {
 704                 return corriger_entites_html($texte);
 705         }
 706 }
 707
 708 /**
 709  * Convertit les caractères spéciaux HTML dans le charset du site.
 710  *
 711  * @exemple
 712  *     Si le charset de votre site est `utf-8`, `&eacute;` ou `&#233;`
 713  *     sera transformé en `é`
 714  *
 715  * @filtre
 716  * @link http://www.spip.net/5513
 717  *
 718  * @param string $texte
 719  *     Texte à convertir
 720  * @return string
 721  *     Texte converti
 722  **/
 723 function filtrer_entites($texte) {
 724         if (strpos($texte, '&') === false) {
 725                 return $texte;
 726         }
 727         // filtrer
 728         $texte = html2unicode($texte);
 729         // remettre le tout dans le charset cible
 730         $texte = unicode2charset($texte);
 731         // cas particulier des " et ' qu'il faut filtrer aussi
 732         // (on le faisait deja avec un &quot;)
 733         if (strpos($texte, "&#") !== false) {
 734                 $texte = str_replace(array("&#039;", "&#39;", "&#034;", "&#34;"), array("'", "'", '"', '"'), $texte);
 735         }
 736
 737         return $texte;
 738 }
 739
 740
 741 if (!function_exists('filtre_filtrer_entites_dist')) {
 742         /**
 743          * Version sécurisée de filtrer_entites
 744          *
 745          * @uses interdire_scripts()
 746          * @uses filtrer_entites()
 747          *
 748          * @param string $t
 749          * @return string
 750          */
 751         function filtre_filtrer_entites_dist($t) {
 752                 include_spip('inc/texte');
 753                 return interdire_scripts(filtrer_entites($t));
 754         }
 755 }
 756
 757
 758 /**
 759  * Supprime des caractères illégaux
 760  *
 761  * Remplace les caractères de controle par le caractère `-`
 762  *
 763  * @link http://www.w3.org/TR/REC-xml/#charsets
 764  *
 765  * @param string|array $texte
 766  * @return string|array
 767  **/
 768 function supprimer_caracteres_illegaux($texte) {
 769         static $from = "\x0\x1\x2\x3\x4\x5\x6\x7\x8\xB\xC\xE\xF\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F";
 770         static $to = null;
 771
 772         if (is_array($texte)) {
 773                 return array_map('supprimer_caracteres_illegaux', $texte);
 774         }
 775
 776         if (!$to) {
 777                 $to = str_repeat('-', strlen($from));
 778         }
 779
 780         return strtr($texte, $from, $to);
 781 }
 782
 783 /**
 784  * Correction de caractères
 785  *
 786  * Supprimer les caracteres windows non conformes et les caracteres de controle illégaux
 787  *
 788  * @param string|array $texte
 789  * @return string|array
 790  **/
 791 function corriger_caracteres($texte) {
 792         $texte = corriger_caracteres_windows($texte);
 793         $texte = supprimer_caracteres_illegaux($texte);
 794
 795         return $texte;
 796 }
 797
 798 /**
 799  * Encode du HTML pour transmission XML notamment dans les flux RSS
 800  *
 801  * Ce filtre transforme les liens en liens absolus, importe les entitées html et échappe les tags html.
 802  *
 803  * @filtre
 804  * @link http://www.spip.net/4287
 805  *
 806  * @param string $texte
 807  *     Texte à transformer
 808  * @return string
 809  *     Texte encodé pour XML
 810  */
 811 function texte_backend($texte) {
 812
 813         static $apostrophe = array("&#8217;", "'"); # n'allouer qu'une fois
 814
 815         // si on a des liens ou des images, les passer en absolu
 816         $texte = liens_absolus($texte);
 817
 818         // echapper les tags &gt; &lt;
 819         $texte = preg_replace(',&(gt|lt);,S', '&amp;\1;', $texte);
 820
 821         // importer les &eacute;
 822         $texte = filtrer_entites($texte);
 823
 824         // " -> &quot; et tout ce genre de choses
 825         $u = $GLOBALS['meta']['pcre_u'];
 826         $texte = str_replace("&nbsp;", " ", $texte);
 827         $texte = preg_replace('/\s{2,}/S' . $u, " ", $texte);
 828         // ne pas echapper les sinqle quotes car certains outils de syndication gerent mal
 829         $texte = entites_html($texte, false, false);
 830         // mais bien echapper les double quotes !
 831         $texte = str_replace('"', '&#034;', $texte);
 832
 833         // verifier le charset
 834         $texte = charset2unicode($texte);
 835
 836         // Caracteres problematiques en iso-latin 1
 837         if (isset($GLOBALS['meta']['charset']) and $GLOBALS['meta']['charset'] == 'iso-8859-1') {
 838                 $texte = str_replace(chr(156), '&#156;', $texte);
 839                 $texte = str_replace(chr(140), '&#140;', $texte);
 840                 $texte = str_replace(chr(159), '&#159;', $texte);
 841         }
 842
 843         // l'apostrophe curly pose probleme a certains lecteure de RSS
 844         // et le caractere apostrophe alourdit les squelettes avec PHP
 845         // ==> on les remplace par l'entite HTML
 846         return str_replace($apostrophe, "'", $texte);
 847 }
 848
 849 /**
 850  * Encode et quote du HTML pour transmission XML notamment dans les flux RSS
 851  *
 852  * Comme texte_backend(), mais avec addslashes final pour squelettes avec PHP (rss)
 853  *
 854  * @uses texte_backend()
 855  * @filtre
 856  *
 857  * @param string $texte
 858  *     Texte à transformer
 859  * @return string
 860  *     Texte encodé et quote pour XML
 861  */
 862 function texte_backendq($texte) {
 863         return addslashes(texte_backend($texte));
 864 }
 865
 866
 867 /**
 868  * Enlève un numéro préfixant un texte
 869  *
 870  * Supprime `10. ` dans la chaine `10. Titre`
 871  *
 872  * @filtre
 873  * @link http://www.spip.net/4314
 874  * @see recuperer_numero() Pour obtenir le numéro
 875  * @example
 876  *     ```
 877  *     [<h1>(#TITRE|supprimer_numero)</h1>]
 878  *     ```
 879  *
 880  * @param string $texte
 881  *     Texte
 882  * @return int|string
 883  *     Numéro de titre, sinon chaîne vide
 884  **/
 885 function supprimer_numero($texte) {
 886         return preg_replace(
 887                 ",^[[:space:]]*([0-9]+)([.)]|" . chr(194) . '?' . chr(176) . ")[[:space:]]+,S",
 888                 "", $texte);
 889 }
 890
 891 /**
 892  * Récupère un numéro préfixant un texte
 893  *
 894  * Récupère le numéro `10` dans la chaine `10. Titre`
 895  *
 896  * @filtre
 897  * @link http://www.spip.net/5514
 898  * @see supprimer_numero() Pour supprimer le numéro
 899  * @see balise_RANG_dist() Pour obtenir un numéro de titre
 900  * @example
 901  *     ```
 902  *     [(#TITRE|recuperer_numero)]
 903  *     ```
 904  *
 905  * @param string $texte
 906  *     Texte
 907  * @return int|string
 908  *     Numéro de titre, sinon chaîne vide
 909  **/
 910 function recuperer_numero($texte) {
 911         if (preg_match(
 912                 ",^[[:space:]]*([0-9]+)([.)]|" . chr(194) . '?' . chr(176) . ")[[:space:]]+,S",
 913                 $texte, $regs)) {
 914                 return strval($regs[1]);
 915         } else {
 916                 return '';
 917         }
 918 }
 919
 920 /**
 921  * Suppression basique et brutale de tous les tags
 922  *
 923  * Supprime tous les tags `<...>`.
 924  * Utilisé fréquemment pour écrire des RSS.
 925  *
 926  * @filtre
 927  * @link http://www.spip.net/4315
 928  * @example
 929  *     ```
 930  *     <title>[(#TITRE|supprimer_tags|texte_backend)]</title>
 931  *     ```
 932  *
 933  * @note
 934  *     Ce filtre supprime aussi les signes inférieurs `<` rencontrés.
 935  *
 936  * @param string $texte
 937  *     Texte à échapper
 938  * @param string $rempl
 939  *     Inutilisé.
 940  * @return string
 941  *     Texte converti
 942  **/
 943 function supprimer_tags($texte, $rempl = "") {
 944         $texte = preg_replace(",<(!--|\w|/)[^>]*>,US", $rempl, $texte);
 945         // ne pas oublier un < final non ferme car coupe
 946         $texte = preg_replace(",<(!--|\w|/).*$,US", $rempl, $texte);
 947         // mais qui peut aussi etre un simple signe plus petit que
 948         $texte = str_replace('<', '&lt;', $texte);
 949
 950         return $texte;
 951 }
 952
 953 /**
 954  * Convertit les chevrons de tag en version lisible en HTML
 955  *
 956  * Transforme les chevrons de tag `<...>` en entité HTML.
 957  *
 958  * @filtre
 959  * @link http://www.spip.net/5515
 960  * @example
 961  *     ```
 962  *     <pre>[(#TEXTE|echapper_tags)]</pre>
 963  *     ```
 964  *
 965  * @param string $texte
 966  *     Texte à échapper
 967  * @param string $rempl
 968  *     Inutilisé.
 969  * @return string
 970  *     Texte converti
 971  **/
 972 function echapper_tags($texte, $rempl = "") {
 973         $texte = preg_replace("/<([^>]*)>/", "&lt;\\1&gt;", $texte);
 974
 975         return $texte;
 976 }
 977
 978 /**
 979  * Convertit un texte HTML en texte brut
 980  *
 981  * Enlève les tags d'un code HTML, élimine les doubles espaces.
 982  *
 983  * @filtre
 984  * @link http://www.spip.net/4317
 985  * @example
 986  *     ```
 987  *     <title>[(#TITRE|textebrut) - ][(#NOM_SITE_SPIP|textebrut)]</title>
 988  *     ```
 989  *
 990  * @param string $texte
 991  *     Texte à convertir
 992  * @return string
 993  *     Texte converti
 994  **/
 995 function textebrut($texte) {
 996         $u = $GLOBALS['meta']['pcre_u'];
 997         $texte = preg_replace('/\s+/S' . $u, " ", $texte);
 998         $texte = preg_replace("/<(p|br)( [^>]*)?" . ">/iS", "\n\n", $texte);
 999         $texte = preg_replace("/^\n+/", "", $texte);
1000         $texte = preg_replace("/\n+$/", "", $texte);
1001         $texte = preg_replace("/\n +/", "\n", $texte);
1002         $texte = supprimer_tags($texte);
1003         $texte = preg_replace("/(&nbsp;| )+/S", " ", $texte);
1004         // nettoyer l'apostrophe curly qui pose probleme a certains rss-readers, lecteurs de mail...
1005         $texte = str_replace("&#8217;", "'", $texte);
1006
1007         return $texte;
1008 }
1009
1010
1011 /**
1012  * Remplace les liens SPIP en liens ouvrant dans une nouvelle fenetre (target=blank)
1013  *
1014  * @filtre
1015  * @link http://www.spip.net/4297
1016  *
1017  * @param string $texte
1018  *     Texte avec des liens
1019  * @return string
1020  *     Texte avec liens ouvrants
1021  **/
1022 function liens_ouvrants($texte) {
1023         if (preg_match_all(",(<a\s+[^>]*https?://[^>]*class=[\"']spip_(out|url)\b[^>]+>),imsS",
1024                 $texte, $liens, PREG_PATTERN_ORDER)) {
1025                 foreach ($liens[0] as $a) {
1026                         $rel = 'noopener noreferrer ' . extraire_attribut($a, 'rel');
1027                         $ablank = inserer_attribut($a, 'rel', $rel);
1028                         $ablank = inserer_attribut($ablank, 'target', '_blank');
1029                         $texte = str_replace($a, $ablank, $texte);
1030                 }
1031         }
1032
1033         return $texte;
1034 }
1035
1036 /**
1037  * Ajouter un attribut rel="nofollow" sur tous les liens d'un texte
1038  *
1039  * @param string $texte
1040  * @return string
1041  */
1042 function liens_nofollow($texte) {
1043         if (stripos($texte, "<a") === false) {
1044                 return $texte;
1045         }
1046
1047         if (preg_match_all(",<a\b[^>]*>,UimsS", $texte, $regs, PREG_PATTERN_ORDER)) {
1048                 foreach ($regs[0] as $a) {
1049                         $rel = extraire_attribut($a, "rel");
1050                         if (strpos($rel, "nofollow") === false) {
1051                                 $rel = "nofollow" . ($rel ? " $rel" : "");
1052                                 $anofollow = inserer_attribut($a, "rel", $rel);
1053                                 $texte = str_replace($a, $anofollow, $texte);
1054                         }
1055                 }
1056         }
1057
1058         return $texte;
1059 }
1060
1061 /**
1062  * Transforme les sauts de paragraphe HTML `p` en simples passages à la ligne `br`
1063  *
1064  * @filtre
1065  * @link http://www.spip.net/4308
1066  * @example
1067  *     ```
1068  *     [<div>(#DESCRIPTIF|PtoBR)[(#NOTES|PtoBR)]</div>]
1069  *     ```
1070  *
1071  * @param string $texte
1072  *     Texte à transformer
1073  * @return string
1074  *     Texte sans paraghaphes
1075  **/
1076 function PtoBR($texte) {
1077         $u = $GLOBALS['meta']['pcre_u'];
1078         $texte = preg_replace("@</p>@iS", "\n", $texte);
1079         $texte = preg_replace("@<p\b.*>@UiS", "<br />", $texte);
1080         $texte = preg_replace("@^\s*<br />@S" . $u, "", $texte);
1081
1082         return $texte;
1083 }
1084
1085
1086 /**
1087  * Assure qu'un texte ne vas pas déborder d'un bloc
1088  * par la faute d'un mot trop long (souvent des URLs)
1089  *
1090  * Ne devrait plus être utilisé et fait directement en CSS par un style
1091  * `word-wrap:break-word;`
1092  *
1093  * @note
1094  *   Pour assurer la compatibilité du filtre, on encapsule le contenu par
1095  *   un `div` ou `span` portant ce style CSS inline.
1096  *
1097  * @filtre
1098  * @link http://www.spip.net/4298
1099  * @link http://www.alsacreations.com/tuto/lire/1038-gerer-debordement-contenu-css.html
1100  * @deprecated Utiliser le style CSS `word-wrap:break-word;`
1101  *
1102  * @param string $texte Texte
1103  * @return string Texte encadré du style CSS
1104  */
1105 function lignes_longues($texte) {
1106         if (!strlen(trim($texte))) {
1107                 return $texte;
1108         }
1109         include_spip('inc/texte');
1110         $tag = preg_match(',</?(' . _BALISES_BLOCS . ')[>[:space:]],iS', $texte) ?
1111                 'div' : 'span';
1112
1113         return "<$tag style='word-wrap:break-word;'>$texte</$tag>";
1114 }
1115
1116 /**
1117  * Passe un texte en majuscules, y compris les accents, en HTML
1118  *
1119  * Encadre le texte du style CSS `text-transform: uppercase;`.
1120  * Le cas spécifique du i turc est géré.
1121  *
1122  * @filtre
1123  * @example
1124  *     ```
1125  *     [(#EXTENSION|majuscules)]
1126  *     ```
1127  *
1128  * @param string $texte Texte
1129  * @return string Texte en majuscule
1130  */
1131 function majuscules($texte) {
1132         if (!strlen($texte)) {
1133                 return '';
1134         }
1135
1136         // Cas du turc
1137         if ($GLOBALS['spip_lang'] == 'tr') {
1138                 # remplacer hors des tags et des entites
1139                 if (preg_match_all(',<[^<>]+>|&[^;]+;,S', $texte, $regs, PREG_SET_ORDER)) {
1140                         foreach ($regs as $n => $match) {
1141                                 $texte = str_replace($match[0], "@@SPIP_TURC$n@@", $texte);
1142                         }
1143                 }
1144
1145                 $texte = str_replace('i', '&#304;', $texte);
1146
1147                 if ($regs) {
1148                         foreach ($regs as $n => $match) {
1149                                 $texte = str_replace("@@SPIP_TURC$n@@", $match[0], $texte);
1150                         }
1151                 }
1152         }
1153
1154         // Cas general
1155         return "<span style='text-transform: uppercase;'>$texte</span>";
1156 }
1157
1158 /**
1159  * Retourne une taille en octets humainement lisible
1160  *
1161  * Tel que "127.4 ko" ou "3.1 Mo"
1162  *
1163  * @example
1164  *     - `[(#TAILLE|taille_en_octets)]`
1165  *     - `[(#VAL{123456789}|taille_en_octets)]` affiche `117.7 Mo`
1166  *
1167  * @filtre
1168  * @link http://www.spip.net/4316
1169  * @param int $taille
1170  * @return string
1171  **/
1172 function taille_en_octets($taille) {
1173         if (!defined('_KILOBYTE')) {
1174                 /**
1175                  * Définit le nombre d'octets dans un Kilobyte
1176                  *
1177                  * @var int
1178                  **/
1179                 define('_KILOBYTE', 1024);
1180         }
1181
1182         if ($taille < 1) {
1183                 return '';
1184         }
1185         if ($taille < _KILOBYTE) {
1186                 $taille = _T('taille_octets', array('taille' => $taille));
1187         } elseif ($taille < _KILOBYTE * _KILOBYTE) {
1188                 $taille = _T('taille_ko', array('taille' => round($taille / _KILOBYTE, 1)));
1189         } elseif ($taille < _KILOBYTE * _KILOBYTE * _KILOBYTE) {
1190                 $taille = _T('taille_mo', array('taille' => round($taille / _KILOBYTE / _KILOBYTE, 1)));
1191         } else {
1192                 $taille = _T('taille_go', array('taille' => round($taille / _KILOBYTE / _KILOBYTE / _KILOBYTE, 2)));
1193         }
1194
1195         return $taille;
1196 }
1197
1198
1199 /**
1200  * Rend une chaine utilisable sans dommage comme attribut HTML
1201  *
1202  * @example `<a href="#URL_ARTICLE" title="[(#TITRE|attribut_html)]">#TITRE</a>`
1203  *
1204  * @filtre
1205  * @link http://www.spip.net/4282
1206  * @uses textebrut()
1207  * @uses texte_backend()
1208  *
1209  * @param string $texte
1210  *     Texte à mettre en attribut
1211  * @param bool $textebrut
1212  *     Passe le texte en texte brut (enlève les balises html) ?
1213  * @return string
1214  *     Texte prêt pour être utilisé en attribut HTML
1215  **/
1216 function attribut_html($texte, $textebrut = true) {
1217         $u = $GLOBALS['meta']['pcre_u'];
1218         if ($textebrut) {
1219                 $texte = preg_replace(array(",\n,", ",\s(?=\s),msS" . $u), array(" ", ""), textebrut($texte));
1220         }
1221         $texte = texte_backend($texte);
1222         $texte = str_replace(array("'", '"'), array('&#039;', '&#034;'), $texte);
1223
1224         return preg_replace(array("/&(amp;|#38;)/", "/&(?![A-Za-z]{0,4}\w{2,3};|#[0-9]{2,5};)/"), array("&", "&#38;"),
1225                 $texte);
1226 }
1227
1228
1229 /**
1230  * Vider les URL nulles
1231  *
1232  * - Vide les URL vides comme `http://` ou `mailto:` (sans rien d'autre)
1233  * - échappe les entités et gère les `&amp;`
1234  *
1235  * @uses entites_html()
1236  *
1237  * @param string $url
1238  *     URL à vérifier et échapper
1239  * @param bool $entites
1240  *     `true` pour échapper les entités HTML.
1241  * @return string
1242  *     URL ou chaîne vide
1243  **/
1244 function vider_url($url, $entites = true) {
1245         # un message pour abs_url
1246         $GLOBALS['mode_abs_url'] = 'url';
1247         $url = trim($url);
1248         $r = ",^(?:" . _PROTOCOLES_STD . '):?/?/?$,iS';
1249
1250         return preg_match($r, $url) ? '' : ($entites ? entites_html($url) : $url);
1251 }
1252
1253
1254 /**
1255  * Maquiller une adresse e-mail
1256  *
1257  * Remplace `@` par 3 caractères aléatoires.
1258  *
1259  * @uses creer_pass_aleatoire()
1260  *
1261  * @param string $texte Adresse email
1262  * @return string Adresse email maquillée
1263  **/
1264 function antispam($texte) {
1265         include_spip('inc/acces');
1266         $masque = creer_pass_aleatoire(3);
1267
1268         return preg_replace("/@/", " $masque ", $texte);
1269 }
1270
1271 /**
1272  * Vérifie un accès à faible sécurité
1273  *
1274  * Vérifie qu'un visiteur peut accéder à la page demandée,
1275  * qui est protégée par une clé, calculée à partir du low_sec de l'auteur,
1276  * et des paramètres le composant l'appel (op, args)
1277  *
1278  * @example
1279  *     `[(#ID_AUTEUR|securiser_acces{#ENV{cle}, rss, #ENV{op}, #ENV{args}}|sinon_interdire_acces)]`
1280  *
1281  * @see  bouton_spip_rss() pour générer un lien de faible sécurité pour les RSS privés
1282  * @see  afficher_low_sec() pour calculer une clé valide
1283  * @uses verifier_low_sec()
1284  *
1285  * @filtre
1286  * @param int $id_auteur
1287  *     L'auteur qui demande la page
1288  * @param string $cle
1289  *     La clé à tester
1290  * @param string $dir
1291  *     Un type d'accès (nom du répertoire dans lequel sont rangés les squelettes demandés, tel que 'rss')
1292  * @param string $op
1293  *     Nom de l'opération éventuelle
1294  * @param string $args
1295  *     Nom de l'argument calculé
1296  * @return bool
1297  *     True si on a le droit d'accès, false sinon.
1298  **/
1299 function securiser_acces($id_auteur, $cle, $dir, $op = '', $args = '') {
1300         include_spip('inc/acces');
1301         if ($op) {
1302                 $dir .= " $op $args";
1303         }
1304
1305         return verifier_low_sec($id_auteur, $cle, $dir);
1306 }
1307
1308 /**
1309  * Retourne le second paramètre lorsque
1310  * le premier est considere vide, sinon retourne le premier paramètre.
1311  *
1312  * En php `sinon($a, 'rien')` retourne `$a`, ou `'rien'` si `$a` est vide.
1313  * En filtre SPIP `|sinon{#TEXTE, rien}` : affiche `#TEXTE` ou `rien` si `#TEXTE` est vide,
1314  *
1315  * @filtre
1316  * @see filtre_logique() pour la compilation du filtre dans un squelette
1317  * @link http://www.spip.net/4313
1318  * @note
1319  *     L'utilisation de `|sinon` en tant que filtre de squelette
1320  *     est directement compilé dans `public/references` par la fonction `filtre_logique()`
1321  *
1322  * @param mixed $texte
1323  *     Contenu de reference a tester
1324  * @param mixed $sinon
1325  *     Contenu a retourner si le contenu de reference est vide
1326  * @return mixed
1327  *     Retourne $texte, sinon $sinon.
1328  **/
1329 function sinon($texte, $sinon = '') {
1330         if ($texte or (!is_array($texte) and strlen($texte))) {
1331                 return $texte;
1332         } else {
1333                 return $sinon;
1334         }
1335 }
1336
1337 /**
1338  * Filtre `|choixsivide{vide, pas vide}` alias de `|?{si oui, si non}` avec les arguments inversés
1339  *
1340  * @example
1341  *     `[(#TEXTE|choixsivide{vide, plein})]` affiche vide si le `#TEXTE`
1342  *     est considéré vide par PHP (chaîne vide, false, 0, tableau vide, etc…).
1343  *     C'est l'équivalent de `[(#TEXTE|?{plein, vide})]`
1344  *
1345  * @filtre
1346  * @see choixsiegal()
1347  * @link http://www.spip.net/4189
1348  *
1349  * @param mixed $a
1350  *     La valeur à tester
1351  * @param mixed $vide
1352  *     Ce qui est retourné si `$a` est considéré vide
1353  * @param mixed $pasvide
1354  *     Ce qui est retourné sinon
1355  * @return mixed
1356  **/
1357 function choixsivide($a, $vide, $pasvide) {
1358         return $a ? $pasvide : $vide;
1359 }
1360
1361 /**
1362  * Filtre `|choixsiegal{valeur, sioui, sinon}`
1363  *
1364  * @example
1365  *     `#LANG_DIR|choixsiegal{ltr,left,right}` retourne `left` si
1366  *      `#LANG_DIR` vaut `ltr` et `right` sinon.
1367  *
1368  * @filtre
1369  * @link http://www.spip.net/4148
1370  *
1371  * @param mixed $a1
1372  *     La valeur à tester
1373  * @param mixed $a2
1374  *     La valeur de comparaison
1375  * @param mixed $v
1376  *     Ce qui est retourné si la comparaison est vraie
1377  * @param mixed $f
1378  *     Ce qui est retourné sinon
1379  * @return mixed
1380  **/
1381 function choixsiegal($a1, $a2, $v, $f) {
1382         return ($a1 == $a2) ? $v : $f;
1383 }
1384
1385 /**
1386  * Alignements en HTML (Old-style, préférer CSS)
1387  *
1388  * Cette fonction ne crée pas de paragraphe
1389  *
1390  * @deprecated Utiliser CSS
1391  * @param string $letexte
1392  * @param string $justif
1393  * @return string
1394  */
1395 function aligner($letexte, $justif = '') {
1396         $letexte = trim($letexte);
1397         if (!strlen($letexte)) {
1398                 return '';
1399         }
1400
1401         // Paragrapher rapidement
1402         $letexte = "<div style='text-align:$justif'>"
1403                 . $letexte
1404                 . "</div>";
1405
1406         return $letexte;
1407 }
1408
1409 /**
1410  * Justifie en HTML (Old-style, préférer CSS)
1411  *
1412  * @deprecated Utiliser CSS
1413  * @uses aligner()
1414  * @param string $letexte
1415  * @return string
1416  */
1417 function justifier($letexte) { return aligner($letexte, 'justify'); }
1418
1419 /**
1420  * Aligne à droite en HTML (Old-style, préférer CSS)
1421  *
1422  * @deprecated Utiliser CSS
1423  * @uses aligner()
1424  * @param string $letexte
1425  * @return string
1426  */
1427 function aligner_droite($letexte) { return aligner($letexte, 'right'); }
1428
1429 /**
1430  * Aligne à gauche en HTML (Old-style, préférer CSS)
1431  *
1432  * @deprecated Utiliser CSS
1433  * @uses aligner()
1434  * @param string $letexte
1435  * @return string
1436  */
1437 function aligner_gauche($letexte) { return aligner($letexte, 'left'); }
1438
1439 /**
1440  * Centre en HTML (Old-style, préférer CSS)
1441  *
1442  * @deprecated Utiliser CSS
1443  * @uses aligner()
1444  * @param string $letexte
1445  * @return string
1446  */
1447 function centrer($letexte) { return aligner($letexte, 'center'); }
1448
1449 /**
1450  * Retourne un texte de style CSS aligné sur la langue en cours
1451  *
1452  * @deprecated
1453  * @param mixed $bof Inutilisé
1454  * @return string Style CSS
1455  **/
1456 function style_align($bof) {
1457
1458         return "text-align: " . $GLOBALS['spip_lang_left'];
1459 }
1460
1461 //
1462 // Export iCal
1463 //
1464
1465 /**
1466  * Adapte un texte pour être inséré dans une valeur d'un export ICAL
1467  *
1468  * Passe le texte en utf8, enlève les sauts de lignes et échappe les virgules.
1469  *
1470  * @example `SUMMARY:[(#TITRE|filtrer_ical)]`
1471  * @filtre
1472  *
1473  * @param string $texte
1474  * @return string
1475  **/
1476 function filtrer_ical($texte) {
1477         #include_spip('inc/charsets');
1478         $texte = html2unicode($texte);
1479         $texte = unicode2charset(charset2unicode($texte, $GLOBALS['meta']['charset'], 1), 'utf-8');
1480         $texte = preg_replace("/\n/", " ", $texte);
1481         $texte = preg_replace("/,/", "\,", $texte);
1482
1483         return $texte;
1484 }
1485
1486
1487 /**
1488  * Transforme les sauts de ligne simples en sauts forcés avec `_ `
1489  *
1490  * Ne modifie pas les sauts de paragraphe (2 sauts consécutifs au moins),
1491  * ou les retours à l'intérieur de modèles ou de certaines balises html.
1492  *
1493  * @note
1494  *     Cette fonction pouvait être utilisée pour forcer les alinéas,
1495  *     (retours à la ligne sans saut de paragraphe), mais ce traitement
1496  *     est maintenant automatique.
1497  *     Cf. plugin Textwheel et la constante _AUTOBR
1498  *
1499  * @uses echappe_html()
1500  * @uses echappe_retour()
1501  *
1502  * @param string $texte
1503  * @param string $delim
1504  *      Ce par quoi sont remplacés les sauts
1505  * @return string
1506  **/
1507 function post_autobr($texte, $delim = "\n_ ") {
1508         if (!function_exists('echappe_html')) {
1509                 include_spip('inc/texte_mini');
1510         }
1511         $texte = str_replace("\r\n", "\r", $texte);
1512         $texte = str_replace("\r", "\n", $texte);
1513
1514         if (preg_match(",\n+$,", $texte, $fin)) {
1515                 $texte = substr($texte, 0, -strlen($fin = $fin[0]));
1516         } else {
1517                 $fin = '';
1518         }
1519
1520         $texte = echappe_html($texte, '', true);
1521
1522         // echapper les modeles
1523         if (strpos($texte, "<") !== false) {
1524                 include_spip('inc/lien');
1525                 if (defined('_PREG_MODELE')) {
1526                         $preg_modeles = "@" . _PREG_MODELE . "@imsS";
1527                         $texte = echappe_html($texte, '', true, $preg_modeles);
1528                 }
1529         }
1530
1531         $debut = '';
1532         $suite = $texte;
1533         while ($t = strpos('-' . $suite, "\n", 1)) {
1534                 $debut .= substr($suite, 0, $t - 1);
1535                 $suite = substr($suite, $t);
1536                 $car = substr($suite, 0, 1);
1537                 if (($car <> '-') and ($car <> '_') and ($car <> "\n") and ($car <> "|") and ($car <> "}")
1538                         and !preg_match(',^\s*(\n|</?(quote|div|dl|dt|dd)|$),S', ($suite))
1539                         and !preg_match(',</?(quote|div|dl|dt|dd)> *$,iS', $debut)
1540                 ) {
1541                         $debut .= $delim;
1542                 } else {
1543                         $debut .= "\n";
1544                 }
1545                 if (preg_match(",^\n+,", $suite, $regs)) {
1546                         $debut .= $regs[0];
1547                         $suite = substr($suite, strlen($regs[0]));
1548                 }
1549         }
1550         $texte = $debut . $suite;
1551
1552         $texte = echappe_retour($texte);
1553
1554         return $texte . $fin;
1555 }
1556
1557
1558 /**
1559  * Expression régulière pour obtenir le contenu des extraits idiomes `<:module:cle:>`
1560  *
1561  * @var string
1562  */
1563 define('_EXTRAIRE_IDIOME', '@<:(?:([a-z0-9_]+):)?([a-z0-9_]+):>@isS');
1564
1565 /**
1566  * Extrait une langue des extraits idiomes (`<:module:cle_de_langue:>`)
1567  *
1568  * Retrouve les balises `<:cle_de_langue:>` d'un texte et remplace son contenu
1569  * par l'extrait correspondant à la langue demandée (si possible), sinon dans la
1570  * langue par défaut du site.
1571  *
1572  * Ne pas mettre de span@lang=fr si on est déjà en fr.
1573  *
1574  * @filtre
1575  * @uses inc_traduire_dist()
1576  * @uses code_echappement()
1577  * @uses echappe_retour()
1578  *
1579  * @param string $letexte
1580  * @param string $lang
1581  *     Langue à retrouver (si vide, utilise la langue en cours).
1582  * @param array $options Options {
1583  * @type bool $echappe_span
1584  *         True pour échapper les balises span (false par défaut)
1585  * @type string $lang_defaut
1586  *         Code de langue : permet de définir la langue utilisée par défaut,
1587  *         en cas d'absence de traduction dans la langue demandée.
1588  *         Par défaut la langue du site.
1589  *         Indiquer 'aucune' pour ne pas retourner de texte si la langue
1590  *         exacte n'a pas été trouvée.
1591  * }
1592  * @return string
1593  **/
1594 function extraire_idiome($letexte, $lang = null, $options = array()) {
1595         static $traduire = false;
1596         if ($letexte
1597                 and preg_match_all(_EXTRAIRE_IDIOME, $letexte, $regs, PREG_SET_ORDER)
1598         ) {
1599                 if (!$traduire) {
1600                         $traduire = charger_fonction('traduire', 'inc');
1601                         include_spip('inc/lang');
1602                 }
1603                 if (!$lang) {
1604                         $lang = $GLOBALS['spip_lang'];
1605                 }
1606                 // Compatibilité avec le prototype de fonction précédente qui utilisait un boolean
1607                 if (is_bool($options)) {
1608                         $options = array('echappe_span' => $options);
1609                 }
1610                 if (!isset($options['echappe_span'])) {
1611                         $options = array_merge($options, array('echappe_span' => false));
1612                 }
1613
1614                 foreach ($regs as $reg) {
1615                         $cle = ($reg[1] ? $reg[1] . ':' : '') . $reg[2];
1616                         $desc = $traduire($cle, $lang, true);
1617                         $l = $desc->langue;
1618                         // si pas de traduction, on laissera l'écriture de l'idiome entier dans le texte.
1619                         if (strlen($desc->texte)) {
1620                                 $trad = code_echappement($desc->texte, 'idiome', false);
1621                                 if ($l !== $lang) {
1622                                         $trad = str_replace("'", '"', inserer_attribut($trad, 'lang', $l));
1623                                 }
1624                                 if (lang_dir($l) !== lang_dir($lang)) {
1625                                         $trad = str_replace("'", '"', inserer_attribut($trad, 'dir', lang_dir($l)));
1626                                 }
1627                                 if (!$options['echappe_span']) {
1628                                         $trad = echappe_retour($trad, 'idiome');
1629                                 }
1630                                 $letexte = str_replace($reg[0], $trad, $letexte);
1631                         }
1632                 }
1633         }
1634         return $letexte;
1635 }
1636
1637 /**
1638  * Expression régulière pour obtenir le contenu des extraits polyglottes `<multi>`
1639  *
1640  * @var string
1641  */
1642 define('_EXTRAIRE_MULTI', "@<multi>(.*?)</multi>@sS");
1643
1644
1645 /**
1646  * Extrait une langue des extraits polyglottes (`<multi>`)
1647  *
1648  * Retrouve les balises `<multi>` d'un texte et remplace son contenu
1649  * par l'extrait correspondant à la langue demandée.
1650  *
1651  * Si la langue demandée n'est pas trouvée dans le multi, ni une langue
1652  * approchante (exemple `fr` si on demande `fr_TU`), on retourne l'extrait
1653  * correspondant à la langue par défaut (option 'lang_defaut'), qui est
1654  * par défaut la langue du site. Et si l'extrait n'existe toujours pas
1655  * dans cette langue, ça utilisera la première langue utilisée
1656  * dans la balise `<multi>`.
1657  *
1658  * Ne pas mettre de span@lang=fr si on est déjà en fr.
1659  *
1660  * @filtre
1661  * @link http://www.spip.net/5332
1662  *
1663  * @uses extraire_trads()
1664  * @uses approcher_langue()
1665  * @uses lang_typo()
1666  * @uses code_echappement()
1667  * @uses echappe_retour()
1668  *
1669  * @param string $letexte
1670  * @param string $lang
1671  *     Langue à retrouver (si vide, utilise la langue en cours).
1672  * @param array $options Options {
1673  * @type bool $echappe_span
1674  *         True pour échapper les balises span (false par défaut)
1675  * @type string $lang_defaut
1676  *         Code de langue : permet de définir la langue utilisée par défaut,
1677  *         en cas d'absence de traduction dans la langue demandée.
1678  *         Par défaut la langue du site.
1679  *         Indiquer 'aucune' pour ne pas retourner de texte si la langue
1680  *         exacte n'a pas été trouvée.
1681  * }
1682  * @return string
1683  **/
1684 function extraire_multi($letexte, $lang = null, $options = array()) {
1685
1686         if ($letexte
1687                 and preg_match_all(_EXTRAIRE_MULTI, $letexte, $regs, PREG_SET_ORDER)
1688         ) {
1689                 if (!$lang) {
1690                         $lang = $GLOBALS['spip_lang'];
1691                 }
1692
1693                 // Compatibilité avec le prototype de fonction précédente qui utilisait un boolean
1694                 if (is_bool($options)) {
1695                         $options = array('echappe_span' => $options, 'lang_defaut' => _LANGUE_PAR_DEFAUT);
1696                 }
1697                 if (!isset($options['echappe_span'])) {
1698                         $options = array_merge($options, array('echappe_span' => false));
1699                 }
1700                 if (!isset($options['lang_defaut'])) {
1701                         $options = array_merge($options, array('lang_defaut' => _LANGUE_PAR_DEFAUT));
1702                 }
1703
1704                 include_spip('inc/lang');
1705                 foreach ($regs as $reg) {
1706                         // chercher la version de la langue courante
1707                         $trads = extraire_trads($reg[1]);
1708                         if ($l = approcher_langue($trads, $lang)) {
1709                                 $trad = $trads[$l];
1710                         } else {
1711                                 if ($options['lang_defaut'] == 'aucune') {
1712                                         $trad = '';
1713                                 } else {
1714                                         // langue absente, prendre le fr ou une langue précisée (meme comportement que inc/traduire.php)
1715                                         // ou la premiere dispo
1716                                         // mais typographier le texte selon les regles de celle-ci
1717                                         // Attention aux blocs multi sur plusieurs lignes
1718                                         if (!$l = approcher_langue($trads, $options['lang_defaut'])) {
1719                                                 $l = key($trads);
1720                                         }
1721                                         $trad = $trads[$l];
1722                                         $typographie = charger_fonction(lang_typo($l), 'typographie');
1723                                         $trad = $typographie($trad);
1724                                         // Tester si on echappe en span ou en div
1725                                         // il ne faut pas echapper en div si propre produit un seul paragraphe
1726                                         include_spip('inc/texte');
1727                                         $trad_propre = preg_replace(",(^<p[^>]*>|</p>$),Uims", "", propre($trad));
1728                                         $mode = preg_match(',</?(' . _BALISES_BLOCS . ')[>[:space:]],iS', $trad_propre) ? 'div' : 'span';
1729                                         $trad = code_echappement($trad, 'multi', false, $mode);
1730                                         $trad = str_replace("'", '"', inserer_attribut($trad, 'lang', $l));
1731                                         if (lang_dir($l) !== lang_dir($lang)) {
1732                                                 $trad = str_replace("'", '"', inserer_attribut($trad, 'dir', lang_dir($l)));
1733                                         }
1734                                         if (!$options['echappe_span']) {
1735                                                 $trad = echappe_retour($trad, 'multi');
1736                                         }
1737                                 }
1738                         }
1739                         $letexte = str_replace($reg[0], $trad, $letexte);
1740                 }
1741         }
1742
1743         return $letexte;
1744 }
1745
1746 /**
1747  * Convertit le contenu d'une balise `<multi>` en un tableau
1748  *
1749  * Exemple de blocs.
1750  * - `texte par défaut [fr] en français [en] en anglais`
1751  * - `[fr] en français [en] en anglais`
1752  *
1753  * @param string $bloc
1754  *     Le contenu intérieur d'un bloc multi
1755  * @return array [code de langue => texte]
1756  *     Peut retourner un code de langue vide, lorsqu'un texte par défaut est indiqué.
1757  **/
1758 function extraire_trads($bloc) {
1759         $lang = '';
1760 // ce reg fait planter l'analyse multi s'il y a de l'{italique} dans le champ
1761 //      while (preg_match("/^(.*?)[{\[]([a-z_]+)[}\]]/siS", $bloc, $regs)) {
1762         while (preg_match("/^(.*?)[\[]([a-z_]+)[\]]/siS", $bloc, $regs)) {
1763                 $texte = trim($regs[1]);
1764                 if ($texte or $lang) {
1765                         $trads[$lang] = $texte;
1766                 }
1767                 $bloc = substr($bloc, strlen($regs[0]));
1768                 $lang = $regs[2];
1769         }
1770         $trads[$lang] = $bloc;
1771
1772         return $trads;
1773 }
1774
1775
1776 /**
1777  * Calculer l'initiale d'un nom
1778  *
1779  * @param string $nom
1780  * @return string L'initiale en majuscule
1781  */
1782 function filtre_initiale($nom) {
1783         return spip_substr(trim(strtoupper(extraire_multi($nom))), 0, 1);
1784 }
1785
1786
1787 /**
1788  * Retourne la donnée si c'est la première fois qu'il la voit
1789  *
1790  * Il est possible de gérer différentes "familles" de données avec
1791  * le second paramètre.
1792  *
1793  * @filtre
1794  * @link http://www.spip.net/4320
1795  * @example
1796  *     ```
1797  *     [(#ID_SECTEUR|unique)]
1798  *     [(#ID_SECTEUR|unique{tete})] n'a pas d'incidence sur
1799  *     [(#ID_SECTEUR|unique{pied})]
1800  *     [(#ID_SECTEUR|unique{pied,1})] affiche le nombre d'éléments.
1801  *     Préférer totefois #TOTAL_UNIQUE{pied}
1802  *     ```
1803  *
1804  * @todo
1805  *    Ameliorations possibles :
1806  *
1807  *    1) si la donnée est grosse, mettre son md5 comme clé
1808  *    2) purger $mem quand on change de squelette (sinon bug inclusions)
1809  *
1810  * @param string $donnee
1811  *      Donnée que l'on souhaite unique
1812  * @param string $famille
1813  *      Famille de stockage (1 unique donnée par famille)
1814  *
1815  *      - _spip_raz_ : (interne) Vide la pile de mémoire et la retourne
1816  *      - _spip_set_ : (interne) Affecte la pile de mémoire avec la donnée
1817  * @param bool $cpt
1818  *      True pour obtenir le nombre d'éléments différents stockés
1819  * @return string|int|array|null|void
1820  *
1821  *      - string : Donnée si c'est la première fois qu'elle est vue
1822  *      - void : si la donnée a déjà été vue
1823  *      - int : si l'on demande le nombre d'éléments
1824  *      - array (interne) : si on dépile
1825  *      - null (interne) : si on empile
1826  **/
1827 function unique($donnee, $famille = '', $cpt = false) {
1828         static $mem = array();
1829         // permettre de vider la pile et de la restaurer
1830         // pour le calcul de introduction...
1831         if ($famille == '_spip_raz_') {
1832                 $tmp = $mem;
1833                 $mem = array();
1834
1835                 return $tmp;
1836         } elseif ($famille == '_spip_set_') {
1837                 $mem = $donnee;
1838
1839                 return;
1840         }
1841         // eviter une notice
1842         if (!isset($mem[$famille])) {
1843                 $mem[$famille] = array();
1844         }
1845         if ($cpt) {
1846                 return count($mem[$famille]);
1847         }
1848         // eviter une notice
1849         if (!isset($mem[$famille][$donnee])) {
1850                 $mem[$famille][$donnee] = 0;
1851         }
1852         if (!($mem[$famille][$donnee]++)) {
1853                 return $donnee;
1854         }
1855 }
1856
1857
1858 /**
1859  * Filtre qui alterne des valeurs en fonction d'un compteur
1860  *
1861  * Affiche à tour de rôle et dans l'ordre, un des arguments transmis
1862  * à chaque incrément du compteur.
1863  *
1864  * S'il n'y a qu'un seul argument, et que c'est un tableau,
1865  * l'alternance se fait sur les valeurs du tableau.
1866  *
1867  * Souvent appliqué à l'intérieur d'une boucle, avec le compteur `#COMPTEUR_BOUCLE`
1868  *
1869  * @example
1870  *     - `[(#COMPTEUR_BOUCLE|alterner{bleu,vert,rouge})]`
1871  *     - `[(#COMPTEUR_BOUCLE|alterner{#LISTE{bleu,vert,rouge}})]`
1872  *
1873  * @filtre
1874  * @link http://www.spip.net/4145
1875  *
1876  * @param int $i
1877  *     Le compteur
1878  * @return mixed
1879  *     Une des valeurs en fonction du compteur.
1880  **/
1881 function alterner($i) {
1882         // recuperer les arguments (attention fonctions un peu space)
1883         $num = func_num_args();
1884         $args = func_get_args();
1885
1886         if ($num == 2 && is_array($args[1])) {
1887                 $args = $args[1];
1888                 array_unshift($args, '');
1889                 $num = count($args);
1890         }
1891
1892         // renvoyer le i-ieme argument, modulo le nombre d'arguments
1893         return $args[(intval($i) - 1) % ($num - 1) + 1];
1894 }
1895
1896
1897 /**
1898  * Récupérer un attribut d'une balise HTML
1899  *
1900  * la regexp est mortelle : cf. `tests/unit/filtres/extraire_attribut.php`
1901  * Si on a passé un tableau de balises, renvoyer un tableau de résultats
1902  * (dans ce cas l'option `$complet` n'est pas disponible)
1903  *
1904  * @param string|array $balise
1905  *     Texte ou liste de textes dont on veut extraire des balises
1906  * @param string $attribut
1907  *     Nom de l'attribut désiré
1908  * @param bool $complet
1909  *     True pour retourner un tableau avec
1910  *     - le texte de la balise
1911  *     - l'ensemble des résultats de la regexp ($r)
1912  * @return string|array
1913  *     - Texte de l'attribut retourné, ou tableau des texte d'attributs
1914  *       (si 1er argument tableau)
1915  *     - Tableau complet (si 2e argument)
1916  **/
1917 function extraire_attribut($balise, $attribut, $complet = false) {
1918         if (is_array($balise)) {
1919                 array_walk($balise,
1920                         create_function('&$a,$key,$t',
1921                                 '$a = extraire_attribut($a,$t);'
1922                         ),
1923                         $attribut);
1924
1925                 return $balise;
1926         }
1927         if (preg_match(
1928                 ',(^.*?<(?:(?>\s*)(?>[\w:.-]+)(?>(?:=(?:"[^"]*"|\'[^\']*\'|[^\'"]\S*))?))*?)(\s+'
1929                 . $attribut
1930                 . '(?:=\s*("[^"]*"|\'[^\']*\'|[^\'"]\S*))?)()((?:[\s/][^>]*)?>.*),isS',
1931
1932                 $balise, $r)) {
1933                 if (isset($r[3][0]) and ($r[3][0] == '"' || $r[3][0] == "'")) {
1934                         $r[4] = substr($r[3], 1, -1);
1935                         $r[3] = $r[3][0];
1936                 } elseif ($r[3] !== '') {
1937                         $r[4] = $r[3];
1938                         $r[3] = '';
1939                 } else {
1940                         $r[4] = trim($r[2]);
1941                 }
1942                 $att = $r[4];
1943                 if (strpos($att, "&#") !== false) {
1944                         $att = str_replace(array("&#039;", "&#39;", "&#034;", "&#34;"), array("'", "'", '"', '"'), $att);
1945                 }
1946                 $att = filtrer_entites($att);
1947         } else {
1948                 $att = null;
1949         }
1950
1951         if ($complet) {
1952                 return array($att, $r);
1953         } else {
1954                 return $att;
1955         }
1956 }
1957
1958 /**
1959  * Insérer (ou modifier) un attribut html dans une balise
1960  *
1961  * @example
1962  *     - `[(#LOGO_ARTICLE|inserer_attribut{class, logo article})]`
1963  *     - `[(#LOGO_ARTICLE|inserer_attribut{alt, #TTTRE|attribut_html|couper{60}})]`
1964  *     - `[(#FICHIER|image_reduire{40}|inserer_attribut{data-description, #DESCRIPTIF})]`
1965  *       Laissera les balises HTML de la valeur (ici `#DESCRIPTIF`) si on n'applique pas le
1966  *       filtre `attribut_html` dessus.
1967  *
1968  * @filtre
1969  * @link http://www.spip.net/4294
1970  * @uses attribut_html()
1971  * @uses extraire_attribut()
1972  *
1973  * @param string $balise
1974  *     Code html de la balise (ou contenant une balise)
1975  * @param string $attribut
1976  *     Nom de l'attribut html à modifier
1977  * @param string $val
1978  *     Valeur de l'attribut à appliquer
1979  * @param bool $proteger
1980  *     Prépare la valeur en tant qu'attribut de balise (mais conserve les balises html).
1981  * @param bool $vider
1982  *     True pour vider l'attribut. Une chaîne vide pour `$val` fera pareil.
1983  * @return string
1984  *     Code html modifié
1985  **/
1986 function inserer_attribut($balise, $attribut, $val, $proteger = true, $vider = false) {
1987         // preparer l'attribut
1988         // supprimer les &nbsp; etc mais pas les balises html
1989         // qui ont un sens dans un attribut value d'un input
1990         if ($proteger) {
1991                 $val = attribut_html($val, false);
1992         }
1993
1994         // echapper les ' pour eviter tout bug
1995         $val = str_replace("'", "&#039;", $val);
1996         if ($vider and strlen($val) == 0) {
1997                 $insert = '';
1998         } else {
1999                 $insert = " $attribut='$val'";
2000         }
2001
2002         list($old, $r) = extraire_attribut($balise, $attribut, true);
2003
2004         if ($old !== null) {
2005                 // Remplacer l'ancien attribut du meme nom
2006                 $balise = $r[1] . $insert . $r[5];
2007         } else {
2008                 // preferer une balise " />" (comme <img />)
2009                 if (preg_match(',/>,', $balise)) {
2010                         $balise = preg_replace(",\s?/>,S", $insert . " />", $balise, 1);
2011                 } // sinon une balise <a ...> ... </a>
2012                 else {
2013                         $balise = preg_replace(",\s?>,S", $insert . ">", $balise, 1);
2014                 }
2015         }
2016
2017         return $balise;
2018 }
2019
2020 /**
2021  * Supprime un attribut HTML
2022  *
2023  * @example `[(#LOGO_ARTICLE|vider_attribut{class})]`
2024  *
2025  * @filtre
2026  * @link http://www.spip.net/4142
2027  * @uses inserer_attribut()
2028  * @see  extraire_attribut()
2029  *
2030  * @param string $balise Code HTML de l'élément
2031  * @param string $attribut Nom de l'attribut à enlever
2032  * @return string Code HTML sans l'attribut
2033  **/
2034 function vider_attribut($balise, $attribut) {
2035         return inserer_attribut($balise, $attribut, '', false, true);
2036 }
2037
2038
2039 /**
2040  * Un filtre pour déterminer le nom du statut des inscrits
2041  *
2042  * @param void|int $id
2043  * @param string $mode
2044  * @return string
2045  */
2046 function tester_config($id, $mode = '') {
2047         include_spip('action/inscrire_auteur');
2048
2049         return tester_statut_inscription($mode, $id);
2050 }
2051
2052 //
2053 // Quelques fonctions de calcul arithmetique
2054 //
2055 function floatstr($a) { return str_replace(',','.',(string)floatval($a)); }
2056 function strize($f, $a, $b) { return floatstr($f(floatstr($a),floatstr($b))); }
2057
2058 /**
2059  * Additionne 2 nombres
2060  *
2061  * @filtre
2062  * @link http://www.spip.net/4307
2063  * @see moins()
2064  * @example
2065  *     ```
2066  *     [(#VAL{28}|plus{14})]
2067  *     ```
2068  *
2069  * @param int $a
2070  * @param int $b
2071  * @return int $a+$b
2072  **/
2073 function plus($a, $b) {
2074         return $a + $b;
2075 }
2076 function strplus($a, $b) {return strize('plus', $a, $b);}
2077 /**
2078  * Soustrait 2 nombres
2079  *
2080  * @filtre
2081  * @link http://www.spip.net/4302
2082  * @see plus()
2083  * @example
2084  *     ```
2085  *     [(#VAL{28}|moins{14})]
2086  *     ```
2087  *
2088  * @param int $a
2089  * @param int $b
2090  * @return int $a-$b
2091  **/
2092 function moins($a, $b) {
2093         return $a - $b;
2094 }
2095 function strmoins($a, $b) {return strize('moins', $a, $b);}
2096
2097 /**
2098  * Multiplie 2 nombres
2099  *
2100  * @filtre
2101  * @link http://www.spip.net/4304
2102  * @see div()
2103  * @see modulo()
2104  * @example
2105  *     ```
2106  *     [(#VAL{28}|mult{14})]
2107  *     ```
2108  *
2109  * @param int $a
2110  * @param int $b
2111  * @return int $a*$b
2112  **/
2113 function mult($a, $b) {
2114         return $a * $b;
2115 }
2116 function strmult($a, $b) {return strize('mult', $a, $b);}
2117
2118 /**
2119  * Divise 2 nombres
2120  *
2121  * @filtre
2122  * @link http://www.spip.net/4279
2123  * @see mult()
2124  * @see modulo()
2125  * @example
2126  *     ```
2127  *     [(#VAL{28}|div{14})]
2128  *     ```
2129  *
2130  * @param int $a
2131  * @param int $b
2132  * @return int $a/$b (ou 0 si $b est nul)
2133  **/
2134 function div($a, $b) {
2135         return $b ? $a / $b : 0;
2136 }
2137 function strdiv($a, $b) {return strize('div', $a, $b);}
2138
2139 /**
2140  * Retourne le modulo 2 nombres
2141  *
2142  * @filtre
2143  * @link http://www.spip.net/4301
2144  * @see mult()
2145  * @see div()
2146  * @example
2147  *     ```
2148  *     [(#VAL{28}|modulo{14})]
2149  *     ```
2150  *
2151  * @param int $nb
2152  * @param int $mod
2153  * @param int $add
2154  * @return int ($nb % $mod) + $add
2155  **/
2156 function modulo($nb, $mod, $add = 0) {
2157         return ($mod ? $nb % $mod : 0) + $add;
2158 }
2159
2160
2161 /**
2162  * Vérifie qu'un nom (d'auteur) ne comporte pas d'autres tags que <multi>
2163  * et ceux volontairement spécifiés dans la constante
2164  *
2165  * @param string $nom
2166  *      Nom (signature) proposé
2167  * @return bool
2168  *      - false si pas conforme,
2169  *      - true sinon
2170  **/
2171 function nom_acceptable($nom) {
2172         if (!is_string($nom)) {
2173                 return false;
2174         }
2175         if (!defined('_TAGS_NOM_AUTEUR')) {
2176                 define('_TAGS_NOM_AUTEUR', '');
2177         }
2178         $tags_acceptes = array_unique(explode(',', 'multi,' . _TAGS_NOM_AUTEUR));
2179         foreach ($tags_acceptes as $tag) {
2180                 if (strlen($tag)) {
2181                         $remp1[] = '<' . trim($tag) . '>';
2182                         $remp1[] = '</' . trim($tag) . '>';
2183                         $remp2[] = '\x60' . trim($tag) . '\x61';
2184                         $remp2[] = '\x60/' . trim($tag) . '\x61';
2185                 }
2186         }
2187         $v_nom = str_replace($remp2, $remp1, supprimer_tags(str_replace($remp1, $remp2, $nom)));
2188
2189         return str_replace('&lt;', '<', $v_nom) == $nom;
2190 }
2191
2192
2193 /**
2194  * Vérifier la conformité d'une ou plusieurs adresses email (suivant RFC 822)
2195  *
2196  * @param string $adresses
2197  *      Adresse ou liste d'adresse
2198  * @return bool|string
2199  *      - false si pas conforme,
2200  *      - la normalisation de la dernière adresse donnée sinon
2201  **/
2202 function email_valide($adresses) {
2203         // eviter d'injecter n'importe quoi dans preg_match
2204         if (!is_string($adresses)) {
2205                 return false;
2206         }
2207
2208         // Si c'est un spammeur autant arreter tout de suite
2209         if (preg_match(",[\n\r].*(MIME|multipart|Content-),i", $adresses)) {
2210                 spip_log("Tentative d'injection de mail : $adresses");
2211
2212                 return false;
2213         }
2214
2215         foreach (explode(',', $adresses) as $v) {
2216                 // nettoyer certains formats
2217                 // "Marie Toto <Marie@toto.com>"
2218                 $adresse = trim(preg_replace(",^[^<>\"]*<([^<>\"]+)>$,i", "\\1", $v));
2219                 // RFC 822
2220                 if (!preg_match('#^[^()<>@,;:\\"/[:space:]]+(@([-_0-9a-z]+\.)*[-_0-9a-z]+)$#i', $adresse)) {
2221                         return false;
2222                 }
2223         }
2224
2225         return $adresse;
2226 }
2227
2228 /**
2229  * Permet d'afficher un symbole à côté des liens pointant vers les
2230  * documents attachés d'un article (liens ayant `rel=enclosure`).
2231  *
2232  * @filtre
2233  * @link http://www.spip.net/4134
2234  *
2235  * @param string $tags Texte
2236  * @return string Texte
2237  **/
2238 function afficher_enclosures($tags) {
2239         $s = array();
2240         foreach (extraire_balises($tags, 'a') as $tag) {
2241                 if (extraire_attribut($tag, 'rel') == 'enclosure'
2242                         and $t = extraire_attribut($tag, 'href')
2243                 ) {
2244                         $s[] = preg_replace(',>[^<]+</a>,S',
2245                                 '>'
2246                                 . http_img_pack('attachment-16.png', $t,
2247                                         'title="' . attribut_html($t) . '"')
2248                                 . '</a>', $tag);
2249                 }
2250         }
2251
2252         return join('&nbsp;', $s);
2253 }
2254
2255 /**
2256  * Filtre des liens HTML `<a>` selon la valeur de leur attribut `rel`
2257  * et ne retourne que ceux là.
2258  *
2259  * @filtre
2260  * @link http://www.spip.net/4187
2261  *
2262  * @param string $tags Texte
2263  * @param string $rels Attribut `rel` à capturer (ou plusieurs séparés par des virgules)
2264  * @return string Liens trouvés
2265  **/
2266 function afficher_tags($tags, $rels = 'tag,directory') {
2267         $s = array();
2268         foreach (extraire_balises($tags, 'a') as $tag) {
2269                 $rel = extraire_attribut($tag, 'rel');
2270                 if (strstr(",$rels,", ",$rel,")) {
2271                         $s[] = $tag;
2272                 }
2273         }
2274
2275         return join(', ', $s);
2276 }
2277
2278
2279 /**
2280  * Convertir les médias fournis par un flux RSS (podcasts)
2281  * en liens conformes aux microformats
2282  *
2283  * Passe un `<enclosure url="fichier" length="5588242" type="audio/mpeg"/>`
2284  * au format microformat `<a rel="enclosure" href="fichier" ...>fichier</a>`.
2285  *
2286  * Peut recevoir un `<link` ou un `<media:content` parfois.
2287  *
2288  * Attention : `length="zz"` devient `title="zz"`, pour rester conforme.
2289  *
2290  * @filtre
2291  * @see microformat2enclosure() Pour l'inverse
2292  *
2293  * @param string $e Tag RSS `<enclosure>`
2294  * @return string Tag HTML `<a>` avec microformat.
2295  **/
2296 function enclosure2microformat($e) {
2297         if (!$url = filtrer_entites(extraire_attribut($e, 'url'))) {
2298                 $url = filtrer_entites(extraire_attribut($e, 'href'));
2299         }
2300         $type = extraire_attribut($e, 'type');
2301         if (!$length = extraire_attribut($e, 'length')) {
2302                 # <media:content : longeur dans fileSize. On tente.
2303                 $length = extraire_attribut($e, 'fileSize');
2304         }
2305         $fichier = basename($url);
2306
2307         return '<a rel="enclosure"'
2308         . ($url ? ' href="' . spip_htmlspecialchars($url) . '"' : '')
2309         . ($type ? ' type="' . spip_htmlspecialchars($type) . '"' : '')
2310         . ($length ? ' title="' . spip_htmlspecialchars($length) . '"' : '')
2311         . '>' . $fichier . '</a>';
2312 }
2313
2314 /**
2315  * Convertir les liens conformes aux microformats en médias pour flux RSS,
2316  * par exemple pour les podcasts
2317  *
2318  * Passe un texte ayant des liens avec microformat
2319  * `<a rel="enclosure" href="fichier" ...>fichier</a>`
2320  * au format RSS `<enclosure url="fichier" ... />`.
2321  *
2322  * @filtre
2323  * @see enclosure2microformat() Pour l'inverse
2324  *
2325  * @param string $tags Texte HTML ayant des tag `<a>` avec microformat
2326  * @return string Tags RSS `<enclosure>`.
2327  **/
2328 function microformat2enclosure($tags) {
2329         $enclosures = array();
2330         foreach (extraire_balises($tags, 'a') as $e) {
2331                 if (extraire_attribut($e, 'rel') == 'enclosure') {
2332                         $url = filtrer_entites(extraire_attribut($e, 'href'));
2333                         $type = extraire_attribut($e, 'type');
2334                         if (!$length = intval(extraire_attribut($e, 'title'))) {
2335                                 $length = intval(extraire_attribut($e, 'length'));
2336                         } # vieux data
2337                         $fichier = basename($url);
2338                         $enclosures[] = '<enclosure'
2339                                 . ($url ? ' url="' . spip_htmlspecialchars($url) . '"' : '')
2340                                 . ($type ? ' type="' . spip_htmlspecialchars($type) . '"' : '')
2341                                 . ($length ? ' length="' . $length . '"' : '')
2342                                 . ' />';
2343                 }
2344         }
2345
2346         return join("\n", $enclosures);
2347 }
2348
2349
2350 /**
2351  * Créer les éléments ATOM `<dc:subject>` à partir des tags
2352  *
2353  * Convertit les liens avec attribut `rel="tag"`
2354  * en balise `<dc:subject></dc:subject>` pour les flux RSS au format Atom.
2355  *
2356  * @filtre
2357  *
2358  * @param string $tags Texte
2359  * @return string Tags RSS Atom `<dc:subject>`.
2360  **/
2361 function tags2dcsubject($tags) {
2362         $subjects = '';
2363         foreach (extraire_balises($tags, 'a') as $e) {
2364                 if (extraire_attribut($e, rel) == 'tag') {
2365                         $subjects .= '<dc:subject>'
2366                                 . texte_backend(textebrut($e))
2367                                 . '</dc:subject>' . "\n";
2368                 }
2369         }
2370
2371         return $subjects;
2372 }
2373
2374 /**
2375  * Retourne la premiere balise html du type demandé
2376  *
2377  * Retourne le contenu d'une balise jusqu'à la première fermeture rencontrée
2378  * du même type.
2379  * Si on a passe un tableau de textes, retourne un tableau de resultats.
2380  *
2381  * @example `[(#DESCRIPTIF|extraire_balise{img})]`
2382  *
2383  * @filtre
2384  * @link http://www.spip.net/4289
2385  * @see extraire_balises()
2386  * @note
2387  *     Attention : les résultats peuvent être incohérents sur des balises imbricables,
2388  *     tel que demander à extraire `div` dans le texte `<div> un <div> mot </div> absent </div>`,
2389  *     ce qui retournerait `<div> un <div> mot </div>` donc.
2390  *
2391  * @param string|array $texte
2392  *     Texte(s) dont on souhaite extraire une balise html
2393  * @param string $tag
2394  *     Nom de la balise html à extraire
2395  * @return void|string|array
2396  *     - Code html de la balise, sinon rien
2397  *     - Tableau de résultats, si tableau en entrée.
2398  **/
2399 function extraire_balise($texte, $tag = 'a') {
2400         if (is_array($texte)) {
2401                 array_walk(
2402                         $texte,
2403                         create_function('&$a,$key,$t', '$a = extraire_balise($a,$t);'),
2404                         $tag
2405                 );
2406
2407                 return $texte;
2408         }
2409
2410         if (preg_match(
2411                 ",<$tag\b[^>]*(/>|>.*</$tag\b[^>]*>|>),UimsS",
2412                 $texte, $regs)) {
2413                 return $regs[0];
2414         }
2415 }
2416
2417 /**
2418  * Extrait toutes les balises html du type demandé
2419  *
2420  * Retourne dans un tableau le contenu de chaque balise jusqu'à la première
2421  * fermeture rencontrée du même type.
2422  * Si on a passe un tableau de textes, retourne un tableau de resultats.
2423  *
2424  * @example `[(#TEXTE|extraire_balises{img}|implode{" - "})]`
2425  *
2426  * @filtre
2427  * @link http://www.spip.net/5618
2428  * @see extraire_balise()
2429  * @note
2430  *     Attention : les résultats peuvent être incohérents sur des balises imbricables,
2431  *     tel que demander à extraire `div` dans un texte.
2432  *
2433  * @param string|array $texte
2434  *     Texte(s) dont on souhaite extraire une balise html
2435  * @param string $tag
2436  *     Nom de la balise html à extraire
2437  * @return array
2438  *     - Liste des codes html des occurrences de la balise, sinon tableau vide
2439  *     - Tableau de résultats, si tableau en entrée.
2440  **/
2441 function extraire_balises($texte, $tag = 'a') {
2442         if (is_array($texte)) {
2443                 array_walk(
2444                         $texte,
2445                         create_function('&$a,$key,$t', '$a = extraire_balises($a,$t);'),
2446                         $tag
2447                 );
2448
2449                 return $texte;
2450         }
2451
2452         if (preg_match_all(
2453                 ",<${tag}\b[^>]*(/>|>.*</${tag}\b[^>]*>|>),UimsS",
2454                 $texte, $regs, PREG_PATTERN_ORDER)) {
2455                 return $regs[0];
2456         } else {
2457                 return array();
2458         }
2459 }
2460
2461 /**
2462  * Indique si le premier argument est contenu dans le second
2463  *
2464  * Cette fonction est proche de `in_array()` en PHP avec comme principale
2465  * différence qu'elle ne crée pas d'erreur si le second argument n'est pas
2466  * un tableau (dans ce cas elle tentera de le désérialiser, et sinon retournera
2467  * la valeur par défaut transmise).
2468  *
2469  * @example `[(#VAL{deux}|in_any{#LISTE{un,deux,trois}}|oui) ... ]`
2470  *
2471  * @filtre
2472  * @see filtre_find() Assez proche, avec les arguments valeur et tableau inversés.
2473  *
2474  * @param string $val
2475  *     Valeur à chercher dans le tableau
2476  * @param array|string $vals
2477  *     Tableau des valeurs. S'il ce n'est pas un tableau qui est transmis,
2478  *     la fonction tente de la désérialiser.
2479  * @param string $def
2480  *     Valeur par défaut retournée si `$vals` n'est pas un tableau.
2481  * @return string
2482  *     - ' ' si la valeur cherchée est dans le tableau
2483  *     - '' si la valeur n'est pas dans le tableau
2484  *     - `$def` si on n'a pas transmis de tableau
2485  **/
2486 function in_any($val, $vals, $def = '') {
2487         if (!is_array($vals) and $v = unserialize($vals)) {
2488                 $vals = $v;
2489         }
2490
2491         return (!is_array($vals) ? $def : (in_array($val, $vals) ? ' ' : ''));
2492 }
2493
2494
2495 /**
2496  * Retourne le résultat d'une expression mathématique simple
2497  *
2498  * N'accepte que les *, + et - (à ameliorer si on l'utilise vraiment).
2499  *
2500  * @filtre
2501  * @example
2502  *      ```
2503  *      valeur_numerique("3*2") retourne 6
2504  *      ```
2505  *
2506  * @param string $expr
2507  *     Expression mathématique `nombre operateur nombre` comme `3*2`
2508  * @return int
2509  *     Résultat du calcul
2510  **/
2511 function valeur_numerique($expr) {
2512         $a = 0;
2513         if (preg_match(',^[0-9]+(\s*[+*-]\s*[0-9]+)*$,S', trim($expr))) {
2514                 eval("\$a = $expr;");
2515         }
2516
2517         return intval($a);
2518 }
2519
2520 /**
2521  * Retourne un calcul de règle de trois
2522  *
2523  * @filtre
2524  * @example
2525  *     ```
2526  *     [(#VAL{6}|regledetrois{4,3})] retourne 8
2527  *     ```
2528  *
2529  * @param int $a
2530  * @param int $b
2531  * @param int $c
2532  * @return int
2533  *      Retourne `$a*$b/$c`
2534  **/
2535 function regledetrois($a, $b, $c) {
2536         return round($a * $b / $c);
2537 }
2538
2539
2540 /**
2541  * Crée des tags HTML input hidden pour chaque paramètre et valeur d'une URL
2542  *
2543  * Fournit la suite de Input-Hidden correspondant aux paramètres de
2544  * l'URL donnée en argument, compatible avec les types_urls
2545  *
2546  * @filtre
2547  * @link http://www.spip.net/4286
2548  * @see balise_ACTION_FORMULAIRE()
2549  *     Également pour transmettre les actions à un formulaire
2550  * @example
2551  *     ```
2552  *     [(#ENV{action}|form_hidden)] dans un formulaire
2553  *     ```
2554  *
2555  * @param string $action URL
2556  * @return string Suite de champs input hidden
2557  **/
2558 function form_hidden($action) {
2559
2560         $contexte = array();
2561         include_spip('inc/urls');
2562         if ($p = urls_decoder_url($action, '')
2563                 and reset($p)
2564         ) {
2565                 $fond = array_shift($p);
2566                 if ($fond != '404') {
2567                         $contexte = array_shift($p);
2568                         $contexte['page'] = $fond;
2569                         $action = preg_replace('/([?]' . preg_quote($fond) . '[^&=]*[0-9]+)(&|$)/', '?&', $action);
2570                 }
2571         }
2572         // defaire ce qu'a injecte urls_decoder_url : a revoir en modifiant la signature de urls_decoder_url
2573         if (defined('_DEFINIR_CONTEXTE_TYPE') and _DEFINIR_CONTEXTE_TYPE) {
2574                 unset($contexte['type']);
2575         }
2576         if (defined('_DEFINIR_CONTEXTE_TYPE_PAGE') and _DEFINIR_CONTEXTE_TYPE_PAGE) {
2577                 unset($contexte['type-page']);
2578         }
2579
2580         // on va remplir un tableau de valeurs en prenant bien soin de ne pas
2581         // ecraser les elements de la forme mots[]=1&mots[]=2
2582         $values = array();
2583
2584         // d'abord avec celles de l'url
2585         if (false !== ($p = strpos($action, '?'))) {
2586                 foreach (preg_split('/&(amp;)?/S', substr($action, $p + 1)) as $c) {
2587                         $c = explode('=', $c, 2);
2588                         $var = array_shift($c);
2589                         $val = array_shift($c);
2590                         if ($var) {
2591                                 $val = rawurldecode($val);
2592                                 $var = rawurldecode($var); // decoder les [] eventuels
2593                                 if (preg_match(',\[\]$,S', $var)) {
2594                                         $values[] = array($var, $val);
2595                                 } else {
2596                                         if (!isset($values[$var])) {
2597                                                 $values[$var] = array($var, $val);
2598                                         }
2599                                 }
2600                         }
2601                 }
2602         }
2603
2604         // ensuite avec celles du contexte, sans doublonner !
2605         foreach ($contexte as $var => $val) {
2606                 if (preg_match(',\[\]$,S', $var)) {
2607                         $values[] = array($var, $val);
2608                 } else {
2609                         if (!isset($values[$var])) {
2610                                 $values[$var] = array($var, $val);
2611                         }
2612                 }
2613         }
2614
2615         // puis on rassemble le tout
2616         $hidden = array();
2617         foreach ($values as $value) {
2618                 list($var, $val) = $value;
2619                 $hidden[] = '<input name="'
2620                         . entites_html($var)
2621                         . '"'
2622                         . (is_null($val)
2623                                 ? ''
2624                                 : ' value="' . entites_html($val) . '"'
2625                         )
2626                         . ' type="hidden"' . "\n/>";
2627         }
2628
2629         return join("", $hidden);
2630 }
2631
2632 /**
2633  * Calcule les bornes d'une pagination
2634  *
2635  * @filtre
2636  *
2637  * @param int $courante
2638  *     Page courante
2639  * @param int $nombre
2640  *     Nombre de pages
2641  * @param int $max
2642  *     Nombre d'éléments par page
2643  * @return int[]
2644  *     Liste (première page, dernière page).
2645  **/
2646 function filtre_bornes_pagination_dist($courante, $nombre, $max = 10) {
2647         if ($max <= 0 or $max >= $nombre) {
2648                 return array(1, $nombre);
2649         }
2650
2651         $premiere = max(1, $courante - floor(($max - 1) / 2));
2652         $derniere = min($nombre, $premiere + $max - 2);
2653         $premiere = $derniere == $nombre ? $derniere - $max + 1 : $premiere;
2654
2655         return array($premiere, $derniere);
2656 }
2657
2658
2659 /**
2660  * Retourne la première valeur d'un tableau
2661  *
2662  * Plus précisément déplace le pointeur du tableau sur la première valeur et la retourne.
2663  *
2664  * @example `[(#LISTE{un,deux,trois}|reset)]` retourne 'un'
2665  *
2666  * @filtre
2667  * @link http://php.net/manual/fr/function.reset.php
2668  * @see filtre_end()
2669  *
2670  * @param array $array
2671  * @return mixed|null|false
2672  *    - null si $array n'est pas un tableau,
2673  *    - false si le tableau est vide
2674  *    - la première valeur du tableau sinon.
2675  **/
2676 function filtre_reset($array) {
2677         return !is_array($array) ? null : reset($array);
2678 }
2679
2680 /**
2681  * Retourne la dernière valeur d'un tableau
2682  *
2683  * Plus précisément déplace le pointeur du tableau sur la dernière valeur et la retourne.
2684  *
2685  * @example `[(#LISTE{un,deux,trois}|end)]` retourne 'trois'
2686  *
2687  * @filtre
2688  * @link http://php.net/manual/fr/function.end.php
2689  * @see filtre_reset()
2690  *
2691  * @param array $array
2692  * @return mixed|null|false
2693  *    - null si $array n'est pas un tableau,
2694  *    - false si le tableau est vide
2695  *    - la dernière valeur du tableau sinon.
2696  **/
2697 function filtre_end($array) {
2698         return !is_array($array) ? null : end($array);
2699 }
2700
2701 /**
2702  * Empile une valeur à la fin d'un tableau
2703  *
2704  * @example `[(#LISTE{un,deux,trois}|push{quatre}|print)]`
2705  *
2706  * @filtre
2707  * @link http://www.spip.net/4571
2708  * @link http://php.net/manual/fr/function.array-push.php
2709  *
2710  * @param array $array
2711  * @param mixed $val
2712  * @return array|string
2713  *     - '' si $array n'est pas un tableau ou si echec.
2714  *     - le tableau complété de la valeur sinon.
2715  *
2716  **/
2717 function filtre_push($array, $val) {
2718         if (!is_array($array) or !array_push($array, $val)) {
2719                 return '';
2720         }
2721
2722         return $array;
2723 }
2724
2725 /**
2726  * Indique si une valeur est contenue dans un tableau
2727  *
2728  * @example `[(#LISTE{un,deux,trois}|find{quatre}|oui) ... ]`
2729  *
2730  * @filtre
2731  * @link http://www.spip.net/4575
2732  * @see in_any() Assez proche, avec les paramètres tableau et valeur inversés.
2733  *
2734  * @param array $array
2735  * @param mixed $val
2736  * @return bool
2737  *     - `false` si `$array` n'est pas un tableau
2738  *     - `true` si la valeur existe dans le tableau, `false` sinon.
2739  **/
2740 function filtre_find($array, $val) {
2741         return (is_array($array) and in_array($val, $array));
2742 }
2743
2744
2745 /**
2746  * Filtre calculant une pagination, utilisé par la balise `#PAGINATION`
2747  *
2748  * Le filtre cherche le modèle `pagination.html` par défaut, mais peut
2749  * chercher un modèle de pagination particulier avec l'argument `$modele`.
2750  * S'il `$modele='prive'`, le filtre cherchera le modèle `pagination_prive.html`.
2751  *
2752  * @filtre
2753  * @see balise_PAGINATION_dist()
2754  *
2755  * @param int $total
2756  *     Nombre total d'éléments
2757  * @param string $nom
2758  *     Nom identifiant la pagination
2759  * @param int $position
2760  *     Page à afficher (tel que la 3è page)
2761  * @param int $pas
2762  *     Nombre d'éléments par page
2763  * @param bool $liste
2764  *     - True pour afficher toute la liste des éléments,
2765  *     - False pour n'afficher que l'ancre
2766  * @param string $modele
2767  *     Nom spécifique du modèle de pagination
2768  * @param string $connect
2769  *     Nom du connecteur à la base de données
2770  * @param array $env
2771  *     Environnement à transmettre au modèle
2772  * @return string
2773  *     Code HTML de la pagination
2774  **/
2775 function filtre_pagination_dist(
2776         $total,
2777         $nom,
2778         $position,
2779         $pas,
2780         $liste = true,
2781         $modele = '',
2782         $connect = '',
2783         $env = array()
2784 ) {
2785         static $ancres = array();
2786         if ($pas < 1) {
2787                 return '';
2788         }
2789         $ancre = 'pagination' . $nom; // #pagination_articles
2790         $debut = 'debut' . $nom; // 'debut_articles'
2791
2792         // n'afficher l'ancre qu'une fois
2793         if (!isset($ancres[$ancre])) {
2794                 $bloc_ancre = $ancres[$ancre] = "<a name='" . $ancre . "' id='" . $ancre . "'></a>";
2795         } else {
2796                 $bloc_ancre = '';
2797         }
2798         // liste = false : on ne veut que l'ancre
2799         if (!$liste) {
2800                 return $ancres[$ancre];
2801         }
2802
2803         $self = (empty($env['self']) ? self() : $env['self']);
2804         $pagination = array(
2805                 'debut' => $debut,
2806                 'url' => parametre_url($self, 'fragment', ''), // nettoyer l'id ahah eventuel
2807                 'total' => $total,
2808                 'position' => intval($position),
2809                 'pas' => $pas,
2810                 'nombre_pages' => floor(($total - 1) / $pas) + 1,
2811                 'page_courante' => floor(intval($position) / $pas) + 1,
2812                 'ancre' => $ancre,
2813                 'bloc_ancre' => $bloc_ancre
2814         );
2815         if (is_array($env)) {
2816                 $pagination = array_merge($env, $pagination);
2817         }
2818
2819         // Pas de pagination
2820         if ($pagination['nombre_pages'] <= 1) {
2821                 return '';
2822         }
2823
2824         if ($modele) {
2825                 $modele = '_' . $modele;
2826         }
2827
2828         return recuperer_fond("modeles/pagination$modele", $pagination, array('trim' => true), $connect);
2829 }
2830
2831
2832 /**
2833  * Passer les url relatives à la css d'origine en url absolues
2834  *
2835  * @uses suivre_lien()
2836  *
2837  * @param string $contenu
2838  *     Contenu du fichier CSS
2839  * @param string $source
2840  *     Chemin du fichier CSS
2841  * @return string
2842  *     Contenu avec urls en absolus
2843  **/
2844 function urls_absolues_css($contenu, $source) {
2845         $path = suivre_lien(url_absolue($source), './');
2846
2847         return preg_replace_callback(
2848                 ",url\s*\(\s*['\"]?([^'\"/#\s][^:]*)['\"]?\s*\),Uims",
2849                 create_function('$x',
2850                         'return "url(\'".suivre_lien(\'' . $path . '\',$x[1])."\')";'
2851                 ), $contenu);
2852 }
2853
2854
2855 /**
2856  * Inverse le code CSS (left <--> right) d'une feuille de style CSS
2857  *
2858  * Récupère le chemin d'une CSS existante et :
2859  *
2860  * 1. regarde si une CSS inversée droite-gauche existe dans le meme répertoire
2861  * 2. sinon la crée (ou la recrée) dans `_DIR_VAR/cache_css/`
2862  *
2863  * Si on lui donne à manger une feuille nommée `*_rtl.css` il va faire l'inverse.
2864  *
2865  * @filtre
2866  * @example
2867  *     ```
2868  *     [<link rel="stylesheet" href="(#CHEMIN{css/perso.css}|direction_css)" type="text/css" />]
2869  *     ```
2870  * @param string $css
2871  *     Chemin vers le fichier CSS
2872  * @param string $voulue
2873  *     Permet de forcer le sens voulu (en indiquant `ltr`, `rtl` ou un
2874  *     code de langue). En absence, prend le sens de la langue en cours.
2875  *
2876  * @return string
2877  *     Chemin du fichier CSS inversé
2878  **/
2879 function direction_css($css, $voulue = '') {
2880         if (!preg_match(',(_rtl)?\.css$,i', $css, $r)) {
2881                 return $css;
2882         }
2883
2884         // si on a precise le sens voulu en argument, le prendre en compte
2885         if ($voulue = strtolower($voulue)) {
2886                 if ($voulue != 'rtl' and $voulue != 'ltr') {
2887                         $voulue = lang_dir($voulue);
2888                 }
2889         } else {
2890                 $voulue = lang_dir();
2891         }
2892
2893         $r = count($r) > 1;
2894         $right = $r ? 'left' : 'right'; // 'right' de la css lue en entree
2895         $dir = $r ? 'rtl' : 'ltr';
2896         $ndir = $r ? 'ltr' : 'rtl';
2897
2898         if ($voulue == $dir) {
2899                 return $css;
2900         }
2901
2902         if (
2903                 // url absolue
2904                 preg_match(",^http:,i", $css)
2905                 // ou qui contient un ?
2906                 or (($p = strpos($css, '?')) !== false)
2907         ) {
2908                 $distant = true;
2909                 $cssf = parse_url($css);
2910                 $cssf = $cssf['path'] . ($cssf['query'] ? "?" . $cssf['query'] : "");
2911                 $cssf = preg_replace(',[?:&=],', "_", $cssf);
2912         } else {
2913                 $distant = false;
2914                 $cssf = $css;
2915                 // 1. regarder d'abord si un fichier avec la bonne direction n'est pas aussi
2916                 //propose (rien a faire dans ce cas)
2917                 $f = preg_replace(',(_rtl)?\.css$,i', '_' . $ndir . '.css', $css);
2918                 if (@file_exists($f)) {
2919                         return $f;
2920                 }
2921         }
2922
2923         // 2.
2924         $dir_var = sous_repertoire(_DIR_VAR, 'cache-css');
2925         $f = $dir_var
2926                 . preg_replace(',.*/(.*?)(_rtl)?\.css,', '\1', $cssf)
2927                 . '.' . substr(md5($cssf), 0, 4) . '_' . $ndir . '.css';
2928
2929         // la css peut etre distante (url absolue !)
2930         if ($distant) {
2931                 include_spip('inc/distant');
2932                 $contenu = recuperer_page($css);
2933                 if (!$contenu) {
2934                         return $css;
2935                 }
2936         } else {
2937                 if ((@filemtime($f) > @filemtime($css))
2938                         and (_VAR_MODE != 'recalcul')
2939                 ) {
2940                         return $f;
2941                 }
2942                 if (!lire_fichier($css, $contenu)) {
2943                         return $css;
2944                 }
2945         }
2946
2947         $contenu = str_replace(
2948                 array('right', 'left', '@@@@L E F T@@@@'),
2949                 array('@@@@L E F T@@@@', 'right', 'left'),
2950                 $contenu);
2951
2952         // reperer les @import auxquels il faut propager le direction_css
2953         preg_match_all(",\@import\s*url\s*\(\s*['\"]?([^'\"/][^:]*)['\"]?\s*\),Uims", $contenu, $regs);
2954         $src = array();
2955         $src_direction_css = array();
2956         $src_faux_abs = array();
2957         $d = dirname($css);
2958         foreach ($regs[1] as $k => $import_css) {
2959                 $css_direction = direction_css("$d/$import_css", $voulue);
2960                 // si la css_direction est dans le meme path que la css d'origine, on tronque le path, elle sera passee en absolue
2961                 if (substr($css_direction, 0, strlen($d) + 1) == "$d/") {
2962                         $css_direction = substr($css_direction, strlen($d) + 1);
2963                 } // si la css_direction commence par $dir_var on la fait passer pour une absolue
2964                 elseif (substr($css_direction, 0, strlen($dir_var)) == $dir_var) {
2965                         $css_direction = substr($css_direction, strlen($dir_var));
2966                         $src_faux_abs["/@@@@@@/" . $css_direction] = $css_direction;
2967                         $css_direction = "/@@@@@@/" . $css_direction;
2968                 }
2969                 $src[] = $regs[0][$k];
2970                 $src_direction_css[] = str_replace($import_css, $css_direction, $regs[0][$k]);
2971         }
2972         $contenu = str_replace($src, $src_direction_css, $contenu);
2973
2974         $contenu = urls_absolues_css($contenu, $css);
2975
2976         // virer les fausses url absolues que l'on a mis dans les import
2977         if (count($src_faux_abs)) {
2978                 $contenu = str_replace(array_keys($src_faux_abs), $src_faux_abs, $contenu);
2979         }
2980
2981         if (!ecrire_fichier($f, $contenu)) {
2982                 return $css;
2983         }
2984
2985         return $f;
2986 }
2987
2988
2989 /**
2990  * Transforme les urls relatives d'un fichier CSS en absolues
2991  *
2992  * Récupère le chemin d'une css existante et crée (ou recrée) dans `_DIR_VAR/cache_css/`
2993  * une css dont les url relatives sont passées en url absolues
2994  *
2995  * Le calcul n'est pas refait si le fichier cache existe déjà et que
2996  * la source n'a pas été modifiée depuis.
2997  *
2998  * @uses recuperer_page() si l'URL source n'est pas sur le même site
2999  * @uses urls_absolues_css()
3000  *
3001  * @param string $css
3002  *     Chemin ou URL du fichier CSS source
3003  * @return string
3004  *     - Chemin du fichier CSS transformé (si source lisible et mise en cache réussie)
3005  *     - Chemin ou URL du fichier CSS source sinon.
3006  **/
3007 function url_absolue_css($css) {
3008         if (!preg_match(',\.css$,i', $css, $r)) {
3009                 return $css;
3010         }
3011
3012         $url_absolue_css = url_absolue($css);
3013
3014         $f = basename($css, '.css');
3015         $f = sous_repertoire(_DIR_VAR, 'cache-css')
3016                 . preg_replace(",(.*?)(_rtl|_ltr)?$,", "\\1-urlabs-" . substr(md5("$css-urlabs"), 0, 4) . "\\2", $f)
3017                 . '.css';
3018
3019         if ((@filemtime($f) > @filemtime($css)) and (_VAR_MODE != 'recalcul')) {
3020                 return $f;
3021         }
3022
3023         if ($url_absolue_css == $css) {
3024                 if (strncmp($GLOBALS['meta']['adresse_site'], $css, $l = strlen($GLOBALS['meta']['adresse_site'])) != 0
3025                         or !lire_fichier(_DIR_RACINE . substr($css, $l), $contenu)
3026                 ) {
3027                         include_spip('inc/distant');
3028                         if (!$contenu = recuperer_page($css)) {
3029                                 return $css;
3030                         }
3031                 }
3032         } elseif (!lire_fichier($css, $contenu)) {
3033                 return $css;
3034         }
3035
3036         // passer les url relatives a la css d'origine en url absolues
3037         $contenu = urls_absolues_css($contenu, $css);
3038
3039         // ecrire la css
3040         if (!ecrire_fichier($f, $contenu)) {
3041                 return $css;
3042         }
3043
3044         return $f;
3045 }
3046
3047
3048 /**
3049  * Récupère la valeur d'une clé donnée
3050  * dans un tableau (ou un objet).
3051  *
3052  * @filtre
3053  * @link http://www.spip.net/4572
3054  * @example
3055  *     ```
3056  *     [(#VALEUR|table_valeur{cle/sous/element})]
3057  *     ```
3058  *
3059  * @param mixed $table
3060  *     Tableau ou objet PHP
3061  *     (ou chaîne serialisée de tableau, ce qui permet d'enchaîner le filtre)
3062  * @param string $cle
3063  *     Clé du tableau (ou paramètre public de l'objet)
3064  *     Cette clé peut contenir des caractères / pour sélectionner
3065  *     des sous éléments dans le tableau, tel que `sous/element/ici`
3066  *     pour obtenir la valeur de `$tableau['sous']['element']['ici']`
3067  * @param mixed $defaut
3068  *     Valeur par defaut retournée si la clé demandée n'existe pas
3069  * @param bool  $conserver_null
3070  *     Permet de forcer la fonction à renvoyer la valeur null d'un index
3071  *     et non pas $defaut comme cela est fait naturellement par la fonction
3072  *     isset. On utilise alors array_key_exists() à la place de isset().
3073  *
3074  * @return mixed
3075  *     Valeur trouvée ou valeur par défaut.
3076  **/
3077 function table_valeur($table, $cle, $defaut = '', $conserver_null = false) {
3078         foreach (explode('/', $cle) as $k) {
3079
3080                 $table = is_string($table) ? @unserialize($table) : $table;
3081
3082                 if (is_object($table)) {
3083                         $table = (($k !== "") and isset($table->$k)) ? $table->$k : $defaut;
3084                 } elseif (is_array($table)) {
3085                         if ($conserver_null) {
3086                                 $table = array_key_exists($k, $table) ? $table[$k] : $defaut;
3087                         } else {
3088                                 $table = isset($table[$k]) ? $table[$k] : $defaut;
3089                         }
3090                 } else {
3091                         $table = $defaut;
3092                 }
3093         }
3094
3095         return $table;
3096 }
3097
3098 /**
3099  * Retrouve un motif dans un texte à partir d'une expression régulière
3100  *
3101  * S'appuie sur la fonction `preg_match()` en PHP
3102  *
3103  * @example
3104  *    - `[(#TITRE|match{toto})]`
3105  *    - `[(#TEXTE|match{^ceci$,Uims})]`
3106  *    - `[(#TEXTE|match{truc(...)$, UimsS, 1})]` Capture de la parenthèse indiquée
3107  *    - `[(#TEXTE|match{truc(...)$, 1})]` Équivalent, sans indiquer les modificateurs
3108  *
3109  * @filtre
3110  * @link http://www.spip.net/4299
3111  * @link http://php.net/manual/fr/function.preg-match.php Pour des infos sur `preg_match()`
3112  *
3113  * @param string $texte
3114  *     Texte dans lequel chercher
3115  * @param string|int $expression
3116  *     Expression régulière de recherche, sans le délimiteur
3117  * @param string $modif
3118  *     - string : Modificateurs de l'expression régulière
3119  *     - int : Numéro de parenthèse capturante
3120  * @param int $capte
3121  *     Numéro de parenthèse capturante
3122  * @return bool|string
3123  *     - false : l'expression n'a pas été trouvée
3124  *     - true : expression trouvée, mais pas la parenthèse capturante
3125  *     - string : expression trouvée.
3126  **/
3127 function match($texte, $expression, $modif = "UimsS", $capte = 0) {
3128         if (intval($modif) and $capte == 0) {
3129                 $capte = $modif;
3130                 $modif = "UimsS";
3131         }
3132         $expression = str_replace("\/", "/", $expression);
3133         $expression = str_replace("/", "\/", $expression);
3134
3135         if (preg_match('/' . $expression . '/' . $modif, $texte, $r)) {
3136                 if (isset($r[$capte])) {
3137                         return $r[$capte];
3138                 } else {
3139                         return true;
3140                 }
3141         }
3142
3143         return false;
3144 }
3145
3146
3147 /**
3148  * Remplacement de texte à base d'expression régulière
3149  *
3150  * @filtre
3151  * @link http://www.spip.net/4309
3152  * @see match()
3153  * @example
3154  *     ```
3155  *     [(#TEXTE|replace{^ceci$,cela,UimsS})]
3156  *     ```
3157  *
3158  * @param string $texte
3159  *     Texte
3160  * @param string $expression
3161  *     Expression régulière
3162  * @param string $replace
3163  *     Texte de substitution des éléments trouvés
3164  * @param string $modif
3165  *     Modificateurs pour l'expression régulière.
3166  * @return string
3167  *     Texte
3168  **/
3169 function replace($texte, $expression, $replace = '', $modif = "UimsS") {
3170         $expression = str_replace("\/", "/", $expression);
3171         $expression = str_replace("/", "\/", $expression);
3172
3173         return preg_replace('/' . $expression . '/' . $modif, $replace, $texte);
3174 }
3175
3176
3177 /**
3178  * Cherche les documents numerotés dans un texte traite par `propre()`
3179  *
3180  * Affecte la liste des doublons['documents']
3181  *
3182  * @param array $doublons
3183  *     Liste des doublons
3184  * @param string $letexte
3185  *     Le texte
3186  * @return string
3187  *     Le texte
3188  **/
3189 function traiter_doublons_documents(&$doublons, $letexte) {
3190
3191         // Verifier dans le texte & les notes (pas beau, helas)
3192         $t = $letexte . $GLOBALS['les_notes'];
3193
3194         if (strstr($t, 'spip_document_') // evite le preg_match_all si inutile
3195                 and preg_match_all(
3196                         ',<[^>]+\sclass=["\']spip_document_([0-9]+)[\s"\'],imsS',
3197                         $t, $matches, PREG_PATTERN_ORDER)
3198         ) {
3199                 if (!isset($doublons['documents'])) {
3200                         $doublons['documents'] = "";
3201                 }
3202                 $doublons['documents'] .= "," . join(',', $matches[1]);
3203         }
3204
3205         return $letexte;
3206 }
3207
3208 /**
3209  * Filtre vide qui ne renvoie rien
3210  *
3211  * @example
3212  *     `[(#CALCUL|vide)]` n'affichera pas le résultat du calcul
3213  * @filtre
3214  *
3215  * @param mixed $texte
3216  * @return string Chaîne vide
3217  **/
3218 function vide($texte) {
3219         return "";
3220 }
3221
3222 //
3223 // Filtres pour le modele/emb (embed document)
3224 //
3225
3226 /**
3227  * Écrit des balises HTML `<param...>` à partir d'un tableau de données tel que `#ENV`
3228  *
3229  * Permet d'écrire les balises `<param>` à indiquer dans un `<object>`
3230  * en prenant toutes les valeurs du tableau transmis.
3231  *
3232  * Certaines clés spécifiques à SPIP et aux modèles embed sont omises :
3233  * id, lang, id_document, date, date_redac, align, fond, recurs, emb, dir_racine
3234  *
3235  * @example `[(#ENV*|env_to_params)]`
3236  *
3237  * @filtre
3238  * @link http://www.spip.net/4005
3239  *
3240  * @param array|string $env
3241  *      Tableau cle => valeur des paramètres à écrire, ou chaine sérialisée de ce tableau
3242  * @param array $ignore_params
3243  *      Permet de compléter les clés ignorées du tableau.
3244  * @return string
3245  *      Code HTML résultant
3246  **/
3247 function env_to_params($env, $ignore_params = array()) {
3248         $ignore_params = array_merge(
3249                 array('id', 'lang', 'id_document', 'date', 'date_redac', 'align', 'fond', '', 'recurs', 'emb', 'dir_racine'),
3250                 $ignore_params
3251         );
3252         if (!is_array($env)) {
3253                 $env = unserialize($env);
3254         }
3255         $texte = "";
3256         if ($env) {
3257                 foreach ($env as $i => $j) {
3258                         if (is_string($j) and !in_array($i, $ignore_params)) {
3259                                 $texte .= "<param name='" . attribut_html($i) . "'\n\tvalue='" . attribut_html($j) . "' />";
3260                         }
3261                 }
3262         }
3263
3264         return $texte;
3265 }
3266
3267 /**
3268  * Écrit des attributs HTML à partir d'un tableau de données tel que `#ENV`
3269  *
3270  * Permet d'écrire des attributs d'une balise HTML en utilisant les données du tableau transmis.
3271  * Chaque clé deviendra le nom de l'attribut (et la valeur, sa valeur)
3272  *
3273  * Certaines clés spécifiques à SPIP et aux modèles embed sont omises :
3274  * id, lang, id_document, date, date_redac, align, fond, recurs, emb, dir_racine
3275  *
3276  * @example `<embed src='#URL_DOCUMENT' [(#ENV*|env_to_attributs)] width='#GET{largeur}' height='#GET{hauteur}'></embed>`
3277  * @filtre
3278  *
3279  * @param array|string $env
3280  *      Tableau cle => valeur des attributs à écrire, ou chaine sérialisée de ce tableau
3281  * @param array $ignore_params
3282  *      Permet de compléter les clés ignorées du tableau.
3283  * @return string
3284  *      Code HTML résultant
3285  **/
3286 function env_to_attributs($env, $ignore_params = array()) {
3287         $ignore_params = array_merge(
3288                 array('id', 'lang', 'id_document', 'date', 'date_redac', 'align', 'fond', '', 'recurs', 'emb', 'dir_racine'),
3289                 $ignore_params
3290         );
3291         if (!is_array($env)) {
3292                 $env = unserialize($env);
3293         }
3294         $texte = "";
3295         if ($env) {
3296                 foreach ($env as $i => $j) {
3297                         if (is_string($j) and !in_array($i, $ignore_params)) {
3298                                 $texte .= attribut_html($i) . "='" . attribut_html($j) . "' ";
3299                         }
3300                 }
3301         }
3302
3303         return $texte;
3304 }
3305
3306
3307 /**
3308  * Concatène des chaînes
3309  *
3310  * @filtre
3311  * @link http://www.spip.net/4150
3312  * @example
3313  *     ```
3314  *     #TEXTE|concat{texte1,texte2,...}
3315  *     ```
3316  *
3317  * @return string Chaînes concaténés
3318  **/
3319 function concat() {
3320         $args = func_get_args();
3321
3322         return join('', $args);
3323 }
3324
3325
3326 /**
3327  * Retourne le contenu d'un ou plusieurs fichiers
3328  *
3329  * Les chemins sont cherchés dans le path de SPIP
3330  *
3331  * @see balise_INCLURE_dist() La balise `#INCLURE` peut appeler cette fonction
3332  *
3333  * @param array|string $files
3334  *     - array : Liste de fichiers
3335  *     - string : fichier ou fichiers séparés par `|`
3336  * @param bool $script
3337  *     - si true, considère que c'est un fichier js à chercher `javascript/`
3338  * @return string
3339  *     Contenu du ou des fichiers, concaténé
3340  **/
3341 function charge_scripts($files, $script = true) {
3342         $flux = "";
3343         foreach (is_array($files) ? $files : explode("|", $files) as $file) {
3344                 if (!is_string($file)) {
3345                         continue;
3346                 }
3347                 if ($script) {
3348                         $file = preg_match(",^\w+$,", $file) ? "javascript/$file.js" : '';
3349                 }
3350                 if ($file) {
3351                         $path = find_in_path($file);
3352                         if ($path) {
3353                                 $flux .= spip_file_get_contents($path);
3354                         }
3355                 }
3356         }
3357
3358         return $flux;
3359 }
3360
3361
3362 /**
3363  * Produit une balise img avec un champ alt d'office si vide
3364  *
3365  * Attention le htmlentities et la traduction doivent être appliqués avant.
3366  *
3367  * @param string $img
3368  * @param string $alt
3369  * @param string $atts
3370  * @param string $title
3371  * @param array $options
3372  *   chemin_image : utiliser chemin_image sur $img fourni, ou non (oui par dafaut)
3373  *   utiliser_suffixe_size : utiliser ou non le suffixe de taille dans le nom de fichier de l'image
3374  *   sous forme -xx.png (pour les icones essentiellement) (oui par defaut)
3375  * @return string
3376  */
3377 function http_img_pack($img, $alt, $atts = '', $title = '', $options = array()) {
3378         if (!isset($options['chemin_image']) or $options['chemin_image'] == true) {
3379                 $img = chemin_image($img);
3380         }
3381         if (stripos($atts, 'width') === false && !preg_match(',\.svg$,', $img)) {
3382                 // utiliser directement l'info de taille presente dans le nom
3383                 if ((!isset($options['utiliser_suffixe_size']) or $options['utiliser_suffixe_size'] == true)
3384                         and preg_match(',-([0-9]+)[.](png|gif)$,', $img, $regs)
3385                 ) {
3386                         $largeur = $hauteur = intval($regs[1]);
3387                 } else {
3388                         $taille = taille_image($img);
3389                         list($hauteur, $largeur) = $taille;
3390                         if (!$hauteur or !$largeur) {
3391                                 return "";
3392                         }
3393                 }
3394                 $atts .= " width='" . $largeur . "' height='" . $hauteur . "'";
3395         }
3396
3397         return "<img src='$img' alt='" . attribut_html($alt ? $alt : $title) . "'"
3398         . ($title ? ' title="' . attribut_html($title) . '"' : '')
3399         . " " . ltrim($atts)
3400         . " />";
3401 }
3402
3403 /**
3404  * Générer une directive `style='background:url()'` à partir d'un fichier image
3405  *
3406  * @param string $img
3407  * @param string $att
3408  * @return string
3409  */
3410 function http_style_background($img, $att = '') {
3411         return " style='background" . ($att ? "" : "-image") . ": url(\"" . chemin_image($img) . "\")" . ($att ? (' ' . $att) : '') . ";'";
3412 }
3413
3414 /**
3415  * Générer une balise HTML `img` à partir d'un nom de fichier
3416  *
3417  * @uses http_img_pack()
3418  *
3419  * @param string $img
3420  * @param string $alt
3421  * @param string $class
3422  * @return string
3423  *     Code HTML de la balise IMG
3424  */
3425 function filtre_balise_img_dist($img, $alt = "", $class = "") {
3426         return http_img_pack($img, $alt, $class ? " class='" . attribut_html($class) . "'" : '', '',
3427                 array('chemin_image' => false, 'utiliser_suffixe_size' => false));
3428 }
3429
3430
3431 /**
3432  * Inserer un svg inline
3433  * http://www.accede-web.com/notices/html-css-javascript/6-images-icones/6-2-svg-images-vectorielles/
3434  *
3435  * pour l'inserer avec une balise <img>, utiliser le filtre |balise_img
3436  *
3437  * @param string $img
3438  * @param string $alt
3439  * @param string $class
3440  * @return string
3441  */
3442 function filtre_balise_svg_dist($img, $alt = "", $class = "") {
3443         if (!$file = find_in_path($img)
3444           or !$svg = file_get_contents($file)) {
3445                 return '';
3446         }
3447
3448         if (!preg_match(",<svg\b[^>]*>,UimsS", $svg, $match)) {
3449                 return '';
3450         }
3451         $balise_svg = $match[0];
3452         $balise_svg_source = $balise_svg;
3453
3454         // entete XML à supprimer
3455         $svg = preg_replace(',^\s*<\?xml[^>]*\?' . '>,', '', $svg);
3456
3457         // IE est toujours mon ami
3458         $balise_svg = inserer_attribut($balise_svg, 'focusable', 'false');
3459         if ($class) {
3460                 $balise_svg = inserer_attribut($balise_svg, 'class', $class);
3461         }
3462         if ($alt){
3463                 $balise_svg = inserer_attribut($balise_svg, 'role', 'img');
3464                 $id = "img-svg-title-" . substr(md5("$file:$svg:$alt"),0,4);
3465                 $balise_svg = inserer_attribut($balise_svg, 'aria-labelledby', $id);
3466                 $title = "<title id=\"$id\">" . entites_html($alt)."</title>\n";
3467                 $balise_svg .= $title;
3468         }
3469         else {
3470                 $balise_svg = inserer_attribut($balise_svg, 'aria-hidden', 'true');
3471         }
3472         $svg = str_replace($balise_svg_source, $balise_svg, $svg);
3473
3474         return $svg;
3475 }
3476
3477
3478
3479 /**
3480  * Affiche chaque valeur d'un tableau associatif en utilisant un modèle
3481  *
3482  * @example
3483  *     - `[(#ENV*|unserialize|foreach)]`
3484  *     - `[(#ARRAY{a,un,b,deux}|foreach)]`
3485  *
3486  * @filtre
3487  * @link http://www.spip.net/4248
3488  *
3489  * @param array $tableau
3490  *     Tableau de données à afficher
3491  * @param string $modele
3492  *     Nom du modèle à utiliser
3493  * @return string
3494  *     Code HTML résultant
3495  **/
3496 function filtre_foreach_dist($tableau, $modele = 'foreach') {
3497         $texte = '';
3498         if (is_array($tableau)) {
3499                 foreach ($tableau as $k => $v) {
3500                         $res = recuperer_fond('modeles/' . $modele,
3501                                 array_merge(array('cle' => $k), (is_array($v) ? $v : array('valeur' => $v)))
3502                         );
3503                         $texte .= $res;
3504                 }
3505         }
3506
3507         return $texte;
3508 }
3509
3510
3511 /**
3512  * Obtient des informations sur les plugins actifs
3513  *
3514  * @filtre
3515  * @uses liste_plugin_actifs() pour connaître les informations affichables
3516  *
3517  * @param string $plugin
3518  *     Préfixe du plugin ou chaîne vide
3519  * @param string $type_info
3520  *     Type d'info demandée
3521  * @param bool $reload
3522  *     true (à éviter) pour forcer le recalcul du cache des informations des plugins.
3523  * @return array|string|bool
3524  *
3525  *     - Liste sérialisée des préfixes de plugins actifs (si $plugin = '')
3526  *     - Suivant $type_info, avec $plugin un préfixe
3527  *         - est_actif : renvoie true s'il est actif, false sinon
3528  *         - x : retourne l'information x du plugin si présente (et plugin actif)
3529  *         - tout : retourne toutes les informations du plugin actif
3530  **/
3531 function filtre_info_plugin_dist($plugin, $type_info, $reload = false) {
3532         include_spip('inc/plugin');
3533         $plugin = strtoupper($plugin);
3534         $plugins_actifs = liste_plugin_actifs();
3535
3536         if (!$plugin) {
3537                 return serialize(array_keys($plugins_actifs));
3538         } elseif (empty($plugins_actifs[$plugin]) and !$reload) {
3539                 return '';
3540         } elseif (($type_info == 'est_actif') and !$reload) {
3541                 return $plugins_actifs[$plugin] ? 1 : 0;
3542         } elseif (isset($plugins_actifs[$plugin][$type_info]) and !$reload) {
3543                 return $plugins_actifs[$plugin][$type_info];
3544         } else {
3545                 $get_infos = charger_fonction('get_infos', 'plugins');
3546                 // On prend en compte les extensions
3547                 if (!is_dir($plugins_actifs[$plugin]['dir_type'])) {
3548                         $dir_plugins = constant($plugins_actifs[$plugin]['dir_type']);
3549                 } else {
3550                         $dir_plugins = $plugins_actifs[$plugin]['dir_type'];
3551                 }
3552                 if (!$infos = $get_infos($plugins_actifs[$plugin]['dir'], $reload, $dir_plugins)) {
3553                         return '';
3554                 }
3555                 if ($type_info == 'tout') {
3556                         return $infos;
3557                 } elseif ($type_info == 'est_actif') {
3558                         return $infos ? 1 : 0;
3559                 } else {
3560                         return strval($infos[$type_info]);
3561                 }
3562         }
3563 }
3564
3565
3566 /**
3567  * Affiche la puce statut d'un objet, avec un menu rapide pour changer
3568  * de statut si possibilité de l'avoir
3569  *
3570  * @see inc_puce_statut_dist()
3571  *
3572  * @filtre
3573  *
3574  * @param int $id_objet
3575  *     Identifiant de l'objet
3576  * @param string $statut
3577  *     Statut actuel de l'objet
3578  * @param int $id_rubrique
3579  *     Identifiant du parent
3580  * @param string $type
3581  *     Type d'objet
3582  * @param bool $ajax
3583  *     Indique s'il ne faut renvoyer que le coeur du menu car on est
3584  *     dans une requete ajax suite à un post de changement rapide
3585  * @return string
3586  *     Code HTML de l'image de puce de statut à insérer (et du menu de changement si présent)
3587  */
3588 function puce_changement_statut($id_objet, $statut, $id_rubrique, $type, $ajax = false) {
3589         $puce_statut = charger_fonction('puce_statut', 'inc');
3590
3591         return $puce_statut($id_objet, $statut, $id_rubrique, $type, $ajax);
3592 }
3593
3594
3595 /**
3596  * Affiche la puce statut d'un objet, avec un menu rapide pour changer
3597  * de statut si possibilité de l'avoir
3598  *
3599  * Utilisable sur tout objet qui a declaré ses statuts
3600  *
3601  * @example
3602  *     [(#STATUT|puce_statut{article})] affiche une puce passive
3603  *     [(#STATUT|puce_statut{article,#ID_ARTICLE,#ID_RUBRIQUE})] affiche une puce avec changement rapide
3604  *
3605  * @see inc_puce_statut_dist()
3606  *
3607  * @filtre
3608  *
3609  * @param string $statut
3610  *     Statut actuel de l'objet
3611  * @param string $objet
3612  *     Type d'objet
3613  * @param int $id_objet
3614  *     Identifiant de l'objet
3615  * @param int $id_parent
3616  *     Identifiant du parent
3617  * @return string
3618  *     Code HTML de l'image de puce de statut à insérer (et du menu de changement si présent)
3619  */
3620 function filtre_puce_statut_dist($statut, $objet, $id_objet = 0, $id_parent = 0) {
3621         static $puce_statut = null;
3622         if (!$puce_statut) {
3623                 $puce_statut = charger_fonction('puce_statut', 'inc');
3624         }
3625
3626         return $puce_statut($id_objet, $statut, $id_parent, $objet, false,
3627                 objet_info($objet, 'editable') ? _ACTIVER_PUCE_RAPIDE : false);
3628 }
3629
3630
3631 /**
3632  * Encoder un contexte pour l'ajax
3633  *
3634  * Encoder le contexte, le signer avec une clé, le crypter
3635  * avec le secret du site, le gziper si possible.
3636  *
3637  * L'entrée peut-être sérialisée (le `#ENV**` des fonds ajax et ajax_stat)
3638  *
3639  * @see  decoder_contexte_ajax()
3640  * @uses calculer_cle_action()
3641  *
3642  * @param string|array $c
3643  *   contexte, peut etre un tableau serialize
3644  * @param string $form
3645  *   nom du formulaire eventuel
3646  * @param string $emboite
3647  *   contenu a emboiter dans le conteneur ajax
3648  * @param string $ajaxid
3649  *   ajaxid pour cibler le bloc et forcer sa mise a jour
3650  * @return string
3651  *   hash du contexte
3652  */
3653 function encoder_contexte_ajax($c, $form = '', $emboite = null, $ajaxid = '') {
3654         if (is_string($c)
3655                 and @unserialize($c) !== false
3656         ) {
3657                 $c = unserialize($c);
3658         }
3659
3660         // supprimer les parametres debut_x
3661         // pour que la pagination ajax ne soit pas plantee
3662         // si on charge la page &debut_x=1 : car alors en cliquant sur l'item 0,
3663         // le debut_x=0 n'existe pas, et on resterait sur 1
3664         if (is_array($c)) {
3665                 foreach ($c as $k => $v) {
3666                         if (strpos($k, 'debut_') === 0) {
3667                                 unset($c[$k]);
3668                         }
3669                 }
3670         }
3671
3672         if (!function_exists('calculer_cle_action')) {
3673                 include_spip("inc/securiser_action");
3674         }
3675
3676         $c = serialize($c);
3677         $cle = calculer_cle_action($form . $c);
3678         $c = "$cle:$c";
3679
3680         // on ne stocke pas les contextes dans des fichiers en cache
3681         // par defaut, sauf si cette configuration a été forcée
3682         // OU que la longueur de l’argument géneré est plus long
3683         // que ce qui est toléré.
3684         $cache_contextes_ajax = (defined('_CACHE_CONTEXTES_AJAX') and _CACHE_CONTEXTES_AJAX);
3685         if (!$cache_contextes_ajax) {
3686                 $env = $c;
3687                 if (function_exists('gzdeflate') && function_exists('gzinflate')) {
3688                         $env = gzdeflate($env);
3689                         // http://core.spip.net/issues/2667 | https://bugs.php.net/bug.php?id=61287
3690                         if ((PHP_VERSION_ID == 50400) and !@gzinflate($env)) {
3691                                 $cache_contextes_ajax = true;
3692                                 spip_log("Contextes AJAX forces en fichiers ! Erreur PHP 5.4.0", _LOG_AVERTISSEMENT);
3693                         }
3694                 }
3695                 $env = _xor($env);
3696                 $env = base64_encode($env);
3697                 $len = strlen($env);
3698                 // Si l’url est trop longue pour le navigateur
3699                 $max_len = _CACHE_CONTEXTES_AJAX_SUR_LONGUEUR;
3700                 if ($len > $max_len) {
3701                         $cache_contextes_ajax = true;
3702                         spip_log("Contextes AJAX forces en fichiers !"
3703                                 . " Cela arrive lorsque la valeur du contexte"
3704                                 . " depasse la longueur maximale autorisee ($max_len). Ici : $len."
3705                                 , _LOG_AVERTISSEMENT);
3706                 }
3707                 // Sinon si Suhosin est actif et a une la valeur maximale des variables en GET...
3708                 elseif (
3709                         $max_len = @ini_get('suhosin.get.max_value_length')
3710                         and $max_len < $len
3711                 ) {
3712                         $cache_contextes_ajax = true;
3713                         spip_log("Contextes AJAX forces en fichiers !"
3714                                 . " Cela arrive lorsque la valeur du contexte"
3715                                 . " depasse la longueur maximale autorisee par Suhosin"
3716                                 . " ($max_len) dans 'suhosin.get.max_value_length'. Ici : $len."
3717                                 . " Vous devriez modifier les parametres de Suhosin"
3718                                 . " pour accepter au moins 1024 caracteres.", _LOG_AVERTISSEMENT);
3719                 }
3720
3721         }
3722
3723         if ($cache_contextes_ajax) {
3724                 $dir = sous_repertoire(_DIR_CACHE, 'contextes');
3725                 // stocker les contextes sur disque et ne passer qu'un hash dans l'url
3726                 $md5 = md5($c);
3727                 ecrire_fichier("$dir/c$md5", $c);
3728                 $env = $md5;
3729         }
3730
3731         if ($emboite === null) {
3732                 return $env;
3733         }
3734         if (!trim($emboite)) {
3735                 return "";
3736         }
3737         // toujours encoder l'url source dans le bloc ajax
3738         $r = self();
3739         $r = ' data-origin="' . $r . '"';
3740         $class = 'ajaxbloc';
3741         if ($ajaxid and is_string($ajaxid)) {
3742                 // ajaxid est normalement conforme a un nom de classe css
3743                 // on ne verifie pas la conformite, mais on passe entites_html par dessus par precaution
3744                 $class .= ' ajax-id-' . entites_html($ajaxid);
3745         }
3746
3747         return "<div class='$class' " . "data-ajax-env='$env'$r>\n$emboite</div><!--ajaxbloc-->\n";
3748 }
3749
3750 /**
3751  * Décoder un hash de contexte pour l'ajax
3752  *
3753  * Précude inverse de `encoder_contexte_ajax()`
3754  *
3755  * @see  encoder_contexte_ajax()
3756  * @uses calculer_cle_action()
3757  *
3758  * @param string $c
3759  *   hash du contexte
3760  * @param string $form
3761  *   nom du formulaire eventuel
3762  * @return array|string|bool
3763  *   - array|string : contexte d'environnement, possiblement sérialisé
3764  *   - false : erreur de décodage
3765  */
3766 function decoder_contexte_ajax($c, $form = '') {
3767         if (!function_exists('calculer_cle_action')) {
3768                 include_spip("inc/securiser_action");
3769         }
3770         if (((defined('_CACHE_CONTEXTES_AJAX') and _CACHE_CONTEXTES_AJAX) or strlen($c) == 32)
3771                 and $dir = sous_repertoire(_DIR_CACHE, 'contextes')
3772                 and lire_fichier("$dir/c$c", $contexte)
3773         ) {
3774                 $c = $contexte;
3775         } else {
3776                 $c = @base64_decode($c);
3777                 $c = _xor($c);
3778                 if (function_exists('gzdeflate') && function_exists('gzinflate')) {
3779                         $c = @gzinflate($c);
3780                 }
3781         }
3782
3783         // extraire la signature en debut de contexte
3784         // et la verifier avant de deserializer
3785         // format : signature:donneesserializees
3786         if ($p = strpos($c,":")){
3787                 $cle = substr($c,0,$p);
3788                 $c = substr($c,$p+1);
3789
3790                 if ($cle == calculer_cle_action($form . $c)) {
3791                         $env = @unserialize($c);
3792                         return $env;
3793                 }
3794         }
3795
3796         return false;
3797 }
3798
3799
3800 /**
3801  * Encrypte ou décrypte un message
3802  *
3803  * @link http://www.php.net/manual/fr/language.operators.bitwise.php#81358
3804  *
3805  * @param string $message
3806  *    Message à encrypter ou décrypter
3807  * @param null|string $key
3808  *    Clé de cryptage / décryptage.
3809  *    Une clé sera calculée si non transmise
3810  * @return string
3811  *    Message décrypté ou encrypté
3812  **/
3813 function _xor($message, $key = null) {
3814         if (is_null($key)) {
3815                 if (!function_exists('calculer_cle_action')) {
3816                         include_spip("inc/securiser_action");
3817                 }
3818                 $key = pack("H*", calculer_cle_action('_xor'));
3819         }
3820
3821         $keylen = strlen($key);
3822         $messagelen = strlen($message);
3823         for ($i = 0; $i < $messagelen; $i++) {
3824                 $message[$i] = ~($message[$i] ^ $key[$i % $keylen]);
3825         }
3826
3827         return $message;
3828 }
3829
3830 /**
3831  * Retourne une URL de réponse de forum (aucune action ici)
3832  *
3833  * @see filtre_url_reponse_forum() du plugin forum (prioritaire)
3834  * @note
3835  *   La vraie fonction est dans le plugin forum,
3836  *   mais on évite ici une erreur du compilateur en absence du plugin
3837  * @param string $texte
3838  * @return string
3839  */
3840 function url_reponse_forum($texte) { return $texte; }
3841
3842 /**
3843  * retourne une URL de suivi rss d'un forum (aucune action ici)
3844  *
3845  * @see filtre_url_rss_forum() du plugin forum (prioritaire)
3846  * @note
3847  *   La vraie fonction est dans le plugin forum,
3848  *   mais on évite ici une erreur du compilateur en absence du plugin
3849  * @param string $texte
3850  * @return string
3851  */
3852 function url_rss_forum($texte) { return $texte; }
3853
3854
3855 /**
3856  * Génère des menus avec liens ou `<strong class='on'>` non clicable lorsque
3857  * l'item est sélectionné
3858  *
3859  * @filtre
3860  * @link http://www.spip.net/4004
3861  * @example
3862  *   ```
3863  *   [(#URL_RUBRIQUE|lien_ou_expose{#TITRE, #ENV{test}|=={en_cours}})]
3864  *   ```
3865  *
3866  * @param string $url
3867  *   URL du lien
3868  * @param string $libelle
3869  *   Texte du lien
3870  * @param bool $on
3871  *   État exposé (génère un strong) ou non (génère un lien)
3872  * @param string $class
3873  *   Classes CSS ajoutées au lien
3874  * @param string $title
3875  *   Title ajouté au lien
3876  * @param string $rel
3877  *   Attribut `rel` ajouté au lien
3878  * @param string $evt
3879  *   Complement à la balise `a` pour gérer un événement javascript,
3880  *   de la forme ` onclick='...'`
3881  * @return string
3882  *   Code HTML
3883  */
3884 function lien_ou_expose($url, $libelle = null, $on = false, $class = "", $title = "", $rel = "", $evt = '') {
3885         if ($on) {
3886                 $bal = "strong";
3887                 $att = "class='on'";
3888         } else {
3889                 $bal = 'a';
3890                 $att = "href='$url'"
3891                         . ($title ? " title='" . attribut_html($title) . "'" : '')
3892                         . ($class ? " class='" . attribut_html($class) . "'" : '')
3893                         . ($rel ? " rel='" . attribut_html($rel) . "'" : '')
3894                         . $evt;
3895         }
3896         if ($libelle === null) {
3897                 $libelle = $url;
3898         }
3899
3900         return "<$bal $att>$libelle</$bal>";
3901 }
3902
3903
3904 /**
3905  * Afficher un message "un truc"/"N trucs"
3906  * Les items sont à indiquer comme pour la fonction _T() sous la forme :
3907  * "module:chaine"
3908  *
3909  * @param int $nb : le nombre
3910  * @param string $chaine_un : l'item de langue si $nb vaut un
3911  * @param string $chaine_plusieurs : l'item de lanque si $nb >= 2
3912  * @param string $var : La variable à remplacer par $nb dans l'item de langue (facultatif, défaut "nb")
3913  * @param array $vars : Les autres variables nécessaires aux chaines de langues (facultatif)
3914  * @return string : la chaine de langue finale en utilisant la fonction _T()
3915  */
3916 function singulier_ou_pluriel($nb, $chaine_un, $chaine_plusieurs, $var = 'nb', $vars = array()) {
3917         if (!is_numeric($nb) or $nb == 0) {
3918                 return "";
3919         }
3920         if (!is_array($vars)) {
3921                 return "";
3922         }
3923         $vars[$var] = $nb;
3924         if ($nb >= 2) {
3925                 return _T($chaine_plusieurs, $vars);
3926         } else {
3927                 return _T($chaine_un, $vars);
3928         }
3929 }
3930
3931
3932 /**
3933  * Fonction de base pour une icone dans un squelette
3934  * structure html : `<span><a><img><b>texte</b></span>`
3935  *
3936  * @param string $type
3937  *  'lien' ou 'bouton'
3938  * @param string $lien
3939  *  url
3940  * @param string $texte
3941  *  texte du lien / alt de l'image
3942  * @param string $fond
3943  *  objet avec ou sans son extension et sa taille (article, article-24, article-24.png)
3944  * @param string $fonction
3945  *  new/del/edit
3946  * @param string $class
3947  *  classe supplementaire (horizontale, verticale, ajax ...)
3948  * @param string $javascript
3949  *  "onclick='...'" par exemple
3950  * @return string
3951  */
3952 function prepare_icone_base($type, $lien, $texte, $fond, $fonction = "", $class = "", $javascript = "") {
3953         if (in_array($fonction, array("del", "supprimer.gif"))) {
3954                 $class .= ' danger';
3955         } elseif ($fonction == "rien.gif") {
3956                 $fonction = "";
3957         } elseif ($fonction == "delsafe") {
3958                 $fonction = "del";
3959         }
3960
3961         // remappage des icone : article-24.png+new => article-new-24.png
3962         if ($icone_renommer = charger_fonction('icone_renommer', 'inc', true)) {
3963                 list($fond, $fonction) = $icone_renommer($fond, $fonction);
3964         }
3965
3966         // ajouter le type d'objet dans la class de l'icone
3967         $class .= " " . substr(basename($fond), 0, -4);
3968
3969         $alt = attribut_html($texte);
3970         $title = " title=\"$alt\""; // est-ce pertinent de doubler le alt par un title ?
3971
3972         $ajax = "";
3973         if (strpos($class, "ajax") !== false) {
3974                 $ajax = "ajax";
3975                 if (strpos($class, "preload") !== false) {
3976                         $ajax .= " preload";
3977                 }
3978                 if (strpos($class, "nocache") !== false) {
3979                         $ajax .= " nocache";
3980                 }
3981                 $ajax = " class='$ajax'";
3982         }
3983
3984         $size = 24;
3985         if (preg_match("/-([0-9]{1,3})[.](gif|png)$/i", $fond, $match)) {
3986                 $size = $match[1];
3987         }
3988
3989         if ($fonction) {
3990                 // 2 images pour composer l'icone : le fond (article) en background,
3991                 // la fonction (new) en image
3992                 $icone = http_img_pack($fonction, $alt, "width='$size' height='$size'\n" .
3993                         http_style_background($fond));
3994         } else {
3995                 $icone = http_img_pack($fond, $alt, "width='$size' height='$size'");
3996         }
3997
3998         if ($type == 'lien') {
3999                 return "<span class='icone s$size $class'>"
4000                 . "<a href='$lien'$title$ajax$javascript>"
4001                 . $icone
4002                 . "<b>$texte</b>"
4003                 . "</a></span>\n";
4004         } else {
4005                 return bouton_action("$icone<b>$texte</b>", $lien, "icone s$size $class", $javascript, $alt);
4006         }
4007 }
4008
4009 /**
4010  * Crée un lien ayant une icone
4011  *
4012  * @uses prepare_icone_base()
4013  *
4014  * @param string $lien
4015  *     URL du lien
4016  * @param string $texte
4017  *     Texte du lien
4018  * @param string $fond
4019  *     Objet avec ou sans son extension et sa taille (article, article-24, article-24.png)
4020  * @param string $fonction
4021  *     Fonction du lien (`edit`, `new`, `del`)
4022  * @param string $class
4023  *     Classe CSS, tel que `left`, `right` pour définir un alignement
4024  * @param string $javascript
4025  *     Javascript ajouté sur le lien
4026  * @return string
4027  *     Code HTML du lien
4028  **/
4029 function icone_base($lien, $texte, $fond, $fonction = "", $class = "", $javascript = "") {
4030         return prepare_icone_base('lien', $lien, $texte, $fond, $fonction, $class, $javascript);
4031 }
4032
4033 /**
4034  * Crée un lien précédé d'une icone au dessus du texte
4035  *
4036  * @uses icone_base()
4037  * @see  icone_verticale() Pour un usage dans un code PHP.
4038  *
4039  * @filtre
4040  * @example
4041  *     ```
4042  *     [(#AUTORISER{voir,groupemots,#ID_GROUPE})
4043  *         [(#URL_ECRIRE{groupe_mots,id_groupe=#ID_GROUPE}
4044  *            |icone_verticale{<:mots:icone_voir_groupe_mots:>,groupe_mots-24.png,'',left})]
4045  *    ]
4046  *     ```
4047  *
4048  * @param string $lien
4049  *     URL du lien
4050  * @param string $texte
4051  *     Texte du lien
4052  * @param string $fond
4053  *     Objet avec ou sans son extension et sa taille (article, article-24, article-24.png)
4054  * @param string $fonction
4055  *     Fonction du lien (`edit`, `new`, `del`)
4056  * @param string $class
4057  *     Classe CSS à ajouter, tel que `left`, `right`, `center` pour définir un alignement.
4058  *     Il peut y en avoir plusieurs : `left ajax`
4059  * @param string $javascript
4060  *     Javascript ajouté sur le lien
4061  * @return string
4062  *     Code HTML du lien
4063  **/
4064 function filtre_icone_verticale_dist($lien, $texte, $fond, $fonction = "", $class = "", $javascript = "") {
4065         return icone_base($lien, $texte, $fond, $fonction, "verticale $class", $javascript);
4066 }
4067
4068 /**
4069  * Crée un lien précédé d'une icone horizontale
4070  *
4071  * @uses icone_base()
4072  * @see  icone_horizontale() Pour un usage dans un code PHP.
4073  *
4074  * @filtre
4075  * @example
4076  *     En tant que filtre dans un squelettes :
4077  *     ```
4078  *     [(#URL_ECRIRE{sites}|icone_horizontale{<:sites:icone_voir_sites_references:>,site-24.png})]
4079  *
4080  *     [(#AUTORISER{supprimer,groupemots,#ID_GROUPE}|oui)
4081  *         [(#URL_ACTION_AUTEUR{supprimer_groupe_mots,#ID_GROUPE,#URL_ECRIRE{mots}}
4082  *             |icone_horizontale{<:mots:icone_supprimer_groupe_mots:>,groupe_mots,del})]
4083  *     ]
4084  *     ```
4085  *
4086  *     En tant que filtre dans un code php :
4087  *     ```
4088  *     $icone_horizontale=chercher_filtre('icone_horizontale');
4089  *     $icone = $icone_horizontale(generer_url_ecrire("stats_visites","id_article=$id_article"),
4090  *         _T('statistiques:icone_evolution_visites', array('visites' => $visites)),
4091  *         "statistique-24.png");
4092  *     ```
4093  *
4094  * @param string $lien
4095  *     URL du lien
4096  * @param string $texte
4097  *     Texte du lien
4098  * @param string $fond
4099  *     Objet avec ou sans son extension et sa taille (article, article-24, article-24.png)
4100  * @param string $fonction
4101  *     Fonction du lien (`edit`, `new`, `del`)
4102  * @param string $class
4103  *     Classe CSS à ajouter
4104  * @param string $javascript
4105  *     Javascript ajouté sur le lien
4106  * @return string
4107  *     Code HTML du lien
4108  **/
4109 function filtre_icone_horizontale_dist($lien, $texte, $fond, $fonction = "", $class = "", $javascript = "") {
4110         return icone_base($lien, $texte, $fond, $fonction, "horizontale $class", $javascript);
4111 }
4112
4113 /**
4114  * Crée un bouton d'action intégrant une icone horizontale
4115  *
4116  * @uses prepare_icone_base()
4117  *
4118  * @filtre
4119  * @example
4120  *     ```
4121  *     [(#URL_ACTION_AUTEUR{supprimer_mot, #ID_MOT, #URL_ECRIRE{groupe_mots,id_groupe=#ID_GROUPE}}
4122  *         |bouton_action_horizontal{<:mots:info_supprimer_mot:>,mot-24.png,del})]
4123  *     ```
4124  *
4125  * @param string $lien
4126  *     URL de l'action
4127  * @param string $texte
4128  *     Texte du bouton
4129  * @param string $fond
4130  *     Objet avec ou sans son extension et sa taille (article, article-24, article-24.png)
4131  * @param string $fonction
4132  *     Fonction du bouton (`edit`, `new`, `del`)
4133  * @param string $class
4134  *     Classe CSS à ajouter
4135  * @param string $confirm
4136  *     Message de confirmation à ajouter en javascript sur le bouton
4137  * @return string
4138  *     Code HTML du lien
4139  **/
4140 function filtre_bouton_action_horizontal_dist($lien, $texte, $fond, $fonction = "", $class = "", $confirm = "") {
4141         return prepare_icone_base('bouton', $lien, $texte, $fond, $fonction, "horizontale $class", $confirm);
4142 }
4143
4144 /**
4145  * Filtre `icone` pour compatibilité mappé sur `icone_base`
4146  *
4147  * @uses icone_base()
4148  * @see  filtre_icone_verticale_dist()
4149  *
4150  * @filtre
4151  * @deprecated Utiliser le filtre `icone_verticale`
4152  *
4153  * @param string $lien
4154  *     URL du lien
4155  * @param string $texte
4156  *     Texte du lien
4157  * @param string $fond
4158  *     Nom de l'image utilisée
4159  * @param string $align
4160  *     Classe CSS d'alignement (`left`, `right`, `center`)
4161  * @param string $fonction
4162  *     Fonction du lien (`edit`, `new`, `del`)
4163  * @param string $class
4164  *     Classe CSS à ajouter
4165  * @param string $javascript
4166  *     Javascript ajouté sur le lien
4167  * @return string
4168  *     Code HTML du lien
4169  */
4170 function filtre_icone_dist($lien, $texte, $fond, $align = "", $fonction = "", $class = "", $javascript = "") {
4171         return icone_base($lien, $texte, $fond, $fonction, "verticale $align $class", $javascript);
4172 }
4173
4174
4175 /**
4176  * Explose un texte en tableau suivant un séparateur
4177  *
4178  * @note
4179  *     Inverse l'écriture de la fonction PHP de même nom
4180  *     pour que le filtre soit plus pratique dans les squelettes
4181  *
4182  * @filtre
4183  * @example
4184  *     ```
4185  *     [(#GET{truc}|explode{-})]
4186  *     ```
4187  *
4188  * @param string $a Texte
4189  * @param string $b Séparateur
4190  * @return array Liste des éléments
4191  */
4192 function filtre_explode_dist($a, $b) { return explode($b, $a); }
4193
4194 /**
4195  * Implose un tableau en chaine en liant avec un séparateur
4196  *
4197  * @note
4198  *     Inverse l'écriture de la fonction PHP de même nom
4199  *     pour que le filtre soit plus pratique dans les squelettes
4200  *
4201  * @filtre
4202  * @example
4203  *     ```
4204  *     [(#GET{truc}|implode{-})]
4205  *     ```
4206  *
4207  * @param array $a Tableau
4208  * @param string $b Séparateur
4209  * @return string Texte
4210  */
4211 function filtre_implode_dist($a, $b) { return is_array($a) ? implode($b, $a) : $a; }
4212
4213 /**
4214  * Produire les styles privés qui associent item de menu avec icone en background
4215  *
4216  * @return string Code CSS
4217  */
4218 function bando_images_background() {
4219         include_spip('inc/bandeau');
4220         // recuperer tous les boutons et leurs images
4221         $boutons = definir_barre_boutons(definir_barre_contexte(), true, false);
4222
4223         $res = "";
4224         foreach ($boutons as $page => $detail) {
4225                 if ($detail->icone and strlen(trim($detail->icone))) {
4226                         $res .= "\n.navigation_avec_icones #bando1_$page {background-image:url(" . $detail->icone . ");}";
4227                 }
4228                 $selecteur = (in_array($page, array('outils_rapides', 'outils_collaboratifs')) ? "" : ".navigation_avec_icones ");
4229                 if (is_array($detail->sousmenu)) {
4230                         foreach ($detail->sousmenu as $souspage => $sousdetail) {
4231                                 if ($sousdetail->icone and strlen(trim($sousdetail->icone))) {
4232                                         $res .= "\n$selecteur.bando2_$souspage {background-image:url(" . $sousdetail->icone . ");}";
4233                                 }
4234                         }
4235                 }
4236         }
4237
4238         return $res;
4239 }
4240
4241 /**
4242  * Generer un bouton_action
4243  * utilise par #BOUTON_ACTION
4244  *
4245  * @param string $libelle
4246  * @param string $url
4247  * @param string $class
4248  * @param string $confirm
4249  *   message de confirmation oui/non avant l'action
4250  * @param string $title
4251  * @param string $callback
4252  *   callback js a appeler lors de l'evenement action (apres confirmation eventuelle si $confirm est non vide)
4253  *   et avant execution de l'action. Si la callback renvoie false, elle annule le declenchement de l'action
4254  * @return string
4255  */
4256 function bouton_action($libelle, $url, $class = "", $confirm = "", $title = "", $callback = "") {
4257         if ($confirm) {
4258                 $confirm = "confirm(\"" . attribut_html($confirm) . "\")";
4259                 if ($callback) {
4260                         $callback = "$confirm?($callback):false";
4261                 } else {
4262                         $callback = $confirm;
4263                 }
4264         }
4265         $onclick = $callback ? " onclick='return " . addcslashes($callback, "'") . "'" : "";
4266         $title = $title ? " title='$title'" : "";
4267
4268         return "<form class='bouton_action_post $class' method='post' action='$url'><div>" . form_hidden($url)
4269         . "<button type='submit' class='submit'$title$onclick>$libelle</button></div></form>";
4270 }
4271
4272
4273 /**
4274  * Proteger les champs passes dans l'url et utiliser dans {tri ...}
4275  * preserver l'espace pour interpreter ensuite num xxx et multi xxx
4276  *
4277  * @param string $t
4278  * @return string
4279  */
4280 function tri_protege_champ($t) {
4281         return preg_replace(',[^\s\w.+],', '', $t);
4282 }
4283
4284 /**
4285  * Interpreter les multi xxx et num xxx utilise comme tri
4286  * pour la clause order
4287  * 'multi xxx' devient simplement 'multi' qui est calcule dans le select
4288  *
4289  * @param string $t
4290  * @param array $from
4291  * @return string
4292  */
4293 function tri_champ_order($t, $from = null) {
4294         if (strncmp($t, 'multi ', 6) == 0) {
4295                 return "multi";
4296         }
4297
4298         $champ = $t;
4299
4300         if (strncmp($t, 'num ', 4) == 0) {
4301                 $champ = substr($t, 4);
4302         }
4303         // enlever les autres espaces non evacues par tri_protege_champ
4304         $champ = preg_replace(',\s,', '', $champ);
4305
4306         if (is_array($from)) {
4307                 $trouver_table = charger_fonction('trouver_table', 'base');
4308                 foreach ($from as $idt => $table_sql) {
4309                         if ($desc = $trouver_table($table_sql)
4310                                 and isset($desc['field'][$champ])
4311                         ) {
4312                                 $champ = "$idt.$champ";
4313                                 break;
4314                         }
4315                 }
4316         }
4317         if (strncmp($t, 'num ', 4) == 0) {
4318                 return "0+$champ";
4319         } else {
4320                 return $champ;
4321         }
4322 }
4323
4324 /**
4325  * Interpreter les multi xxx et num xxx utilise comme tri
4326  * pour la clause select
4327  * 'multi xxx' devient select "...." as multi
4328  * les autres cas ne produisent qu'une chaine vide '' en select
4329  * 'hasard' devient 'rand() AS hasard' dans le select
4330  *
4331  * @param string $t
4332  * @return string
4333  */
4334 function tri_champ_select($t) {
4335         if (strncmp($t, 'multi ', 6) == 0) {
4336                 $t = substr($t, 6);
4337                 $t = preg_replace(',\s,', '', $t);
4338                 $t = sql_multi($t, $GLOBALS['spip_lang']);
4339
4340                 return $t;
4341         }
4342         if (trim($t) == 'hasard') {
4343                 return 'rand() AS hasard';
4344         }
4345
4346         return "''";
4347 }
4348
4349
4350 /**
4351  * Donner n'importe quelle information sur un objet de maniere generique.
4352  *
4353  * La fonction va gerer en interne deux cas particuliers les plus utilises :
4354  * l'URL et le titre (qui n'est pas forcemment le champ SQL "titre").
4355  *
4356  * On peut ensuite personnaliser les autres infos en creant une fonction
4357  * generer_<nom_info>_entite($id_objet, $type_objet, $ligne).
4358  * $ligne correspond a la ligne SQL de tous les champs de l'objet, les fonctions
4359  * de personnalisation n'ont donc pas a refaire de requete.
4360  *
4361  * @param int $id_objet
4362  * @param string $type_objet
4363  * @param string $info
4364  * @param string $etoile
4365  * @return string
4366  */
4367 function generer_info_entite($id_objet, $type_objet, $info, $etoile = "") {
4368         static $trouver_table = null;
4369         static $objets;
4370
4371         // On verifie qu'on a tout ce qu'il faut
4372         $id_objet = intval($id_objet);
4373         if (!($id_objet and $type_objet and $info)) {
4374                 return '';
4375         }
4376
4377         // si on a deja note que l'objet n'existe pas, ne pas aller plus loin
4378         if (isset($objets[$type_objet]) and $objets[$type_objet] === false) {
4379                 return '';
4380         }
4381
4382         // Si on demande l'url, on retourne direct la fonction
4383         if ($info == 'url') {
4384                 return generer_url_entite($id_objet, $type_objet);
4385         }
4386
4387         // Sinon on va tout chercher dans la table et on garde en memoire
4388         $demande_titre = ($info == 'titre');
4389
4390         // On ne fait la requete que si on a pas deja l'objet ou si on demande le titre mais qu'on ne l'a pas encore
4391         if (!isset($objets[$type_objet][$id_objet])
4392                 or
4393                 ($demande_titre and !isset($objets[$type_objet][$id_objet]['titre']))
4394         ) {
4395                 if (!$trouver_table) {
4396                         $trouver_table = charger_fonction('trouver_table', 'base');
4397                 }
4398                 $desc = $trouver_table(table_objet_sql($type_objet));
4399                 if (!$desc) {
4400                         return $objets[$type_objet] = false;
4401                 }
4402
4403                 // Si on demande le titre, on le gere en interne
4404                 $champ_titre = "";
4405                 if ($demande_titre) {
4406                         // si pas de titre declare mais champ titre, il sera peuple par le select *
4407                         $champ_titre = (!empty($desc['titre'])) ? ', ' . $desc['titre'] : '';
4408                 }
4409                 include_spip('base/abstract_sql');
4410                 include_spip('base/connect_sql');
4411                 $objets[$type_objet][$id_objet] = sql_fetsel(
4412                         '*' . $champ_titre,
4413                         $desc['table_sql'],
4414                         id_table_objet($type_objet) . ' = ' . intval($id_objet)
4415                 );
4416         }
4417
4418         // Si la fonction generer_TRUC_TYPE existe, on l'utilise pour formater $info_generee
4419         if ($generer = charger_fonction("generer_${info}_${type_objet}", '', true)) {
4420                 $info_generee = $generer($id_objet, $objets[$type_objet][$id_objet]);
4421         } // Si la fonction generer_TRUC_entite existe, on l'utilise pour formater $info_generee
4422         else {
4423                 if ($generer = charger_fonction("generer_${info}_entite", '', true)) {
4424                         $info_generee = $generer($id_objet, $type_objet, $objets[$type_objet][$id_objet]);
4425                 } // Sinon on prend directement le champ SQL tel quel
4426                 else {
4427                         $info_generee = (isset($objets[$type_objet][$id_objet][$info]) ? $objets[$type_objet][$id_objet][$info] : '');
4428                 }
4429         }
4430
4431         // On va ensuite appliquer les traitements automatiques si besoin
4432         if (!$etoile) {
4433                 // FIXME: on fournit un ENV minimum avec id et type et connect=''
4434                 // mais ce fonctionnement est a ameliorer !
4435                 $info_generee = appliquer_traitement_champ($info_generee, $info, table_objet($type_objet),
4436                         array('id_objet' => $id_objet, 'objet' => $type_objet, ''));
4437         }
4438
4439         return $info_generee;
4440 }
4441
4442 /**
4443  * Appliquer a un champ SQL le traitement qui est configure pour la balise homonyme dans les squelettes
4444  *
4445  * @param string $texte
4446  * @param string $champ
4447  * @param string $table_objet
4448  * @param array $env
4449  * @param string $connect
4450  * @return string
4451  */
4452 function appliquer_traitement_champ($texte, $champ, $table_objet = '', $env = array(), $connect = '') {
4453         if (!$champ) {
4454                 return $texte;
4455         }
4456
4457         // On charge toujours les filtres de texte car la majorité des traitements les utilisent
4458         // et il ne faut pas partir du principe que c'est déjà chargé (form ajax, etc)
4459         include_spip('inc/texte');
4460
4461         $champ = strtoupper($champ);
4462         $traitements = isset($GLOBALS['table_des_traitements'][$champ]) ? $GLOBALS['table_des_traitements'][$champ] : false;
4463         if (!$traitements or !is_array($traitements)) {
4464                 return $texte;
4465         }
4466
4467         $traitement = '';
4468         if ($table_objet and (!isset($traitements[0]) or count($traitements) > 1)) {
4469                 // necessaire pour prendre en charge les vieux appels avec un table_objet_sql en 3e arg
4470                 $table_objet = table_objet($table_objet);
4471                 if (isset($traitements[$table_objet])) {
4472                         $traitement = $traitements[$table_objet];
4473                 }
4474         }
4475         if (!$traitement and isset($traitements[0])) {
4476                 $traitement = $traitements[0];
4477         }
4478         // (sinon prendre le premier de la liste par defaut ?)
4479
4480         if (!$traitement) {
4481                 return $texte;
4482         }
4483
4484         $traitement = str_replace('%s', "'" . texte_script($texte) . "'", $traitement);
4485
4486         // Fournir $connect et $Pile[0] au traitement si besoin
4487         $Pile = array(0 => $env);
4488         eval("\$texte = $traitement;");
4489
4490         return $texte;
4491 }
4492
4493
4494 /**
4495  * Generer un lien (titre clicable vers url) vers un objet
4496  *
4497  * @param int $id_objet
4498  * @param $objet
4499  * @param int $longueur
4500  * @param null|string $connect
4501  * @return string
4502  */
4503 function generer_lien_entite($id_objet, $objet, $longueur = 80, $connect = null) {
4504         include_spip('inc/liens');
4505         $titre = traiter_raccourci_titre($id_objet, $objet, $connect);
4506         // lorsque l'objet n'est plus declare (plugin desactive par exemple)
4507         // le raccourcis n'est plus valide
4508         $titre = isset($titre['titre']) ? typo($titre['titre']) : '';
4509         // on essaye avec generer_info_entite ?
4510         if (!strlen($titre) and !$connect) {
4511                 $titre = generer_info_entite($id_objet, $objet, 'titre');
4512         }
4513         if (!strlen($titre)) {
4514                 $titre = _T('info_sans_titre');
4515         }
4516         $url = generer_url_entite($id_objet, $objet, '', '', $connect);
4517
4518         return "<a href='$url' class='$objet'>" . couper($titre, $longueur) . "</a>";
4519 }
4520
4521
4522 /**
4523  * Englobe (Wrap) un texte avec des balises
4524  *
4525  * @example `wrap('mot','<b>')` donne `<b>mot</b>'`
4526  *
4527  * @filtre
4528  * @uses extraire_balises()
4529  *
4530  * @param string $texte
4531  * @param string $wrap
4532  * @return string
4533  */
4534 function wrap($texte, $wrap) {
4535         $balises = extraire_balises($wrap);
4536         if (preg_match_all(",<([a-z]\w*)\b[^>]*>,UimsS", $wrap, $regs, PREG_PATTERN_ORDER)) {
4537                 $texte = $wrap . $texte;
4538                 $regs = array_reverse($regs[1]);
4539                 $wrap = "</" . implode("></", $regs) . ">";
4540                 $texte = $texte . $wrap;
4541         }
4542
4543         return $texte;
4544 }
4545
4546
4547 /**
4548  * afficher proprement n'importe quoi
4549  * On affiche in fine un pseudo-yaml qui premet de lire humainement les tableaux et de s'y reperer
4550  *
4551  * Les textes sont retournes avec simplement mise en forme typo
4552  *
4553  * le $join sert a separer les items d'un tableau, c'est en general un \n ou <br /> selon si on fait du html ou du texte
4554  * les tableaux-listes (qui n'ont que des cles numeriques), sont affiches sous forme de liste separee par des virgules :
4555  * c'est VOULU !
4556  *
4557  * @param $u
4558  * @param string $join
4559  * @param int $indent
4560  * @return array|mixed|string
4561  */
4562 function filtre_print_dist($u, $join = "<br />", $indent = 0) {
4563         if (is_string($u)) {
4564                 $u = typo($u);
4565
4566                 return $u;
4567         }
4568
4569         // caster $u en array si besoin
4570         if (is_object($u)) {
4571                 $u = (array)$u;
4572         }
4573
4574         if (is_array($u)) {
4575                 $out = "";
4576                 // toutes les cles sont numeriques ?
4577                 // et aucun enfant n'est un tableau
4578                 // liste simple separee par des virgules
4579                 $numeric_keys = array_map('is_numeric', array_keys($u));
4580                 $array_values = array_map('is_array', $u);
4581                 $object_values = array_map('is_object', $u);
4582                 if (array_sum($numeric_keys) == count($numeric_keys)
4583                         and !array_sum($array_values)
4584                         and !array_sum($object_values)
4585                 ) {
4586                         return join(", ", array_map('filtre_print_dist', $u));
4587                 }
4588
4589                 // sinon on passe a la ligne et on indente
4590                 $i_str = str_pad("", $indent, " ");
4591                 foreach ($u as $k => $v) {
4592                         $out .= $join . $i_str . "$k: " . filtre_print_dist($v, $join, $indent + 2);
4593                 }
4594
4595                 return $out;
4596         }
4597
4598         // on sait pas quoi faire...
4599         return $u;
4600 }
4601
4602
4603 /**
4604  * Renvoyer l'info d'un objet
4605  * telles que definies dans declarer_tables_objets_sql
4606  *
4607  * @param string $objet
4608  * @param string $info
4609  * @return string
4610  */
4611 function objet_info($objet, $info) {
4612         $table = table_objet_sql($objet);
4613         $infos = lister_tables_objets_sql($table);
4614
4615         return (isset($infos[$info]) ? $infos[$info] : '');
4616 }
4617
4618 /**
4619  * Filtre pour afficher 'Aucun truc' ou '1 truc' ou 'N trucs'
4620  * avec la bonne chaîne de langue en fonction de l'objet utilisé
4621  *
4622  * @param int $nb
4623  *     Nombre d'éléments
4624  * @param string $objet
4625  *     Objet
4626  * @return mixed|string
4627  *     Texte traduit du comptage, tel que '3 articles'
4628  */
4629 function objet_afficher_nb($nb, $objet) {
4630         if (!$nb) {
4631                 return _T(objet_info($objet, 'info_aucun_objet'));
4632         } else {
4633                 return _T(objet_info($objet, $nb == 1 ? 'info_1_objet' : 'info_nb_objets'), array('nb' => $nb));
4634         }
4635 }
4636
4637 /**
4638  * Filtre pour afficher l'img icone d'un objet
4639  *
4640  * @param string $objet
4641  * @param int $taille
4642  * @return string
4643  */
4644 function objet_icone($objet, $taille = 24) {
4645         $icone = objet_info($objet, 'icone_objet') . "-" . $taille . ".png";
4646         $icone = chemin_image($icone);
4647         $balise_img = charger_filtre('balise_img');
4648
4649         return $icone ? $balise_img($icone, _T(objet_info($objet, 'texte_objet'))) : '';
4650 }
4651
4652 /**
4653  * Renvoyer une traduction d'une chaine de langue contextuelle à un objet si elle existe,
4654  * la traduction de la chaine generique
4655  *
4656  * Ex : [(#ENV{objet}|objet_label{trad_reference})]
4657  * va chercher si une chaine objet:trad_reference existe et renvoyer sa trad le cas echeant
4658  * sinon renvoie la trad de la chaine trad_reference
4659  * Si la chaine fournie contient un prefixe il est remplacé par celui de l'objet pour chercher la chaine contextuelle
4660  *
4661  * Les arguments $args et $options sont ceux de la fonction _T
4662  *
4663  * @param string $objet
4664  * @param string $chaine
4665  * @param array $args
4666  * @param array $options
4667  * @return string
4668  */
4669 function objet_T($objet, $chaine, $args = array(), $options = array()){
4670         $chaine = explode(':',$chaine);
4671         if ($t = _T($objet . ':' . end($chaine), $args, array_merge($options, array('force'=>false)))) {
4672                 return $t;
4673         }
4674         $chaine = implode(':',$chaine);
4675         return _T($chaine, $args, $options);
4676 }
4677
4678 /**
4679  * Fonction de secours pour inserer le head_css de facon conditionnelle
4680  *
4681  * Appelée en filtre sur le squelette qui contient #INSERT_HEAD,
4682  * elle vérifie l'absence éventuelle de #INSERT_HEAD_CSS et y suplée si besoin
4683  * pour assurer la compat avec les squelettes qui n'utilisent pas.
4684  *
4685  * @param string $flux Code HTML
4686  * @return string      Code HTML
4687  */
4688 function insert_head_css_conditionnel($flux) {
4689         if (strpos($flux, '<!-- insert_head_css -->') === false
4690                 and $p = strpos($flux, '<!-- insert_head -->')
4691         ) {
4692                 // plutot avant le premier js externe (jquery) pour etre non bloquant
4693                 if ($p1 = stripos($flux, '<script src=') and $p1 < $p) {
4694                         $p = $p1;
4695                 }
4696                 $flux = substr_replace($flux, pipeline('insert_head_css', '<!-- insert_head_css -->'), $p, 0);
4697         }
4698
4699         return $flux;
4700 }
4701
4702 /**
4703  * Produire un fichier statique à partir d'un squelette dynamique
4704  *
4705  * Permet ensuite à Apache de le servir en statique sans repasser
4706  * par spip.php à chaque hit sur le fichier.
4707  *
4708  * Si le format (css ou js) est passe dans `contexte['format']`, on l'utilise
4709  * sinon on regarde si le fond finit par .css ou .js, sinon on utilie "html"
4710  *
4711  * @uses urls_absolues_css()
4712  *
4713  * @param string $fond
4714  * @param array $contexte
4715  * @param array $options
4716  * @param string $connect
4717  * @return string
4718  */
4719 function produire_fond_statique($fond, $contexte = array(), $options = array(), $connect = '') {
4720         if (isset($contexte['format'])) {
4721                 $extension = $contexte['format'];
4722                 unset($contexte['format']);
4723         } else {
4724                 $extension = "html";
4725                 if (preg_match(',[.](css|js|json)$,', $fond, $m)) {
4726                         $extension = $m[1];
4727                 }
4728         }
4729         // recuperer le contenu produit par le squelette
4730         $options['raw'] = true;
4731         $cache = recuperer_fond($fond, $contexte, $options, $connect);
4732
4733         // calculer le nom de la css
4734         $dir_var = sous_repertoire(_DIR_VAR, 'cache-' . $extension);
4735         $nom_safe = preg_replace(",\W,", '_', str_replace('.', '_', $fond));
4736         $contexte_implicite = calculer_contexte_implicite();
4737         $filename = $dir_var . $extension . "dyn-$nom_safe-"
4738                 . substr(md5($fond . serialize($contexte_implicite) . serialize($contexte) . $connect), 0, 8)
4739                 . ".$extension";
4740
4741         // mettre a jour le fichier si il n'existe pas
4742         // ou trop ancien
4743         // le dernier fichier produit est toujours suffixe par .last
4744         // et recopie sur le fichier cible uniquement si il change
4745         if (!file_exists($filename)
4746                 or !file_exists($filename . ".last")
4747                 or (isset($cache['lastmodified']) and $cache['lastmodified'] and filemtime($filename . ".last") < $cache['lastmodified'])
4748                 or (defined('_VAR_MODE') and _VAR_MODE == 'recalcul')
4749         ) {
4750                 $contenu = $cache['texte'];
4751                 // passer les urls en absolu si c'est une css
4752                 if ($extension == "css") {
4753                         $contenu = urls_absolues_css($contenu,
4754                                 test_espace_prive() ? generer_url_ecrire('accueil') : generer_url_public($fond));
4755                 }
4756
4757                 $comment = '';
4758                 // ne pas insérer de commentaire si c'est du json
4759                 if ($extension != "json") {
4760                         $comment = "/* #PRODUIRE{fond=$fond";
4761                         foreach ($contexte as $k => $v) {
4762                                 $comment .= ",$k=$v";
4763                         }
4764                         // pas de date dans le commentaire car sinon ca invalide le md5 et force la maj
4765                         // mais on peut mettre un md5 du contenu, ce qui donne un aperu rapide si la feuille a change ou non
4766                         $comment .= "}\n   md5:" . md5($contenu) . " */\n";
4767                 }
4768                 // et ecrire le fichier
4769                 ecrire_fichier($filename . ".last", $comment . $contenu);
4770                 // regarder si on recopie
4771                 if (!file_exists($filename)
4772                         or md5_file($filename) !== md5_file($filename . ".last")
4773                 ) {
4774                         @copy($filename . ".last", $filename);
4775                         clearstatcache(true, $filename); // eviter que PHP ne reserve le vieux timestamp
4776                 }
4777         }
4778
4779         return timestamp($filename);
4780 }
4781
4782 /**
4783  * Ajouter un timestamp a une url de fichier
4784  * [(#CHEMIN{monfichier}|timestamp)]
4785  *
4786  * @param string $fichier
4787  *    Le chemin du fichier sur lequel on souhaite ajouter le timestamp
4788  * @return string
4789  *    $fichier auquel on a ajouté le timestamp
4790  */
4791 function timestamp($fichier) {
4792         if (!$fichier
4793                 or !file_exists($fichier)
4794                 or !$m = filemtime($fichier)
4795         ) {
4796                 return $fichier;
4797         }
4798
4799         return "$fichier?$m";
4800 }
4801
4802 /**
4803  * Supprimer le timestamp d'une url
4804  *
4805  * @param string $url
4806  * @return string
4807  */
4808 function supprimer_timestamp($url) {
4809         if (strpos($url, "?") === false) {
4810                 return $url;
4811         }
4812
4813         return preg_replace(",\?[[:digit:]]+$,", "", $url);
4814 }
4815
4816 /**
4817  * Nettoyer le titre d'un email
4818  *
4819  * Éviter une erreur lorsqu'on utilise `|nettoyer_titre_email` dans un squelette de mail
4820  *
4821  * @filtre
4822  * @uses nettoyer_titre_email()
4823  *
4824  * @param string $titre
4825  * @return string
4826  */
4827 function filtre_nettoyer_titre_email_dist($titre) {
4828         include_spip('inc/envoyer_mail');
4829
4830         return nettoyer_titre_email($titre);
4831 }
4832
4833 /**
4834  * Afficher le sélecteur de rubrique
4835  *
4836  * Il permet de placer un objet dans la hiérarchie des rubriques de SPIP
4837  *
4838  * @uses chercher_rubrique()
4839  *
4840  * @param string $titre
4841  * @param int $id_objet
4842  * @param int $id_parent
4843  * @param string $objet
4844  * @param int $id_secteur
4845  * @param bool $restreint
4846  * @param bool $actionable
4847  *   true : fournit le selecteur dans un form directement postable
4848  * @param bool $retour_sans_cadre
4849  * @return string
4850  */
4851 function filtre_chercher_rubrique_dist(
4852         $titre,
4853         $id_objet,
4854         $id_parent,
4855         $objet,
4856         $id_secteur,
4857         $restreint,
4858         $actionable = false,
4859         $retour_sans_cadre = false
4860 ) {
4861         include_spip('inc/filtres_ecrire');
4862
4863         return chercher_rubrique($titre, $id_objet, $id_parent, $objet, $id_secteur, $restreint, $actionable,
4864                 $retour_sans_cadre);
4865 }
4866
4867 /**
4868  * Rediriger une page suivant une autorisation,
4869  * et ce, n'importe où dans un squelette, même dans les inclusions.
4870  *
4871  * En l'absence de redirection indiquée, la fonction redirige par défaut
4872  * sur une 403 dans l'espace privé et 404 dans l'espace public.
4873  *
4874  * @example
4875  *     ```
4876  *     [(#AUTORISER{non}|sinon_interdire_acces)]
4877  *     [(#AUTORISER{non}|sinon_interdire_acces{#URL_PAGE{login}, 401})]
4878  *     ```
4879  *
4880  * @filtre
4881  * @param bool $ok
4882  *     Indique si l'on doit rediriger ou pas
4883  * @param string $url
4884  *     Adresse eventuelle vers laquelle rediriger
4885  * @param int $statut
4886  *     Statut HTML avec lequel on redirigera
4887  * @param string $message
4888  *     message d'erreur
4889  * @return string|void
4890  *     Chaîne vide si l'accès est autorisé
4891  */
4892 function sinon_interdire_acces($ok = false, $url = '', $statut = 0, $message = null) {
4893         if ($ok) {
4894                 return '';
4895         }
4896
4897         // Vider tous les tampons
4898         $level = @ob_get_level();
4899         while ($level--) {
4900                 @ob_end_clean();
4901         }
4902
4903         include_spip('inc/headers');
4904
4905         // S'il y a une URL, on redirige (si pas de statut, la fonction mettra 302 par défaut)
4906         if ($url) {
4907                 redirige_par_entete($url, '', $statut);
4908         }
4909
4910         // ecriture simplifiee avec message en 3eme argument (= statut 403)
4911         if (!is_numeric($statut) and is_null($message)) {
4912                 $message = $statut;
4913                 $statut = 0;
4914         }
4915         if (!$message) {
4916                 $message = '';
4917         }
4918         $statut = intval($statut);
4919
4920         // Si on est dans l'espace privé, on génère du 403 Forbidden par defaut ou du 404
4921         if (test_espace_prive()) {
4922                 if (!$statut or !in_array($statut, array(404, 403))) {
4923                         $statut = 403;
4924                 }
4925                 http_status(403);
4926                 $echec = charger_fonction('403', 'exec');
4927                 $echec($message);
4928         } else {
4929                 // Sinon dans l'espace public on redirige vers une 404 par défaut, car elle toujours présente normalement
4930                 if (!$statut) {
4931                         $statut = 404;
4932                 }
4933                 // Dans tous les cas on modifie l'entité avec ce qui est demandé
4934                 http_status($statut);
4935                 // Si le statut est une erreur et qu'il n'y a pas de redirection on va chercher le squelette du même nom
4936                 if ($statut >= 400) {
4937                         echo recuperer_fond("$statut", array('erreur' => $message));
4938                 }
4939         }
4940
4941
4942         exit;
4943 }
4944
4945 /**
4946  * Assurer le fonctionnement de |compacte meme sans l'extension compresseur
4947  *
4948  * @param string $source
4949  * @param null|string $format
4950  * @return string
4951  */
4952 function filtre_compacte_dist($source, $format = null) {
4953         if (function_exists('compacte')) {
4954                 return compacte($source, $format);
4955         }
4956
4957         return $source;
4958 }