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(
1920                         $balise,
1921                         function(&$a, $key, $t){
1922                                 $a = extraire_attribut($a, $t);
1923                         },
1924                         $attribut
1925                 );
1926
1927                 return $balise;
1928         }
1929         if (preg_match(
1930                 ',(^.*?<(?:(?>\s*)(?>[\w:.-]+)(?>(?:=(?:"[^"]*"|\'[^\']*\'|[^\'"]\S*))?))*?)(\s+'
1931                 . $attribut
1932                 . '(?:=\s*("[^"]*"|\'[^\']*\'|[^\'"]\S*))?)()((?:[\s/][^>]*)?>.*),isS',
1933
1934                 $balise, $r)) {
1935                 if (isset($r[3][0]) and ($r[3][0] == '"' || $r[3][0] == "'")) {
1936                         $r[4] = substr($r[3], 1, -1);
1937                         $r[3] = $r[3][0];
1938                 } elseif ($r[3] !== '') {
1939                         $r[4] = $r[3];
1940                         $r[3] = '';
1941                 } else {
1942                         $r[4] = trim($r[2]);
1943                 }
1944                 $att = $r[4];
1945                 if (strpos($att, "&#") !== false) {
1946                         $att = str_replace(array("&#039;", "&#39;", "&#034;", "&#34;"), array("'", "'", '"', '"'), $att);
1947                 }
1948                 $att = filtrer_entites($att);
1949         } else {
1950                 $att = null;
1951         }
1952
1953         if ($complet) {
1954                 return array($att, $r);
1955         } else {
1956                 return $att;
1957         }
1958 }
1959
1960 /**
1961  * Insérer (ou modifier) un attribut html dans une balise
1962  *
1963  * @example
1964  *     - `[(#LOGO_ARTICLE|inserer_attribut{class, logo article})]`
1965  *     - `[(#LOGO_ARTICLE|inserer_attribut{alt, #TTTRE|attribut_html|couper{60}})]`
1966  *     - `[(#FICHIER|image_reduire{40}|inserer_attribut{data-description, #DESCRIPTIF})]`
1967  *       Laissera les balises HTML de la valeur (ici `#DESCRIPTIF`) si on n'applique pas le
1968  *       filtre `attribut_html` dessus.
1969  *
1970  * @filtre
1971  * @link http://www.spip.net/4294
1972  * @uses attribut_html()
1973  * @uses extraire_attribut()
1974  *
1975  * @param string $balise
1976  *     Code html de la balise (ou contenant une balise)
1977  * @param string $attribut
1978  *     Nom de l'attribut html à modifier
1979  * @param string $val
1980  *     Valeur de l'attribut à appliquer
1981  * @param bool $proteger
1982  *     Prépare la valeur en tant qu'attribut de balise (mais conserve les balises html).
1983  * @param bool $vider
1984  *     True pour vider l'attribut. Une chaîne vide pour `$val` fera pareil.
1985  * @return string
1986  *     Code html modifié
1987  **/
1988 function inserer_attribut($balise, $attribut, $val, $proteger = true, $vider = false) {
1989         // preparer l'attribut
1990         // supprimer les &nbsp; etc mais pas les balises html
1991         // qui ont un sens dans un attribut value d'un input
1992         if ($proteger) {
1993                 $val = attribut_html($val, false);
1994         }
1995
1996         // echapper les ' pour eviter tout bug
1997         $val = str_replace("'", "&#039;", $val);
1998         if ($vider and strlen($val) == 0) {
1999                 $insert = '';
2000         } else {
2001                 $insert = " $attribut='$val'";
2002         }
2003
2004         list($old, $r) = extraire_attribut($balise, $attribut, true);
2005
2006         if ($old !== null) {
2007                 // Remplacer l'ancien attribut du meme nom
2008                 $balise = $r[1] . $insert . $r[5];
2009         } else {
2010                 // preferer une balise " />" (comme <img />)
2011                 if (preg_match(',/>,', $balise)) {
2012                         $balise = preg_replace(",\s?/>,S", $insert . " />", $balise, 1);
2013                 } // sinon une balise <a ...> ... </a>
2014                 else {
2015                         $balise = preg_replace(",\s?>,S", $insert . ">", $balise, 1);
2016                 }
2017         }
2018
2019         return $balise;
2020 }
2021
2022 /**
2023  * Supprime un attribut HTML
2024  *
2025  * @example `[(#LOGO_ARTICLE|vider_attribut{class})]`
2026  *
2027  * @filtre
2028  * @link http://www.spip.net/4142
2029  * @uses inserer_attribut()
2030  * @see  extraire_attribut()
2031  *
2032  * @param string $balise Code HTML de l'élément
2033  * @param string $attribut Nom de l'attribut à enlever
2034  * @return string Code HTML sans l'attribut
2035  **/
2036 function vider_attribut($balise, $attribut) {
2037         return inserer_attribut($balise, $attribut, '', false, true);
2038 }
2039
2040
2041 /**
2042  * Un filtre pour déterminer le nom du statut des inscrits
2043  *
2044  * @param void|int $id
2045  * @param string $mode
2046  * @return string
2047  */
2048 function tester_config($id, $mode = '') {
2049         include_spip('action/inscrire_auteur');
2050
2051         return tester_statut_inscription($mode, $id);
2052 }
2053
2054 //
2055 // Quelques fonctions de calcul arithmetique
2056 //
2057 function floatstr($a) { return str_replace(',','.',(string)floatval($a)); }
2058 function strize($f, $a, $b) { return floatstr($f(floatstr($a),floatstr($b))); }
2059
2060 /**
2061  * Additionne 2 nombres
2062  *
2063  * @filtre
2064  * @link http://www.spip.net/4307
2065  * @see moins()
2066  * @example
2067  *     ```
2068  *     [(#VAL{28}|plus{14})]
2069  *     ```
2070  *
2071  * @param int $a
2072  * @param int $b
2073  * @return int $a+$b
2074  **/
2075 function plus($a, $b) {
2076         return $a + $b;
2077 }
2078 function strplus($a, $b) {return strize('plus', $a, $b);}
2079 /**
2080  * Soustrait 2 nombres
2081  *
2082  * @filtre
2083  * @link http://www.spip.net/4302
2084  * @see plus()
2085  * @example
2086  *     ```
2087  *     [(#VAL{28}|moins{14})]
2088  *     ```
2089  *
2090  * @param int $a
2091  * @param int $b
2092  * @return int $a-$b
2093  **/
2094 function moins($a, $b) {
2095         return $a - $b;
2096 }
2097 function strmoins($a, $b) {return strize('moins', $a, $b);}
2098
2099 /**
2100  * Multiplie 2 nombres
2101  *
2102  * @filtre
2103  * @link http://www.spip.net/4304
2104  * @see div()
2105  * @see modulo()
2106  * @example
2107  *     ```
2108  *     [(#VAL{28}|mult{14})]
2109  *     ```
2110  *
2111  * @param int $a
2112  * @param int $b
2113  * @return int $a*$b
2114  **/
2115 function mult($a, $b) {
2116         return $a * $b;
2117 }
2118 function strmult($a, $b) {return strize('mult', $a, $b);}
2119
2120 /**
2121  * Divise 2 nombres
2122  *
2123  * @filtre
2124  * @link http://www.spip.net/4279
2125  * @see mult()
2126  * @see modulo()
2127  * @example
2128  *     ```
2129  *     [(#VAL{28}|div{14})]
2130  *     ```
2131  *
2132  * @param int $a
2133  * @param int $b
2134  * @return int $a/$b (ou 0 si $b est nul)
2135  **/
2136 function div($a, $b) {
2137         return $b ? $a / $b : 0;
2138 }
2139 function strdiv($a, $b) {return strize('div', $a, $b);}
2140
2141 /**
2142  * Retourne le modulo 2 nombres
2143  *
2144  * @filtre
2145  * @link http://www.spip.net/4301
2146  * @see mult()
2147  * @see div()
2148  * @example
2149  *     ```
2150  *     [(#VAL{28}|modulo{14})]
2151  *     ```
2152  *
2153  * @param int $nb
2154  * @param int $mod
2155  * @param int $add
2156  * @return int ($nb % $mod) + $add
2157  **/
2158 function modulo($nb, $mod, $add = 0) {
2159         return ($mod ? $nb % $mod : 0) + $add;
2160 }
2161
2162
2163 /**
2164  * Vérifie qu'un nom (d'auteur) ne comporte pas d'autres tags que <multi>
2165  * et ceux volontairement spécifiés dans la constante
2166  *
2167  * @param string $nom
2168  *      Nom (signature) proposé
2169  * @return bool
2170  *      - false si pas conforme,
2171  *      - true sinon
2172  **/
2173 function nom_acceptable($nom) {
2174         if (!is_string($nom)) {
2175                 return false;
2176         }
2177         if (!defined('_TAGS_NOM_AUTEUR')) {
2178                 define('_TAGS_NOM_AUTEUR', '');
2179         }
2180         $tags_acceptes = array_unique(explode(',', 'multi,' . _TAGS_NOM_AUTEUR));
2181         foreach ($tags_acceptes as $tag) {
2182                 if (strlen($tag)) {
2183                         $remp1[] = '<' . trim($tag) . '>';
2184                         $remp1[] = '</' . trim($tag) . '>';
2185                         $remp2[] = '\x60' . trim($tag) . '\x61';
2186                         $remp2[] = '\x60/' . trim($tag) . '\x61';
2187                 }
2188         }
2189         $v_nom = str_replace($remp2, $remp1, supprimer_tags(str_replace($remp1, $remp2, $nom)));
2190
2191         return str_replace('&lt;', '<', $v_nom) == $nom;
2192 }
2193
2194
2195 /**
2196  * Vérifier la conformité d'une ou plusieurs adresses email (suivant RFC 822)
2197  *
2198  * @param string $adresses
2199  *      Adresse ou liste d'adresse
2200  * @return bool|string
2201  *      - false si pas conforme,
2202  *      - la normalisation de la dernière adresse donnée sinon
2203  **/
2204 function email_valide($adresses) {
2205         // eviter d'injecter n'importe quoi dans preg_match
2206         if (!is_string($adresses)) {
2207                 return false;
2208         }
2209
2210         // Si c'est un spammeur autant arreter tout de suite
2211         if (preg_match(",[\n\r].*(MIME|multipart|Content-),i", $adresses)) {
2212                 spip_log("Tentative d'injection de mail : $adresses");
2213
2214                 return false;
2215         }
2216
2217         foreach (explode(',', $adresses) as $v) {
2218                 // nettoyer certains formats
2219                 // "Marie Toto <Marie@toto.com>"
2220                 $adresse = trim(preg_replace(",^[^<>\"]*<([^<>\"]+)>$,i", "\\1", $v));
2221                 // RFC 822
2222                 if (!preg_match('#^[^()<>@,;:\\"/[:space:]]+(@([-_0-9a-z]+\.)*[-_0-9a-z]+)$#i', $adresse)) {
2223                         return false;
2224                 }
2225         }
2226
2227         return $adresse;
2228 }
2229
2230 /**
2231  * Permet d'afficher un symbole à côté des liens pointant vers les
2232  * documents attachés d'un article (liens ayant `rel=enclosure`).
2233  *
2234  * @filtre
2235  * @link http://www.spip.net/4134
2236  *
2237  * @param string $tags Texte
2238  * @return string Texte
2239  **/
2240 function afficher_enclosures($tags) {
2241         $s = array();
2242         foreach (extraire_balises($tags, 'a') as $tag) {
2243                 if (extraire_attribut($tag, 'rel') == 'enclosure'
2244                         and $t = extraire_attribut($tag, 'href')
2245                 ) {
2246                         $s[] = preg_replace(',>[^<]+</a>,S',
2247                                 '>'
2248                                 . http_img_pack('attachment-16.png', $t,
2249                                         'title="' . attribut_html($t) . '"')
2250                                 . '</a>', $tag);
2251                 }
2252         }
2253
2254         return join('&nbsp;', $s);
2255 }
2256
2257 /**
2258  * Filtre des liens HTML `<a>` selon la valeur de leur attribut `rel`
2259  * et ne retourne que ceux là.
2260  *
2261  * @filtre
2262  * @link http://www.spip.net/4187
2263  *
2264  * @param string $tags Texte
2265  * @param string $rels Attribut `rel` à capturer (ou plusieurs séparés par des virgules)
2266  * @return string Liens trouvés
2267  **/
2268 function afficher_tags($tags, $rels = 'tag,directory') {
2269         $s = array();
2270         foreach (extraire_balises($tags, 'a') as $tag) {
2271                 $rel = extraire_attribut($tag, 'rel');
2272                 if (strstr(",$rels,", ",$rel,")) {
2273                         $s[] = $tag;
2274                 }
2275         }
2276
2277         return join(', ', $s);
2278 }
2279
2280
2281 /**
2282  * Convertir les médias fournis par un flux RSS (podcasts)
2283  * en liens conformes aux microformats
2284  *
2285  * Passe un `<enclosure url="fichier" length="5588242" type="audio/mpeg"/>`
2286  * au format microformat `<a rel="enclosure" href="fichier" ...>fichier</a>`.
2287  *
2288  * Peut recevoir un `<link` ou un `<media:content` parfois.
2289  *
2290  * Attention : `length="zz"` devient `title="zz"`, pour rester conforme.
2291  *
2292  * @filtre
2293  * @see microformat2enclosure() Pour l'inverse
2294  *
2295  * @param string $e Tag RSS `<enclosure>`
2296  * @return string Tag HTML `<a>` avec microformat.
2297  **/
2298 function enclosure2microformat($e) {
2299         if (!$url = filtrer_entites(extraire_attribut($e, 'url'))) {
2300                 $url = filtrer_entites(extraire_attribut($e, 'href'));
2301         }
2302         $type = extraire_attribut($e, 'type');
2303         if (!$length = extraire_attribut($e, 'length')) {
2304                 # <media:content : longeur dans fileSize. On tente.
2305                 $length = extraire_attribut($e, 'fileSize');
2306         }
2307         $fichier = basename($url);
2308
2309         return '<a rel="enclosure"'
2310         . ($url ? ' href="' . spip_htmlspecialchars($url) . '"' : '')
2311         . ($type ? ' type="' . spip_htmlspecialchars($type) . '"' : '')
2312         . ($length ? ' title="' . spip_htmlspecialchars($length) . '"' : '')
2313         . '>' . $fichier . '</a>';
2314 }
2315
2316 /**
2317  * Convertir les liens conformes aux microformats en médias pour flux RSS,
2318  * par exemple pour les podcasts
2319  *
2320  * Passe un texte ayant des liens avec microformat
2321  * `<a rel="enclosure" href="fichier" ...>fichier</a>`
2322  * au format RSS `<enclosure url="fichier" ... />`.
2323  *
2324  * @filtre
2325  * @see enclosure2microformat() Pour l'inverse
2326  *
2327  * @param string $tags Texte HTML ayant des tag `<a>` avec microformat
2328  * @return string Tags RSS `<enclosure>`.
2329  **/
2330 function microformat2enclosure($tags) {
2331         $enclosures = array();
2332         foreach (extraire_balises($tags, 'a') as $e) {
2333                 if (extraire_attribut($e, 'rel') == 'enclosure') {
2334                         $url = filtrer_entites(extraire_attribut($e, 'href'));
2335                         $type = extraire_attribut($e, 'type');
2336                         if (!$length = intval(extraire_attribut($e, 'title'))) {
2337                                 $length = intval(extraire_attribut($e, 'length'));
2338                         } # vieux data
2339                         $fichier = basename($url);
2340                         $enclosures[] = '<enclosure'
2341                                 . ($url ? ' url="' . spip_htmlspecialchars($url) . '"' : '')
2342                                 . ($type ? ' type="' . spip_htmlspecialchars($type) . '"' : '')
2343                                 . ($length ? ' length="' . $length . '"' : '')
2344                                 . ' />';
2345                 }
2346         }
2347
2348         return join("\n", $enclosures);
2349 }
2350
2351
2352 /**
2353  * Créer les éléments ATOM `<dc:subject>` à partir des tags
2354  *
2355  * Convertit les liens avec attribut `rel="tag"`
2356  * en balise `<dc:subject></dc:subject>` pour les flux RSS au format Atom.
2357  *
2358  * @filtre
2359  *
2360  * @param string $tags Texte
2361  * @return string Tags RSS Atom `<dc:subject>`.
2362  **/
2363 function tags2dcsubject($tags) {
2364         $subjects = '';
2365         foreach (extraire_balises($tags, 'a') as $e) {
2366                 if (extraire_attribut($e, 'rel') == 'tag') {
2367                         $subjects .= '<dc:subject>'
2368                                 . texte_backend(textebrut($e))
2369                                 . '</dc:subject>' . "\n";
2370                 }
2371         }
2372
2373         return $subjects;
2374 }
2375
2376 /**
2377  * Retourne la premiere balise html du type demandé
2378  *
2379  * Retourne le contenu d'une balise jusqu'à la première fermeture rencontrée
2380  * du même type.
2381  * Si on a passe un tableau de textes, retourne un tableau de resultats.
2382  *
2383  * @example `[(#DESCRIPTIF|extraire_balise{img})]`
2384  *
2385  * @filtre
2386  * @link http://www.spip.net/4289
2387  * @see extraire_balises()
2388  * @note
2389  *     Attention : les résultats peuvent être incohérents sur des balises imbricables,
2390  *     tel que demander à extraire `div` dans le texte `<div> un <div> mot </div> absent </div>`,
2391  *     ce qui retournerait `<div> un <div> mot </div>` donc.
2392  *
2393  * @param string|array $texte
2394  *     Texte(s) dont on souhaite extraire une balise html
2395  * @param string $tag
2396  *     Nom de la balise html à extraire
2397  * @return void|string|array
2398  *     - Code html de la balise, sinon rien
2399  *     - Tableau de résultats, si tableau en entrée.
2400  **/
2401 function extraire_balise($texte, $tag = 'a') {
2402         if (is_array($texte)) {
2403                 array_walk(
2404                         $texte,
2405                         function(&$a, $key, $t){
2406                                 $a = extraire_balise($a, $t);
2407                         },
2408                         $tag
2409                 );
2410
2411                 return $texte;
2412         }
2413
2414         if (preg_match(
2415                 ",<$tag\b[^>]*(/>|>.*</$tag\b[^>]*>|>),UimsS",
2416                 $texte, $regs)) {
2417                 return $regs[0];
2418         }
2419 }
2420
2421 /**
2422  * Extrait toutes les balises html du type demandé
2423  *
2424  * Retourne dans un tableau le contenu de chaque balise jusqu'à la première
2425  * fermeture rencontrée du même type.
2426  * Si on a passe un tableau de textes, retourne un tableau de resultats.
2427  *
2428  * @example `[(#TEXTE|extraire_balises{img}|implode{" - "})]`
2429  *
2430  * @filtre
2431  * @link http://www.spip.net/5618
2432  * @see extraire_balise()
2433  * @note
2434  *     Attention : les résultats peuvent être incohérents sur des balises imbricables,
2435  *     tel que demander à extraire `div` dans un texte.
2436  *
2437  * @param string|array $texte
2438  *     Texte(s) dont on souhaite extraire une balise html
2439  * @param string $tag
2440  *     Nom de la balise html à extraire
2441  * @return array
2442  *     - Liste des codes html des occurrences de la balise, sinon tableau vide
2443  *     - Tableau de résultats, si tableau en entrée.
2444  **/
2445 function extraire_balises($texte, $tag = 'a') {
2446         if (is_array($texte)) {
2447                 array_walk(
2448                         $texte,
2449                         function(&$a, $key, $t){
2450                                 $a = extraire_balises($a, $t);
2451                         },
2452                         $tag
2453                 );
2454
2455                 return $texte;
2456         }
2457
2458         if (preg_match_all(
2459                 ",<${tag}\b[^>]*(/>|>.*</${tag}\b[^>]*>|>),UimsS",
2460                 $texte, $regs, PREG_PATTERN_ORDER)) {
2461                 return $regs[0];
2462         } else {
2463                 return array();
2464         }
2465 }
2466
2467 /**
2468  * Indique si le premier argument est contenu dans le second
2469  *
2470  * Cette fonction est proche de `in_array()` en PHP avec comme principale
2471  * différence qu'elle ne crée pas d'erreur si le second argument n'est pas
2472  * un tableau (dans ce cas elle tentera de le désérialiser, et sinon retournera
2473  * la valeur par défaut transmise).
2474  *
2475  * @example `[(#VAL{deux}|in_any{#LISTE{un,deux,trois}}|oui) ... ]`
2476  *
2477  * @filtre
2478  * @see filtre_find() Assez proche, avec les arguments valeur et tableau inversés.
2479  *
2480  * @param string $val
2481  *     Valeur à chercher dans le tableau
2482  * @param array|string $vals
2483  *     Tableau des valeurs. S'il ce n'est pas un tableau qui est transmis,
2484  *     la fonction tente de la désérialiser.
2485  * @param string $def
2486  *     Valeur par défaut retournée si `$vals` n'est pas un tableau.
2487  * @return string
2488  *     - ' ' si la valeur cherchée est dans le tableau
2489  *     - '' si la valeur n'est pas dans le tableau
2490  *     - `$def` si on n'a pas transmis de tableau
2491  **/
2492 function in_any($val, $vals, $def = '') {
2493         if (!is_array($vals) and $v = unserialize($vals)) {
2494                 $vals = $v;
2495         }
2496
2497         return (!is_array($vals) ? $def : (in_array($val, $vals) ? ' ' : ''));
2498 }
2499
2500
2501 /**
2502  * Retourne le résultat d'une expression mathématique simple
2503  *
2504  * N'accepte que les *, + et - (à ameliorer si on l'utilise vraiment).
2505  *
2506  * @filtre
2507  * @example
2508  *      ```
2509  *      valeur_numerique("3*2") retourne 6
2510  *      ```
2511  *
2512  * @param string $expr
2513  *     Expression mathématique `nombre operateur nombre` comme `3*2`
2514  * @return int
2515  *     Résultat du calcul
2516  **/
2517 function valeur_numerique($expr) {
2518         $a = 0;
2519         if (preg_match(',^[0-9]+(\s*[+*-]\s*[0-9]+)*$,S', trim($expr))) {
2520                 eval("\$a = $expr;");
2521         }
2522
2523         return intval($a);
2524 }
2525
2526 /**
2527  * Retourne un calcul de règle de trois
2528  *
2529  * @filtre
2530  * @example
2531  *     ```
2532  *     [(#VAL{6}|regledetrois{4,3})] retourne 8
2533  *     ```
2534  *
2535  * @param int $a
2536  * @param int $b
2537  * @param int $c
2538  * @return int
2539  *      Retourne `$a*$b/$c`
2540  **/
2541 function regledetrois($a, $b, $c) {
2542         return round($a * $b / $c);
2543 }
2544
2545
2546 /**
2547  * Crée des tags HTML input hidden pour chaque paramètre et valeur d'une URL
2548  *
2549  * Fournit la suite de Input-Hidden correspondant aux paramètres de
2550  * l'URL donnée en argument, compatible avec les types_urls
2551  *
2552  * @filtre
2553  * @link http://www.spip.net/4286
2554  * @see balise_ACTION_FORMULAIRE()
2555  *     Également pour transmettre les actions à un formulaire
2556  * @example
2557  *     ```
2558  *     [(#ENV{action}|form_hidden)] dans un formulaire
2559  *     ```
2560  *
2561  * @param string $action URL
2562  * @return string Suite de champs input hidden
2563  **/
2564 function form_hidden($action) {
2565
2566         $contexte = array();
2567         include_spip('inc/urls');
2568         if ($p = urls_decoder_url($action, '')
2569                 and reset($p)
2570         ) {
2571                 $fond = array_shift($p);
2572                 if ($fond != '404') {
2573                         $contexte = array_shift($p);
2574                         $contexte['page'] = $fond;
2575                         $action = preg_replace('/([?]' . preg_quote($fond) . '[^&=]*[0-9]+)(&|$)/', '?&', $action);
2576                 }
2577         }
2578         // defaire ce qu'a injecte urls_decoder_url : a revoir en modifiant la signature de urls_decoder_url
2579         if (defined('_DEFINIR_CONTEXTE_TYPE') and _DEFINIR_CONTEXTE_TYPE) {
2580                 unset($contexte['type']);
2581         }
2582         if (defined('_DEFINIR_CONTEXTE_TYPE_PAGE') and _DEFINIR_CONTEXTE_TYPE_PAGE) {
2583                 unset($contexte['type-page']);
2584         }
2585
2586         // on va remplir un tableau de valeurs en prenant bien soin de ne pas
2587         // ecraser les elements de la forme mots[]=1&mots[]=2
2588         $values = array();
2589
2590         // d'abord avec celles de l'url
2591         if (false !== ($p = strpos($action, '?'))) {
2592                 foreach (preg_split('/&(amp;)?/S', substr($action, $p + 1)) as $c) {
2593                         $c = explode('=', $c, 2);
2594                         $var = array_shift($c);
2595                         $val = array_shift($c);
2596                         if ($var) {
2597                                 $val = rawurldecode($val);
2598                                 $var = rawurldecode($var); // decoder les [] eventuels
2599                                 if (preg_match(',\[\]$,S', $var)) {
2600                                         $values[] = array($var, $val);
2601                                 } else {
2602                                         if (!isset($values[$var])) {
2603                                                 $values[$var] = array($var, $val);
2604                                         }
2605                                 }
2606                         }
2607                 }
2608         }
2609
2610         // ensuite avec celles du contexte, sans doublonner !
2611         foreach ($contexte as $var => $val) {
2612                 if (preg_match(',\[\]$,S', $var)) {
2613                         $values[] = array($var, $val);
2614                 } else {
2615                         if (!isset($values[$var])) {
2616                                 $values[$var] = array($var, $val);
2617                         }
2618                 }
2619         }
2620
2621         // puis on rassemble le tout
2622         $hidden = array();
2623         foreach ($values as $value) {
2624                 list($var, $val) = $value;
2625                 $hidden[] = '<input name="'
2626                         . entites_html($var)
2627                         . '"'
2628                         . (is_null($val)
2629                                 ? ''
2630                                 : ' value="' . entites_html($val) . '"'
2631                         )
2632                         . ' type="hidden"' . "\n/>";
2633         }
2634
2635         return join("", $hidden);
2636 }
2637
2638 /**
2639  * Calcule les bornes d'une pagination
2640  *
2641  * @filtre
2642  *
2643  * @param int $courante
2644  *     Page courante
2645  * @param int $nombre
2646  *     Nombre de pages
2647  * @param int $max
2648  *     Nombre d'éléments par page
2649  * @return int[]
2650  *     Liste (première page, dernière page).
2651  **/
2652 function filtre_bornes_pagination_dist($courante, $nombre, $max = 10) {
2653         if ($max <= 0 or $max >= $nombre) {
2654                 return array(1, $nombre);
2655         }
2656
2657         $premiere = max(1, $courante - floor(($max - 1) / 2));
2658         $derniere = min($nombre, $premiere + $max - 2);
2659         $premiere = $derniere == $nombre ? $derniere - $max + 1 : $premiere;
2660
2661         return array($premiere, $derniere);
2662 }
2663
2664
2665 /**
2666  * Retourne la première valeur d'un tableau
2667  *
2668  * Plus précisément déplace le pointeur du tableau sur la première valeur et la retourne.
2669  *
2670  * @example `[(#LISTE{un,deux,trois}|reset)]` retourne 'un'
2671  *
2672  * @filtre
2673  * @link http://php.net/manual/fr/function.reset.php
2674  * @see filtre_end()
2675  *
2676  * @param array $array
2677  * @return mixed|null|false
2678  *    - null si $array n'est pas un tableau,
2679  *    - false si le tableau est vide
2680  *    - la première valeur du tableau sinon.
2681  **/
2682 function filtre_reset($array) {
2683         return !is_array($array) ? null : reset($array);
2684 }
2685
2686 /**
2687  * Retourne la dernière valeur d'un tableau
2688  *
2689  * Plus précisément déplace le pointeur du tableau sur la dernière valeur et la retourne.
2690  *
2691  * @example `[(#LISTE{un,deux,trois}|end)]` retourne 'trois'
2692  *
2693  * @filtre
2694  * @link http://php.net/manual/fr/function.end.php
2695  * @see filtre_reset()
2696  *
2697  * @param array $array
2698  * @return mixed|null|false
2699  *    - null si $array n'est pas un tableau,
2700  *    - false si le tableau est vide
2701  *    - la dernière valeur du tableau sinon.
2702  **/
2703 function filtre_end($array) {
2704         return !is_array($array) ? null : end($array);
2705 }
2706
2707 /**
2708  * Empile une valeur à la fin d'un tableau
2709  *
2710  * @example `[(#LISTE{un,deux,trois}|push{quatre}|print)]`
2711  *
2712  * @filtre
2713  * @link http://www.spip.net/4571
2714  * @link http://php.net/manual/fr/function.array-push.php
2715  *
2716  * @param array $array
2717  * @param mixed $val
2718  * @return array|string
2719  *     - '' si $array n'est pas un tableau ou si echec.
2720  *     - le tableau complété de la valeur sinon.
2721  *
2722  **/
2723 function filtre_push($array, $val) {
2724         if (!is_array($array) or !array_push($array, $val)) {
2725                 return '';
2726         }
2727
2728         return $array;
2729 }
2730
2731 /**
2732  * Indique si une valeur est contenue dans un tableau
2733  *
2734  * @example `[(#LISTE{un,deux,trois}|find{quatre}|oui) ... ]`
2735  *
2736  * @filtre
2737  * @link http://www.spip.net/4575
2738  * @see in_any() Assez proche, avec les paramètres tableau et valeur inversés.
2739  *
2740  * @param array $array
2741  * @param mixed $val
2742  * @return bool
2743  *     - `false` si `$array` n'est pas un tableau
2744  *     - `true` si la valeur existe dans le tableau, `false` sinon.
2745  **/
2746 function filtre_find($array, $val) {
2747         return (is_array($array) and in_array($val, $array));
2748 }
2749
2750
2751 /**
2752  * Filtre calculant une pagination, utilisé par la balise `#PAGINATION`
2753  *
2754  * Le filtre cherche le modèle `pagination.html` par défaut, mais peut
2755  * chercher un modèle de pagination particulier avec l'argument `$modele`.
2756  * S'il `$modele='prive'`, le filtre cherchera le modèle `pagination_prive.html`.
2757  *
2758  * @filtre
2759  * @see balise_PAGINATION_dist()
2760  *
2761  * @param int $total
2762  *     Nombre total d'éléments
2763  * @param string $nom
2764  *     Nom identifiant la pagination
2765  * @param int $position
2766  *     Page à afficher (tel que la 3è page)
2767  * @param int $pas
2768  *     Nombre d'éléments par page
2769  * @param bool $liste
2770  *     - True pour afficher toute la liste des éléments,
2771  *     - False pour n'afficher que l'ancre
2772  * @param string $modele
2773  *     Nom spécifique du modèle de pagination
2774  * @param string $connect
2775  *     Nom du connecteur à la base de données
2776  * @param array $env
2777  *     Environnement à transmettre au modèle
2778  * @return string
2779  *     Code HTML de la pagination
2780  **/
2781 function filtre_pagination_dist(
2782         $total,
2783         $nom,
2784         $position,
2785         $pas,
2786         $liste = true,
2787         $modele = '',
2788         $connect = '',
2789         $env = array()
2790 ) {
2791         static $ancres = array();
2792         if ($pas < 1) {
2793                 return '';
2794         }
2795         $ancre = 'pagination' . $nom; // #pagination_articles
2796         $debut = 'debut' . $nom; // 'debut_articles'
2797
2798         // n'afficher l'ancre qu'une fois
2799         if (!isset($ancres[$ancre])) {
2800                 $bloc_ancre = $ancres[$ancre] = "<a name='" . $ancre . "' id='" . $ancre . "'></a>";
2801         } else {
2802                 $bloc_ancre = '';
2803         }
2804         // liste = false : on ne veut que l'ancre
2805         if (!$liste) {
2806                 return $ancres[$ancre];
2807         }
2808
2809         $self = (empty($env['self']) ? self() : $env['self']);
2810         $pagination = array(
2811                 'debut' => $debut,
2812                 'url' => parametre_url($self, 'fragment', ''), // nettoyer l'id ahah eventuel
2813                 'total' => $total,
2814                 'position' => intval($position),
2815                 'pas' => $pas,
2816                 'nombre_pages' => floor(($total - 1) / $pas) + 1,
2817                 'page_courante' => floor(intval($position) / $pas) + 1,
2818                 'ancre' => $ancre,
2819                 'bloc_ancre' => $bloc_ancre
2820         );
2821         if (is_array($env)) {
2822                 $pagination = array_merge($env, $pagination);
2823         }
2824
2825         // Pas de pagination
2826         if ($pagination['nombre_pages'] <= 1) {
2827                 return '';
2828         }
2829
2830         if ($modele) {
2831                 $modele = '_' . $modele;
2832         }
2833
2834         return recuperer_fond("modeles/pagination$modele", $pagination, array('trim' => true), $connect);
2835 }
2836
2837
2838 /**
2839  * Passer les url relatives à la css d'origine en url absolues
2840  *
2841  * @uses suivre_lien()
2842  *
2843  * @param string $contenu
2844  *     Contenu du fichier CSS
2845  * @param string $source
2846  *     Chemin du fichier CSS
2847  * @return string
2848  *     Contenu avec urls en absolus
2849  **/
2850 function urls_absolues_css($contenu, $source) {
2851         $path = suivre_lien(url_absolue($source), './');
2852
2853         return preg_replace_callback(
2854                 ",url\s*\(\s*['\"]?([^'\"/#\s][^:]*)['\"]?\s*\),Uims",
2855                 function($x) use ($path) {
2856                         return "url('" . suivre_lien($path, $x[1]) . "')";
2857                 },
2858                 $contenu
2859         );
2860 }
2861
2862
2863 /**
2864  * Inverse le code CSS (left <--> right) d'une feuille de style CSS
2865  *
2866  * Récupère le chemin d'une CSS existante et :
2867  *
2868  * 1. regarde si une CSS inversée droite-gauche existe dans le meme répertoire
2869  * 2. sinon la crée (ou la recrée) dans `_DIR_VAR/cache_css/`
2870  *
2871  * Si on lui donne à manger une feuille nommée `*_rtl.css` il va faire l'inverse.
2872  *
2873  * @filtre
2874  * @example
2875  *     ```
2876  *     [<link rel="stylesheet" href="(#CHEMIN{css/perso.css}|direction_css)" type="text/css" />]
2877  *     ```
2878  * @param string $css
2879  *     Chemin vers le fichier CSS
2880  * @param string $voulue
2881  *     Permet de forcer le sens voulu (en indiquant `ltr`, `rtl` ou un
2882  *     code de langue). En absence, prend le sens de la langue en cours.
2883  *
2884  * @return string
2885  *     Chemin du fichier CSS inversé
2886  **/
2887 function direction_css($css, $voulue = '') {
2888         if (!preg_match(',(_rtl)?\.css$,i', $css, $r)) {
2889                 return $css;
2890         }
2891
2892         // si on a precise le sens voulu en argument, le prendre en compte
2893         if ($voulue = strtolower($voulue)) {
2894                 if ($voulue != 'rtl' and $voulue != 'ltr') {
2895                         $voulue = lang_dir($voulue);
2896                 }
2897         } else {
2898                 $voulue = lang_dir();
2899         }
2900
2901         $r = count($r) > 1;
2902         $right = $r ? 'left' : 'right'; // 'right' de la css lue en entree
2903         $dir = $r ? 'rtl' : 'ltr';
2904         $ndir = $r ? 'ltr' : 'rtl';
2905
2906         if ($voulue == $dir) {
2907                 return $css;
2908         }
2909
2910         if (
2911                 // url absolue
2912                 preg_match(",^http:,i", $css)
2913                 // ou qui contient un ?
2914                 or (($p = strpos($css, '?')) !== false)
2915         ) {
2916                 $distant = true;
2917                 $cssf = parse_url($css);
2918                 $cssf = $cssf['path'] . ($cssf['query'] ? "?" . $cssf['query'] : "");
2919                 $cssf = preg_replace(',[?:&=],', "_", $cssf);
2920         } else {
2921                 $distant = false;
2922                 $cssf = $css;
2923                 // 1. regarder d'abord si un fichier avec la bonne direction n'est pas aussi
2924                 //propose (rien a faire dans ce cas)
2925                 $f = preg_replace(',(_rtl)?\.css$,i', '_' . $ndir . '.css', $css);
2926                 if (@file_exists($f)) {
2927                         return $f;
2928                 }
2929         }
2930
2931         // 2.
2932         $dir_var = sous_repertoire(_DIR_VAR, 'cache-css');
2933         $f = $dir_var
2934                 . preg_replace(',.*/(.*?)(_rtl)?\.css,', '\1', $cssf)
2935                 . '.' . substr(md5($cssf), 0, 4) . '_' . $ndir . '.css';
2936
2937         // la css peut etre distante (url absolue !)
2938         if ($distant) {
2939                 include_spip('inc/distant');
2940                 $contenu = recuperer_page($css);
2941                 if (!$contenu) {
2942                         return $css;
2943                 }
2944         } else {
2945                 if ((@filemtime($f) > @filemtime($css))
2946                         and (_VAR_MODE != 'recalcul')
2947                 ) {
2948                         return $f;
2949                 }
2950                 if (!lire_fichier($css, $contenu)) {
2951                         return $css;
2952                 }
2953         }
2954
2955         $contenu = str_replace(
2956                 array('right', 'left', '@@@@L E F T@@@@'),
2957                 array('@@@@L E F T@@@@', 'right', 'left'),
2958                 $contenu);
2959
2960         // reperer les @import auxquels il faut propager le direction_css
2961         preg_match_all(",\@import\s*url\s*\(\s*['\"]?([^'\"/][^:]*)['\"]?\s*\),Uims", $contenu, $regs);
2962         $src = array();
2963         $src_direction_css = array();
2964         $src_faux_abs = array();
2965         $d = dirname($css);
2966         foreach ($regs[1] as $k => $import_css) {
2967                 $css_direction = direction_css("$d/$import_css", $voulue);
2968                 // si la css_direction est dans le meme path que la css d'origine, on tronque le path, elle sera passee en absolue
2969                 if (substr($css_direction, 0, strlen($d) + 1) == "$d/") {
2970                         $css_direction = substr($css_direction, strlen($d) + 1);
2971                 } // si la css_direction commence par $dir_var on la fait passer pour une absolue
2972                 elseif (substr($css_direction, 0, strlen($dir_var)) == $dir_var) {
2973                         $css_direction = substr($css_direction, strlen($dir_var));
2974                         $src_faux_abs["/@@@@@@/" . $css_direction] = $css_direction;
2975                         $css_direction = "/@@@@@@/" . $css_direction;
2976                 }
2977                 $src[] = $regs[0][$k];
2978                 $src_direction_css[] = str_replace($import_css, $css_direction, $regs[0][$k]);
2979         }
2980         $contenu = str_replace($src, $src_direction_css, $contenu);
2981
2982         $contenu = urls_absolues_css($contenu, $css);
2983
2984         // virer les fausses url absolues que l'on a mis dans les import
2985         if (count($src_faux_abs)) {
2986                 $contenu = str_replace(array_keys($src_faux_abs), $src_faux_abs, $contenu);
2987         }
2988
2989         if (!ecrire_fichier($f, $contenu)) {
2990                 return $css;
2991         }
2992
2993         return $f;
2994 }
2995
2996
2997 /**
2998  * Transforme les urls relatives d'un fichier CSS en absolues
2999  *
3000  * Récupère le chemin d'une css existante et crée (ou recrée) dans `_DIR_VAR/cache_css/`
3001  * une css dont les url relatives sont passées en url absolues
3002  *
3003  * Le calcul n'est pas refait si le fichier cache existe déjà et que
3004  * la source n'a pas été modifiée depuis.
3005  *
3006  * @uses recuperer_page() si l'URL source n'est pas sur le même site
3007  * @uses urls_absolues_css()
3008  *
3009  * @param string $css
3010  *     Chemin ou URL du fichier CSS source
3011  * @return string
3012  *     - Chemin du fichier CSS transformé (si source lisible et mise en cache réussie)
3013  *     - Chemin ou URL du fichier CSS source sinon.
3014  **/
3015 function url_absolue_css($css) {
3016         if (!preg_match(',\.css$,i', $css, $r)) {
3017                 return $css;
3018         }
3019
3020         $url_absolue_css = url_absolue($css);
3021
3022         $f = basename($css, '.css');
3023         $f = sous_repertoire(_DIR_VAR, 'cache-css')
3024                 . preg_replace(",(.*?)(_rtl|_ltr)?$,", "\\1-urlabs-" . substr(md5("$css-urlabs"), 0, 4) . "\\2", $f)
3025                 . '.css';
3026
3027         if ((@filemtime($f) > @filemtime($css)) and (_VAR_MODE != 'recalcul')) {
3028                 return $f;
3029         }
3030
3031         if ($url_absolue_css == $css) {
3032                 if (strncmp($GLOBALS['meta']['adresse_site'], $css, $l = strlen($GLOBALS['meta']['adresse_site'])) != 0
3033                         or !lire_fichier(_DIR_RACINE . substr($css, $l), $contenu)
3034                 ) {
3035                         include_spip('inc/distant');
3036                         if (!$contenu = recuperer_page($css)) {
3037                                 return $css;
3038                         }
3039                 }
3040         } elseif (!lire_fichier($css, $contenu)) {
3041                 return $css;
3042         }
3043
3044         // passer les url relatives a la css d'origine en url absolues
3045         $contenu = urls_absolues_css($contenu, $css);
3046
3047         // ecrire la css
3048         if (!ecrire_fichier($f, $contenu)) {
3049                 return $css;
3050         }
3051
3052         return $f;
3053 }
3054
3055
3056 /**
3057  * Récupère la valeur d'une clé donnée
3058  * dans un tableau (ou un objet).
3059  *
3060  * @filtre
3061  * @link http://www.spip.net/4572
3062  * @example
3063  *     ```
3064  *     [(#VALEUR|table_valeur{cle/sous/element})]
3065  *     ```
3066  *
3067  * @param mixed $table
3068  *     Tableau ou objet PHP
3069  *     (ou chaîne serialisée de tableau, ce qui permet d'enchaîner le filtre)
3070  * @param string $cle
3071  *     Clé du tableau (ou paramètre public de l'objet)
3072  *     Cette clé peut contenir des caractères / pour sélectionner
3073  *     des sous éléments dans le tableau, tel que `sous/element/ici`
3074  *     pour obtenir la valeur de `$tableau['sous']['element']['ici']`
3075  * @param mixed $defaut
3076  *     Valeur par defaut retournée si la clé demandée n'existe pas
3077  * @param bool  $conserver_null
3078  *     Permet de forcer la fonction à renvoyer la valeur null d'un index
3079  *     et non pas $defaut comme cela est fait naturellement par la fonction
3080  *     isset. On utilise alors array_key_exists() à la place de isset().
3081  *
3082  * @return mixed
3083  *     Valeur trouvée ou valeur par défaut.
3084  **/
3085 function table_valeur($table, $cle, $defaut = '', $conserver_null = false) {
3086         foreach (explode('/', $cle) as $k) {
3087
3088                 $table = is_string($table) ? @unserialize($table) : $table;
3089
3090                 if (is_object($table)) {
3091                         $table = (($k !== "") and isset($table->$k)) ? $table->$k : $defaut;
3092                 } elseif (is_array($table)) {
3093                         if ($conserver_null) {
3094                                 $table = array_key_exists($k, $table) ? $table[$k] : $defaut;
3095                         } else {
3096                                 $table = isset($table[$k]) ? $table[$k] : $defaut;
3097                         }
3098                 } else {
3099                         $table = $defaut;
3100                 }
3101         }
3102
3103         return $table;
3104 }
3105
3106 /**
3107  * Retrouve un motif dans un texte à partir d'une expression régulière
3108  *
3109  * S'appuie sur la fonction `preg_match()` en PHP
3110  *
3111  * @example
3112  *    - `[(#TITRE|match{toto})]`
3113  *    - `[(#TEXTE|match{^ceci$,Uims})]`
3114  *    - `[(#TEXTE|match{truc(...)$, UimsS, 1})]` Capture de la parenthèse indiquée
3115  *    - `[(#TEXTE|match{truc(...)$, 1})]` Équivalent, sans indiquer les modificateurs
3116  *
3117  * @filtre
3118  * @link http://www.spip.net/4299
3119  * @link http://php.net/manual/fr/function.preg-match.php Pour des infos sur `preg_match()`
3120  *
3121  * @param string $texte
3122  *     Texte dans lequel chercher
3123  * @param string|int $expression
3124  *     Expression régulière de recherche, sans le délimiteur
3125  * @param string $modif
3126  *     - string : Modificateurs de l'expression régulière
3127  *     - int : Numéro de parenthèse capturante
3128  * @param int $capte
3129  *     Numéro de parenthèse capturante
3130  * @return bool|string
3131  *     - false : l'expression n'a pas été trouvée
3132  *     - true : expression trouvée, mais pas la parenthèse capturante
3133  *     - string : expression trouvée.
3134  **/
3135 function match($texte, $expression, $modif = "UimsS", $capte = 0) {
3136         if (intval($modif) and $capte == 0) {
3137                 $capte = $modif;
3138                 $modif = "UimsS";
3139         }
3140         $expression = str_replace("\/", "/", $expression);
3141         $expression = str_replace("/", "\/", $expression);
3142
3143         if (preg_match('/' . $expression . '/' . $modif, $texte, $r)) {
3144                 if (isset($r[$capte])) {
3145                         return $r[$capte];
3146                 } else {
3147                         return true;
3148                 }
3149         }
3150
3151         return false;
3152 }
3153
3154
3155 /**
3156  * Remplacement de texte à base d'expression régulière
3157  *
3158  * @filtre
3159  * @link http://www.spip.net/4309
3160  * @see match()
3161  * @example
3162  *     ```
3163  *     [(#TEXTE|replace{^ceci$,cela,UimsS})]
3164  *     ```
3165  *
3166  * @param string $texte
3167  *     Texte
3168  * @param string $expression
3169  *     Expression régulière
3170  * @param string $replace
3171  *     Texte de substitution des éléments trouvés
3172  * @param string $modif
3173  *     Modificateurs pour l'expression régulière.
3174  * @return string
3175  *     Texte
3176  **/
3177 function replace($texte, $expression, $replace = '', $modif = "UimsS") {
3178         $expression = str_replace("\/", "/", $expression);
3179         $expression = str_replace("/", "\/", $expression);
3180
3181         return preg_replace('/' . $expression . '/' . $modif, $replace, $texte);
3182 }
3183
3184
3185 /**
3186  * Cherche les documents numerotés dans un texte traite par `propre()`
3187  *
3188  * Affecte la liste des doublons['documents']
3189  *
3190  * @param array $doublons
3191  *     Liste des doublons
3192  * @param string $letexte
3193  *     Le texte
3194  * @return string
3195  *     Le texte
3196  **/
3197 function traiter_doublons_documents(&$doublons, $letexte) {
3198
3199         // Verifier dans le texte & les notes (pas beau, helas)
3200         $t = $letexte . $GLOBALS['les_notes'];
3201
3202         if (strstr($t, 'spip_document_') // evite le preg_match_all si inutile
3203                 and preg_match_all(
3204                         ',<[^>]+\sclass=["\']spip_document_([0-9]+)[\s"\'],imsS',
3205                         $t, $matches, PREG_PATTERN_ORDER)
3206         ) {
3207                 if (!isset($doublons['documents'])) {
3208                         $doublons['documents'] = "";
3209                 }
3210                 $doublons['documents'] .= "," . join(',', $matches[1]);
3211         }
3212
3213         return $letexte;
3214 }
3215
3216 /**
3217  * Filtre vide qui ne renvoie rien
3218  *
3219  * @example
3220  *     `[(#CALCUL|vide)]` n'affichera pas le résultat du calcul
3221  * @filtre
3222  *
3223  * @param mixed $texte
3224  * @return string Chaîne vide
3225  **/
3226 function vide($texte) {
3227         return "";
3228 }
3229
3230 //
3231 // Filtres pour le modele/emb (embed document)
3232 //
3233
3234 /**
3235  * Écrit des balises HTML `<param...>` à partir d'un tableau de données tel que `#ENV`
3236  *
3237  * Permet d'écrire les balises `<param>` à indiquer dans un `<object>`
3238  * en prenant toutes les valeurs du tableau transmis.
3239  *
3240  * Certaines clés spécifiques à SPIP et aux modèles embed sont omises :
3241  * id, lang, id_document, date, date_redac, align, fond, recurs, emb, dir_racine
3242  *
3243  * @example `[(#ENV*|env_to_params)]`
3244  *
3245  * @filtre
3246  * @link http://www.spip.net/4005
3247  *
3248  * @param array|string $env
3249  *      Tableau cle => valeur des paramètres à écrire, ou chaine sérialisée de ce tableau
3250  * @param array $ignore_params
3251  *      Permet de compléter les clés ignorées du tableau.
3252  * @return string
3253  *      Code HTML résultant
3254  **/
3255 function env_to_params($env, $ignore_params = array()) {
3256         $ignore_params = array_merge(
3257                 array('id', 'lang', 'id_document', 'date', 'date_redac', 'align', 'fond', '', 'recurs', 'emb', 'dir_racine'),
3258                 $ignore_params
3259         );
3260         if (!is_array($env)) {
3261                 $env = unserialize($env);
3262         }
3263         $texte = "";
3264         if ($env) {
3265                 foreach ($env as $i => $j) {
3266                         if (is_string($j) and !in_array($i, $ignore_params)) {
3267                                 $texte .= "<param name='" . attribut_html($i) . "'\n\tvalue='" . attribut_html($j) . "' />";
3268                         }
3269                 }
3270         }
3271
3272         return $texte;
3273 }
3274
3275 /**
3276  * Écrit des attributs HTML à partir d'un tableau de données tel que `#ENV`
3277  *
3278  * Permet d'écrire des attributs d'une balise HTML en utilisant les données du tableau transmis.
3279  * Chaque clé deviendra le nom de l'attribut (et la valeur, sa valeur)
3280  *
3281  * Certaines clés spécifiques à SPIP et aux modèles embed sont omises :
3282  * id, lang, id_document, date, date_redac, align, fond, recurs, emb, dir_racine
3283  *
3284  * @example `<embed src='#URL_DOCUMENT' [(#ENV*|env_to_attributs)] width='#GET{largeur}' height='#GET{hauteur}'></embed>`
3285  * @filtre
3286  *
3287  * @param array|string $env
3288  *      Tableau cle => valeur des attributs à écrire, ou chaine sérialisée de ce tableau
3289  * @param array $ignore_params
3290  *      Permet de compléter les clés ignorées du tableau.
3291  * @return string
3292  *      Code HTML résultant
3293  **/
3294 function env_to_attributs($env, $ignore_params = array()) {
3295         $ignore_params = array_merge(
3296                 array('id', 'lang', 'id_document', 'date', 'date_redac', 'align', 'fond', '', 'recurs', 'emb', 'dir_racine'),
3297                 $ignore_params
3298         );
3299         if (!is_array($env)) {
3300                 $env = unserialize($env);
3301         }
3302         $texte = "";
3303         if ($env) {
3304                 foreach ($env as $i => $j) {
3305                         if (is_string($j) and !in_array($i, $ignore_params)) {
3306                                 $texte .= attribut_html($i) . "='" . attribut_html($j) . "' ";
3307                         }
3308                 }
3309         }
3310
3311         return $texte;
3312 }
3313
3314
3315 /**
3316  * Concatène des chaînes
3317  *
3318  * @filtre
3319  * @link http://www.spip.net/4150
3320  * @example
3321  *     ```
3322  *     #TEXTE|concat{texte1,texte2,...}
3323  *     ```
3324  *
3325  * @return string Chaînes concaténés
3326  **/
3327 function concat() {
3328         $args = func_get_args();
3329
3330         return join('', $args);
3331 }
3332
3333
3334 /**
3335  * Retourne le contenu d'un ou plusieurs fichiers
3336  *
3337  * Les chemins sont cherchés dans le path de SPIP
3338  *
3339  * @see balise_INCLURE_dist() La balise `#INCLURE` peut appeler cette fonction
3340  *
3341  * @param array|string $files
3342  *     - array : Liste de fichiers
3343  *     - string : fichier ou fichiers séparés par `|`
3344  * @param bool $script
3345  *     - si true, considère que c'est un fichier js à chercher `javascript/`
3346  * @return string
3347  *     Contenu du ou des fichiers, concaténé
3348  **/
3349 function charge_scripts($files, $script = true) {
3350         $flux = "";
3351         foreach (is_array($files) ? $files : explode("|", $files) as $file) {
3352                 if (!is_string($file)) {
3353                         continue;
3354                 }
3355                 if ($script) {
3356                         $file = preg_match(",^\w+$,", $file) ? "javascript/$file.js" : '';
3357                 }
3358                 if ($file) {
3359                         $path = find_in_path($file);
3360                         if ($path) {
3361                                 $flux .= spip_file_get_contents($path);
3362                         }
3363                 }
3364         }
3365
3366         return $flux;
3367 }
3368
3369
3370 /**
3371  * Produit une balise img avec un champ alt d'office si vide
3372  *
3373  * Attention le htmlentities et la traduction doivent être appliqués avant.
3374  *
3375  * @param string $img
3376  * @param string $alt
3377  * @param string $atts
3378  * @param string $title
3379  * @param array $options
3380  *   chemin_image : utiliser chemin_image sur $img fourni, ou non (oui par dafaut)
3381  *   utiliser_suffixe_size : utiliser ou non le suffixe de taille dans le nom de fichier de l'image
3382  *   sous forme -xx.png (pour les icones essentiellement) (oui par defaut)
3383  * @return string
3384  */
3385 function http_img_pack($img, $alt, $atts = '', $title = '', $options = array()) {
3386         if (!isset($options['chemin_image']) or $options['chemin_image'] == true) {
3387                 $img = chemin_image($img);
3388         }
3389         if (stripos($atts, 'width') === false && !preg_match(',\.svg$,', $img)) {
3390                 // utiliser directement l'info de taille presente dans le nom
3391                 if ((!isset($options['utiliser_suffixe_size']) or $options['utiliser_suffixe_size'] == true)
3392                         and preg_match(',-([0-9]+)[.](png|gif)$,', $img, $regs)
3393                 ) {
3394                         $largeur = $hauteur = intval($regs[1]);
3395                 } else {
3396                         $taille = taille_image($img);
3397                         list($hauteur, $largeur) = $taille;
3398                         if (!$hauteur or !$largeur) {
3399                                 return "";
3400                         }
3401                 }
3402                 $atts .= " width='" . $largeur . "' height='" . $hauteur . "'";
3403         }
3404
3405         return "<img src='$img' alt='" . attribut_html($alt ? $alt : $title) . "'"
3406         . ($title ? ' title="' . attribut_html($title) . '"' : '')
3407         . " " . ltrim($atts)
3408         . " />";
3409 }
3410
3411 /**
3412  * Générer une directive `style='background:url()'` à partir d'un fichier image
3413  *
3414  * @param string $img
3415  * @param string $att
3416  * @return string
3417  */
3418 function http_style_background($img, $att = '') {
3419         return " style='background" . ($att ? "" : "-image") . ": url(\"" . chemin_image($img) . "\")" . ($att ? (' ' . $att) : '') . ";'";
3420 }
3421
3422 /**
3423  * Générer une balise HTML `img` à partir d'un nom de fichier
3424  *
3425  * @uses http_img_pack()
3426  *
3427  * @param string $img
3428  * @param string $alt
3429  * @param string $class
3430  * @return string
3431  *     Code HTML de la balise IMG
3432  */
3433 function filtre_balise_img_dist($img, $alt = "", $class = "") {
3434         return http_img_pack($img, $alt, $class ? " class='" . attribut_html($class) . "'" : '', '',
3435                 array('chemin_image' => false, 'utiliser_suffixe_size' => false));
3436 }
3437
3438
3439 /**
3440  * Inserer un svg inline
3441  * http://www.accede-web.com/notices/html-css-javascript/6-images-icones/6-2-svg-images-vectorielles/
3442  *
3443  * pour l'inserer avec une balise <img>, utiliser le filtre |balise_img
3444  *
3445  * @param string $img
3446  * @param string $alt
3447  * @param string $class
3448  * @return string
3449  */
3450 function filtre_balise_svg_dist($img, $alt = "", $class = "") {
3451         if (!$file = find_in_path($img)
3452           or !$svg = file_get_contents($file)) {
3453                 return '';
3454         }
3455
3456         if (!preg_match(",<svg\b[^>]*>,UimsS", $svg, $match)) {
3457                 return '';
3458         }
3459         $balise_svg = $match[0];
3460         $balise_svg_source = $balise_svg;
3461
3462         // entete XML à supprimer
3463         $svg = preg_replace(',^\s*<\?xml[^>]*\?' . '>,', '', $svg);
3464
3465         // IE est toujours mon ami
3466         $balise_svg = inserer_attribut($balise_svg, 'focusable', 'false');
3467         if ($class) {
3468                 $balise_svg = inserer_attribut($balise_svg, 'class', $class);
3469         }
3470         if ($alt){
3471                 $balise_svg = inserer_attribut($balise_svg, 'role', 'img');
3472                 $id = "img-svg-title-" . substr(md5("$file:$svg:$alt"),0,4);
3473                 $balise_svg = inserer_attribut($balise_svg, 'aria-labelledby', $id);
3474                 $title = "<title id=\"$id\">" . entites_html($alt)."</title>\n";
3475                 $balise_svg .= $title;
3476         }
3477         else {
3478                 $balise_svg = inserer_attribut($balise_svg, 'aria-hidden', 'true');
3479         }
3480         $svg = str_replace($balise_svg_source, $balise_svg, $svg);
3481
3482         return $svg;
3483 }
3484
3485
3486
3487 /**
3488  * Affiche chaque valeur d'un tableau associatif en utilisant un modèle
3489  *
3490  * @example
3491  *     - `[(#ENV*|unserialize|foreach)]`
3492  *     - `[(#ARRAY{a,un,b,deux}|foreach)]`
3493  *
3494  * @filtre
3495  * @link http://www.spip.net/4248
3496  *
3497  * @param array $tableau
3498  *     Tableau de données à afficher
3499  * @param string $modele
3500  *     Nom du modèle à utiliser
3501  * @return string
3502  *     Code HTML résultant
3503  **/
3504 function filtre_foreach_dist($tableau, $modele = 'foreach') {
3505         $texte = '';
3506         if (is_array($tableau)) {
3507                 foreach ($tableau as $k => $v) {
3508                         $res = recuperer_fond('modeles/' . $modele,
3509                                 array_merge(array('cle' => $k), (is_array($v) ? $v : array('valeur' => $v)))
3510                         );
3511                         $texte .= $res;
3512                 }
3513         }
3514
3515         return $texte;
3516 }
3517
3518
3519 /**
3520  * Obtient des informations sur les plugins actifs
3521  *
3522  * @filtre
3523  * @uses liste_plugin_actifs() pour connaître les informations affichables
3524  *
3525  * @param string $plugin
3526  *     Préfixe du plugin ou chaîne vide
3527  * @param string $type_info
3528  *     Type d'info demandée
3529  * @param bool $reload
3530  *     true (à éviter) pour forcer le recalcul du cache des informations des plugins.
3531  * @return array|string|bool
3532  *
3533  *     - Liste sérialisée des préfixes de plugins actifs (si $plugin = '')
3534  *     - Suivant $type_info, avec $plugin un préfixe
3535  *         - est_actif : renvoie true s'il est actif, false sinon
3536  *         - x : retourne l'information x du plugin si présente (et plugin actif)
3537  *         - tout : retourne toutes les informations du plugin actif
3538  **/
3539 function filtre_info_plugin_dist($plugin, $type_info, $reload = false) {
3540         include_spip('inc/plugin');
3541         $plugin = strtoupper($plugin);
3542         $plugins_actifs = liste_plugin_actifs();
3543
3544         if (!$plugin) {
3545                 return serialize(array_keys($plugins_actifs));
3546         } elseif (empty($plugins_actifs[$plugin]) and !$reload) {
3547                 return '';
3548         } elseif (($type_info == 'est_actif') and !$reload) {
3549                 return $plugins_actifs[$plugin] ? 1 : 0;
3550         } elseif (isset($plugins_actifs[$plugin][$type_info]) and !$reload) {
3551                 return $plugins_actifs[$plugin][$type_info];
3552         } else {
3553                 $get_infos = charger_fonction('get_infos', 'plugins');
3554                 // On prend en compte les extensions
3555                 if (!is_dir($plugins_actifs[$plugin]['dir_type'])) {
3556                         $dir_plugins = constant($plugins_actifs[$plugin]['dir_type']);
3557                 } else {
3558                         $dir_plugins = $plugins_actifs[$plugin]['dir_type'];
3559                 }
3560                 if (!$infos = $get_infos($plugins_actifs[$plugin]['dir'], $reload, $dir_plugins)) {
3561                         return '';
3562                 }
3563                 if ($type_info == 'tout') {
3564                         return $infos;
3565                 } elseif ($type_info == 'est_actif') {
3566                         return $infos ? 1 : 0;
3567                 } else {
3568                         return strval($infos[$type_info]);
3569                 }
3570         }
3571 }
3572
3573
3574 /**
3575  * Affiche la puce statut d'un objet, avec un menu rapide pour changer
3576  * de statut si possibilité de l'avoir
3577  *
3578  * @see inc_puce_statut_dist()
3579  *
3580  * @filtre
3581  *
3582  * @param int $id_objet
3583  *     Identifiant de l'objet
3584  * @param string $statut
3585  *     Statut actuel de l'objet
3586  * @param int $id_rubrique
3587  *     Identifiant du parent
3588  * @param string $type
3589  *     Type d'objet
3590  * @param bool $ajax
3591  *     Indique s'il ne faut renvoyer que le coeur du menu car on est
3592  *     dans une requete ajax suite à un post de changement rapide
3593  * @return string
3594  *     Code HTML de l'image de puce de statut à insérer (et du menu de changement si présent)
3595  */
3596 function puce_changement_statut($id_objet, $statut, $id_rubrique, $type, $ajax = false) {
3597         $puce_statut = charger_fonction('puce_statut', 'inc');
3598
3599         return $puce_statut($id_objet, $statut, $id_rubrique, $type, $ajax);
3600 }
3601
3602
3603 /**
3604  * Affiche la puce statut d'un objet, avec un menu rapide pour changer
3605  * de statut si possibilité de l'avoir
3606  *
3607  * Utilisable sur tout objet qui a declaré ses statuts
3608  *
3609  * @example
3610  *     [(#STATUT|puce_statut{article})] affiche une puce passive
3611  *     [(#STATUT|puce_statut{article,#ID_ARTICLE,#ID_RUBRIQUE})] affiche une puce avec changement rapide
3612  *
3613  * @see inc_puce_statut_dist()
3614  *
3615  * @filtre
3616  *
3617  * @param string $statut
3618  *     Statut actuel de l'objet
3619  * @param string $objet
3620  *     Type d'objet
3621  * @param int $id_objet
3622  *     Identifiant de l'objet
3623  * @param int $id_parent
3624  *     Identifiant du parent
3625  * @return string
3626  *     Code HTML de l'image de puce de statut à insérer (et du menu de changement si présent)
3627  */
3628 function filtre_puce_statut_dist($statut, $objet, $id_objet = 0, $id_parent = 0) {
3629         static $puce_statut = null;
3630         if (!$puce_statut) {
3631                 $puce_statut = charger_fonction('puce_statut', 'inc');
3632         }
3633
3634         return $puce_statut($id_objet, $statut, $id_parent, $objet, false,
3635                 objet_info($objet, 'editable') ? _ACTIVER_PUCE_RAPIDE : false);
3636 }
3637
3638
3639 /**
3640  * Encoder un contexte pour l'ajax
3641  *
3642  * Encoder le contexte, le signer avec une clé, le crypter
3643  * avec le secret du site, le gziper si possible.
3644  *
3645  * L'entrée peut-être sérialisée (le `#ENV**` des fonds ajax et ajax_stat)
3646  *
3647  * @see  decoder_contexte_ajax()
3648  * @uses calculer_cle_action()
3649  *
3650  * @param string|array $c
3651  *   contexte, peut etre un tableau serialize
3652  * @param string $form
3653  *   nom du formulaire eventuel
3654  * @param string $emboite
3655  *   contenu a emboiter dans le conteneur ajax
3656  * @param string $ajaxid
3657  *   ajaxid pour cibler le bloc et forcer sa mise a jour
3658  * @return string
3659  *   hash du contexte
3660  */
3661 function encoder_contexte_ajax($c, $form = '', $emboite = null, $ajaxid = '') {
3662         if (is_string($c)
3663                 and @unserialize($c) !== false
3664         ) {
3665                 $c = unserialize($c);
3666         }
3667
3668         // supprimer les parametres debut_x
3669         // pour que la pagination ajax ne soit pas plantee
3670         // si on charge la page &debut_x=1 : car alors en cliquant sur l'item 0,
3671         // le debut_x=0 n'existe pas, et on resterait sur 1
3672         if (is_array($c)) {
3673                 foreach ($c as $k => $v) {
3674                         if (strpos($k, 'debut_') === 0) {
3675                                 unset($c[$k]);
3676                         }
3677                 }
3678         }
3679
3680         if (!function_exists('calculer_cle_action')) {
3681                 include_spip("inc/securiser_action");
3682         }
3683
3684         $c = serialize($c);
3685         $cle = calculer_cle_action($form . $c);
3686         $c = "$cle:$c";
3687
3688         // on ne stocke pas les contextes dans des fichiers en cache
3689         // par defaut, sauf si cette configuration a été forcée
3690         // OU que la longueur de l’argument géneré est plus long
3691         // que ce qui est toléré.
3692         $cache_contextes_ajax = (defined('_CACHE_CONTEXTES_AJAX') and _CACHE_CONTEXTES_AJAX);
3693         if (!$cache_contextes_ajax) {
3694                 $env = $c;
3695                 if (function_exists('gzdeflate') && function_exists('gzinflate')) {
3696                         $env = gzdeflate($env);
3697                         // http://core.spip.net/issues/2667 | https://bugs.php.net/bug.php?id=61287
3698                         if ((PHP_VERSION_ID == 50400) and !@gzinflate($env)) {
3699                                 $cache_contextes_ajax = true;
3700                                 spip_log("Contextes AJAX forces en fichiers ! Erreur PHP 5.4.0", _LOG_AVERTISSEMENT);
3701                         }
3702                 }
3703                 $env = _xor($env);
3704                 $env = base64_encode($env);
3705                 $len = strlen($env);
3706                 // Si l’url est trop longue pour le navigateur
3707                 $max_len = _CACHE_CONTEXTES_AJAX_SUR_LONGUEUR;
3708                 if ($len > $max_len) {
3709                         $cache_contextes_ajax = true;
3710                         spip_log("Contextes AJAX forces en fichiers !"
3711                                 . " Cela arrive lorsque la valeur du contexte"
3712                                 . " depasse la longueur maximale autorisee ($max_len). Ici : $len."
3713                                 , _LOG_AVERTISSEMENT);
3714                 }
3715                 // Sinon si Suhosin est actif et a une la valeur maximale des variables en GET...
3716                 elseif (
3717                         $max_len = @ini_get('suhosin.get.max_value_length')
3718                         and $max_len < $len
3719                 ) {
3720                         $cache_contextes_ajax = true;
3721                         spip_log("Contextes AJAX forces en fichiers !"
3722                                 . " Cela arrive lorsque la valeur du contexte"
3723                                 . " depasse la longueur maximale autorisee par Suhosin"
3724                                 . " ($max_len) dans 'suhosin.get.max_value_length'. Ici : $len."
3725                                 . " Vous devriez modifier les parametres de Suhosin"
3726                                 . " pour accepter au moins 1024 caracteres.", _LOG_AVERTISSEMENT);
3727                 }
3728
3729         }
3730
3731         if ($cache_contextes_ajax) {
3732                 $dir = sous_repertoire(_DIR_CACHE, 'contextes');
3733                 // stocker les contextes sur disque et ne passer qu'un hash dans l'url
3734                 $md5 = md5($c);
3735                 ecrire_fichier("$dir/c$md5", $c);
3736                 $env = $md5;
3737         }
3738
3739         if ($emboite === null) {
3740                 return $env;
3741         }
3742         if (!trim($emboite)) {
3743                 return "";
3744         }
3745         // toujours encoder l'url source dans le bloc ajax
3746         $r = self();
3747         $r = ' data-origin="' . $r . '"';
3748         $class = 'ajaxbloc';
3749         if ($ajaxid and is_string($ajaxid)) {
3750                 // ajaxid est normalement conforme a un nom de classe css
3751                 // on ne verifie pas la conformite, mais on passe entites_html par dessus par precaution
3752                 $class .= ' ajax-id-' . entites_html($ajaxid);
3753         }
3754
3755         return "<div class='$class' " . "data-ajax-env='$env'$r>\n$emboite</div><!--ajaxbloc-->\n";
3756 }
3757
3758 /**
3759  * Décoder un hash de contexte pour l'ajax
3760  *
3761  * Précude inverse de `encoder_contexte_ajax()`
3762  *
3763  * @see  encoder_contexte_ajax()
3764  * @uses calculer_cle_action()
3765  *
3766  * @param string $c
3767  *   hash du contexte
3768  * @param string $form
3769  *   nom du formulaire eventuel
3770  * @return array|string|bool
3771  *   - array|string : contexte d'environnement, possiblement sérialisé
3772  *   - false : erreur de décodage
3773  */
3774 function decoder_contexte_ajax($c, $form = '') {
3775         if (!function_exists('calculer_cle_action')) {
3776                 include_spip("inc/securiser_action");
3777         }
3778         if (((defined('_CACHE_CONTEXTES_AJAX') and _CACHE_CONTEXTES_AJAX) or strlen($c) == 32)
3779                 and $dir = sous_repertoire(_DIR_CACHE, 'contextes')
3780                 and lire_fichier("$dir/c$c", $contexte)
3781         ) {
3782                 $c = $contexte;
3783         } else {
3784                 $c = @base64_decode($c);
3785                 $c = _xor($c);
3786                 if (function_exists('gzdeflate') && function_exists('gzinflate')) {
3787                         $c = @gzinflate($c);
3788                 }
3789         }
3790
3791         // extraire la signature en debut de contexte
3792         // et la verifier avant de deserializer
3793         // format : signature:donneesserializees
3794         if ($p = strpos($c,":")){
3795                 $cle = substr($c,0,$p);
3796                 $c = substr($c,$p+1);
3797
3798                 if ($cle == calculer_cle_action($form . $c)) {
3799                         $env = @unserialize($c);
3800                         return $env;
3801                 }
3802         }
3803
3804         return false;
3805 }
3806
3807
3808 /**
3809  * Encrypte ou décrypte un message
3810  *
3811  * @link http://www.php.net/manual/fr/language.operators.bitwise.php#81358
3812  *
3813  * @param string $message
3814  *    Message à encrypter ou décrypter
3815  * @param null|string $key
3816  *    Clé de cryptage / décryptage.
3817  *    Une clé sera calculée si non transmise
3818  * @return string
3819  *    Message décrypté ou encrypté
3820  **/
3821 function _xor($message, $key = null) {
3822         if (is_null($key)) {
3823                 if (!function_exists('calculer_cle_action')) {
3824                         include_spip("inc/securiser_action");
3825                 }
3826                 $key = pack("H*", calculer_cle_action('_xor'));
3827         }
3828
3829         $keylen = strlen($key);
3830         $messagelen = strlen($message);
3831         for ($i = 0; $i < $messagelen; $i++) {
3832                 $message[$i] = ~($message[$i] ^ $key[$i % $keylen]);
3833         }
3834
3835         return $message;
3836 }
3837
3838 /**
3839  * Retourne une URL de réponse de forum (aucune action ici)
3840  *
3841  * @see filtre_url_reponse_forum() du plugin forum (prioritaire)
3842  * @note
3843  *   La vraie fonction est dans le plugin forum,
3844  *   mais on évite ici une erreur du compilateur en absence du plugin
3845  * @param string $texte
3846  * @return string
3847  */
3848 function url_reponse_forum($texte) { return $texte; }
3849
3850 /**
3851  * retourne une URL de suivi rss d'un forum (aucune action ici)
3852  *
3853  * @see filtre_url_rss_forum() du plugin forum (prioritaire)
3854  * @note
3855  *   La vraie fonction est dans le plugin forum,
3856  *   mais on évite ici une erreur du compilateur en absence du plugin
3857  * @param string $texte
3858  * @return string
3859  */
3860 function url_rss_forum($texte) { return $texte; }
3861
3862
3863 /**
3864  * Génère des menus avec liens ou `<strong class='on'>` non clicable lorsque
3865  * l'item est sélectionné
3866  *
3867  * @filtre
3868  * @link http://www.spip.net/4004
3869  * @example
3870  *   ```
3871  *   [(#URL_RUBRIQUE|lien_ou_expose{#TITRE, #ENV{test}|=={en_cours}})]
3872  *   ```
3873  *
3874  * @param string $url
3875  *   URL du lien
3876  * @param string $libelle
3877  *   Texte du lien
3878  * @param bool $on
3879  *   État exposé (génère un strong) ou non (génère un lien)
3880  * @param string $class
3881  *   Classes CSS ajoutées au lien
3882  * @param string $title
3883  *   Title ajouté au lien
3884  * @param string $rel
3885  *   Attribut `rel` ajouté au lien
3886  * @param string $evt
3887  *   Complement à la balise `a` pour gérer un événement javascript,
3888  *   de la forme ` onclick='...'`
3889  * @return string
3890  *   Code HTML
3891  */
3892 function lien_ou_expose($url, $libelle = null, $on = false, $class = "", $title = "", $rel = "", $evt = '') {
3893         if ($on) {
3894                 $bal = "strong";
3895                 $att = "class='on'";
3896         } else {
3897                 $bal = 'a';
3898                 $att = "href='$url'"
3899                         . ($title ? " title='" . attribut_html($title) . "'" : '')
3900                         . ($class ? " class='" . attribut_html($class) . "'" : '')
3901                         . ($rel ? " rel='" . attribut_html($rel) . "'" : '')
3902                         . $evt;
3903         }
3904         if ($libelle === null) {
3905                 $libelle = $url;
3906         }
3907
3908         return "<$bal $att>$libelle</$bal>";
3909 }
3910
3911
3912 /**
3913  * Afficher un message "un truc"/"N trucs"
3914  * Les items sont à indiquer comme pour la fonction _T() sous la forme :
3915  * "module:chaine"
3916  *
3917  * @param int $nb : le nombre
3918  * @param string $chaine_un : l'item de langue si $nb vaut un
3919  * @param string $chaine_plusieurs : l'item de lanque si $nb >= 2
3920  * @param string $var : La variable à remplacer par $nb dans l'item de langue (facultatif, défaut "nb")
3921  * @param array $vars : Les autres variables nécessaires aux chaines de langues (facultatif)
3922  * @return string : la chaine de langue finale en utilisant la fonction _T()
3923  */
3924 function singulier_ou_pluriel($nb, $chaine_un, $chaine_plusieurs, $var = 'nb', $vars = array()) {
3925         if (!is_numeric($nb) or $nb == 0) {
3926                 return "";
3927         }
3928         if (!is_array($vars)) {
3929                 return "";
3930         }
3931         $vars[$var] = $nb;
3932         if ($nb >= 2) {
3933                 return _T($chaine_plusieurs, $vars);
3934         } else {
3935                 return _T($chaine_un, $vars);
3936         }
3937 }
3938
3939
3940 /**
3941  * Fonction de base pour une icone dans un squelette
3942  * structure html : `<span><a><img><b>texte</b></span>`
3943  *
3944  * @param string $type
3945  *  'lien' ou 'bouton'
3946  * @param string $lien
3947  *  url
3948  * @param string $texte
3949  *  texte du lien / alt de l'image
3950  * @param string $fond
3951  *  objet avec ou sans son extension et sa taille (article, article-24, article-24.png)
3952  * @param string $fonction
3953  *  new/del/edit
3954  * @param string $class
3955  *  classe supplementaire (horizontale, verticale, ajax ...)
3956  * @param string $javascript
3957  *  "onclick='...'" par exemple
3958  * @return string
3959  */
3960 function prepare_icone_base($type, $lien, $texte, $fond, $fonction = "", $class = "", $javascript = "") {
3961         if (in_array($fonction, array("del", "supprimer.gif"))) {
3962                 $class .= ' danger';
3963         } elseif ($fonction == "rien.gif") {
3964                 $fonction = "";
3965         } elseif ($fonction == "delsafe") {
3966                 $fonction = "del";
3967         }
3968
3969         // remappage des icone : article-24.png+new => article-new-24.png
3970         if ($icone_renommer = charger_fonction('icone_renommer', 'inc', true)) {
3971                 list($fond, $fonction) = $icone_renommer($fond, $fonction);
3972         }
3973
3974         // ajouter le type d'objet dans la class de l'icone
3975         $class .= " " . substr(basename($fond), 0, -4);
3976
3977         $alt = attribut_html($texte);
3978         $title = " title=\"$alt\""; // est-ce pertinent de doubler le alt par un title ?
3979
3980         $ajax = "";
3981         if (strpos($class, "ajax") !== false) {
3982                 $ajax = "ajax";
3983                 if (strpos($class, "preload") !== false) {
3984                         $ajax .= " preload";
3985                 }
3986                 if (strpos($class, "nocache") !== false) {
3987                         $ajax .= " nocache";
3988                 }
3989                 $ajax = " class='$ajax'";
3990         }
3991
3992         $size = 24;
3993         if (preg_match("/-([0-9]{1,3})[.](gif|png)$/i", $fond, $match)) {
3994                 $size = $match[1];
3995         }
3996
3997         if ($fonction) {
3998                 // 2 images pour composer l'icone : le fond (article) en background,
3999                 // la fonction (new) en image
4000                 $icone = http_img_pack($fonction, $alt, "width='$size' height='$size'\n" .
4001                         http_style_background($fond));
4002         } else {
4003                 $icone = http_img_pack($fond, $alt, "width='$size' height='$size'");
4004         }
4005
4006         if ($type == 'lien') {
4007                 return "<span class='icone s$size $class'>"
4008                 . "<a href='$lien'$title$ajax$javascript>"
4009                 . $icone
4010                 . "<b>$texte</b>"
4011                 . "</a></span>\n";
4012         } else {
4013                 return bouton_action("$icone<b>$texte</b>", $lien, "icone s$size $class", $javascript, $alt);
4014         }
4015 }
4016
4017 /**
4018  * Crée un lien ayant une icone
4019  *
4020  * @uses prepare_icone_base()
4021  *
4022  * @param string $lien
4023  *     URL du lien
4024  * @param string $texte
4025  *     Texte du lien
4026  * @param string $fond
4027  *     Objet avec ou sans son extension et sa taille (article, article-24, article-24.png)
4028  * @param string $fonction
4029  *     Fonction du lien (`edit`, `new`, `del`)
4030  * @param string $class
4031  *     Classe CSS, tel que `left`, `right` pour définir un alignement
4032  * @param string $javascript
4033  *     Javascript ajouté sur le lien
4034  * @return string
4035  *     Code HTML du lien
4036  **/
4037 function icone_base($lien, $texte, $fond, $fonction = "", $class = "", $javascript = "") {
4038         return prepare_icone_base('lien', $lien, $texte, $fond, $fonction, $class, $javascript);
4039 }
4040
4041 /**
4042  * Crée un lien précédé d'une icone au dessus du texte
4043  *
4044  * @uses icone_base()
4045  * @see  icone_verticale() Pour un usage dans un code PHP.
4046  *
4047  * @filtre
4048  * @example
4049  *     ```
4050  *     [(#AUTORISER{voir,groupemots,#ID_GROUPE})
4051  *         [(#URL_ECRIRE{groupe_mots,id_groupe=#ID_GROUPE}
4052  *            |icone_verticale{<:mots:icone_voir_groupe_mots:>,groupe_mots-24.png,'',left})]
4053  *    ]
4054  *     ```
4055  *
4056  * @param string $lien
4057  *     URL du lien
4058  * @param string $texte
4059  *     Texte du lien
4060  * @param string $fond
4061  *     Objet avec ou sans son extension et sa taille (article, article-24, article-24.png)
4062  * @param string $fonction
4063  *     Fonction du lien (`edit`, `new`, `del`)
4064  * @param string $class
4065  *     Classe CSS à ajouter, tel que `left`, `right`, `center` pour définir un alignement.
4066  *     Il peut y en avoir plusieurs : `left ajax`
4067  * @param string $javascript
4068  *     Javascript ajouté sur le lien
4069  * @return string
4070  *     Code HTML du lien
4071  **/
4072 function filtre_icone_verticale_dist($lien, $texte, $fond, $fonction = "", $class = "", $javascript = "") {
4073         return icone_base($lien, $texte, $fond, $fonction, "verticale $class", $javascript);
4074 }
4075
4076 /**
4077  * Crée un lien précédé d'une icone horizontale
4078  *
4079  * @uses icone_base()
4080  * @see  icone_horizontale() Pour un usage dans un code PHP.
4081  *
4082  * @filtre
4083  * @example
4084  *     En tant que filtre dans un squelettes :
4085  *     ```
4086  *     [(#URL_ECRIRE{sites}|icone_horizontale{<:sites:icone_voir_sites_references:>,site-24.png})]
4087  *
4088  *     [(#AUTORISER{supprimer,groupemots,#ID_GROUPE}|oui)
4089  *         [(#URL_ACTION_AUTEUR{supprimer_groupe_mots,#ID_GROUPE,#URL_ECRIRE{mots}}
4090  *             |icone_horizontale{<:mots:icone_supprimer_groupe_mots:>,groupe_mots,del})]
4091  *     ]
4092  *     ```
4093  *
4094  *     En tant que filtre dans un code php :
4095  *     ```
4096  *     $icone_horizontale=chercher_filtre('icone_horizontale');
4097  *     $icone = $icone_horizontale(generer_url_ecrire("stats_visites","id_article=$id_article"),
4098  *         _T('statistiques:icone_evolution_visites', array('visites' => $visites)),
4099  *         "statistique-24.png");
4100  *     ```
4101  *
4102  * @param string $lien
4103  *     URL du lien
4104  * @param string $texte
4105  *     Texte du lien
4106  * @param string $fond
4107  *     Objet avec ou sans son extension et sa taille (article, article-24, article-24.png)
4108  * @param string $fonction
4109  *     Fonction du lien (`edit`, `new`, `del`)
4110  * @param string $class
4111  *     Classe CSS à ajouter
4112  * @param string $javascript
4113  *     Javascript ajouté sur le lien
4114  * @return string
4115  *     Code HTML du lien
4116  **/
4117 function filtre_icone_horizontale_dist($lien, $texte, $fond, $fonction = "", $class = "", $javascript = "") {
4118         return icone_base($lien, $texte, $fond, $fonction, "horizontale $class", $javascript);
4119 }
4120
4121 /**
4122  * Crée un bouton d'action intégrant une icone horizontale
4123  *
4124  * @uses prepare_icone_base()
4125  *
4126  * @filtre
4127  * @example
4128  *     ```
4129  *     [(#URL_ACTION_AUTEUR{supprimer_mot, #ID_MOT, #URL_ECRIRE{groupe_mots,id_groupe=#ID_GROUPE}}
4130  *         |bouton_action_horizontal{<:mots:info_supprimer_mot:>,mot-24.png,del})]
4131  *     ```
4132  *
4133  * @param string $lien
4134  *     URL de l'action
4135  * @param string $texte
4136  *     Texte du bouton
4137  * @param string $fond
4138  *     Objet avec ou sans son extension et sa taille (article, article-24, article-24.png)
4139  * @param string $fonction
4140  *     Fonction du bouton (`edit`, `new`, `del`)
4141  * @param string $class
4142  *     Classe CSS à ajouter
4143  * @param string $confirm
4144  *     Message de confirmation à ajouter en javascript sur le bouton
4145  * @return string
4146  *     Code HTML du lien
4147  **/
4148 function filtre_bouton_action_horizontal_dist($lien, $texte, $fond, $fonction = "", $class = "", $confirm = "") {
4149         return prepare_icone_base('bouton', $lien, $texte, $fond, $fonction, "horizontale $class", $confirm);
4150 }
4151
4152 /**
4153  * Filtre `icone` pour compatibilité mappé sur `icone_base`
4154  *
4155  * @uses icone_base()
4156  * @see  filtre_icone_verticale_dist()
4157  *
4158  * @filtre
4159  * @deprecated Utiliser le filtre `icone_verticale`
4160  *
4161  * @param string $lien
4162  *     URL du lien
4163  * @param string $texte
4164  *     Texte du lien
4165  * @param string $fond
4166  *     Nom de l'image utilisée
4167  * @param string $align
4168  *     Classe CSS d'alignement (`left`, `right`, `center`)
4169  * @param string $fonction
4170  *     Fonction du lien (`edit`, `new`, `del`)
4171  * @param string $class
4172  *     Classe CSS à ajouter
4173  * @param string $javascript
4174  *     Javascript ajouté sur le lien
4175  * @return string
4176  *     Code HTML du lien
4177  */
4178 function filtre_icone_dist($lien, $texte, $fond, $align = "", $fonction = "", $class = "", $javascript = "") {
4179         return icone_base($lien, $texte, $fond, $fonction, "verticale $align $class", $javascript);
4180 }
4181
4182
4183 /**
4184  * Explose un texte en tableau suivant un séparateur
4185  *
4186  * @note
4187  *     Inverse l'écriture de la fonction PHP de même nom
4188  *     pour que le filtre soit plus pratique dans les squelettes
4189  *
4190  * @filtre
4191  * @example
4192  *     ```
4193  *     [(#GET{truc}|explode{-})]
4194  *     ```
4195  *
4196  * @param string $a Texte
4197  * @param string $b Séparateur
4198  * @return array Liste des éléments
4199  */
4200 function filtre_explode_dist($a, $b) { return explode($b, $a); }
4201
4202 /**
4203  * Implose un tableau en chaine en liant avec un séparateur
4204  *
4205  * @note
4206  *     Inverse l'écriture de la fonction PHP de même nom
4207  *     pour que le filtre soit plus pratique dans les squelettes
4208  *
4209  * @filtre
4210  * @example
4211  *     ```
4212  *     [(#GET{truc}|implode{-})]
4213  *     ```
4214  *
4215  * @param array $a Tableau
4216  * @param string $b Séparateur
4217  * @return string Texte
4218  */
4219 function filtre_implode_dist($a, $b) { return is_array($a) ? implode($b, $a) : $a; }
4220
4221 /**
4222  * Produire les styles privés qui associent item de menu avec icone en background
4223  *
4224  * @return string Code CSS
4225  */
4226 function bando_images_background() {
4227         include_spip('inc/bandeau');
4228         // recuperer tous les boutons et leurs images
4229         $boutons = definir_barre_boutons(definir_barre_contexte(), true, false);
4230
4231         $res = "";
4232         foreach ($boutons as $page => $detail) {
4233                 if ($detail->icone and strlen(trim($detail->icone))) {
4234                         $res .= "\n.navigation_avec_icones #bando1_$page {background-image:url(" . $detail->icone . ");}";
4235                 }
4236                 $selecteur = (in_array($page, array('outils_rapides', 'outils_collaboratifs')) ? "" : ".navigation_avec_icones ");
4237                 if (is_array($detail->sousmenu)) {
4238                         foreach ($detail->sousmenu as $souspage => $sousdetail) {
4239                                 if ($sousdetail->icone and strlen(trim($sousdetail->icone))) {
4240                                         $res .= "\n$selecteur.bando2_$souspage {background-image:url(" . $sousdetail->icone . ");}";
4241                                 }
4242                         }
4243                 }
4244         }
4245
4246         return $res;
4247 }
4248
4249 /**
4250  * Generer un bouton_action
4251  * utilise par #BOUTON_ACTION
4252  *
4253  * @param string $libelle
4254  * @param string $url
4255  * @param string $class
4256  * @param string $confirm
4257  *   message de confirmation oui/non avant l'action
4258  * @param string $title
4259  * @param string $callback
4260  *   callback js a appeler lors de l'evenement action (apres confirmation eventuelle si $confirm est non vide)
4261  *   et avant execution de l'action. Si la callback renvoie false, elle annule le declenchement de l'action
4262  * @return string
4263  */
4264 function bouton_action($libelle, $url, $class = "", $confirm = "", $title = "", $callback = "") {
4265         if ($confirm) {
4266                 $confirm = "confirm(\"" . attribut_html($confirm) . "\")";
4267                 if ($callback) {
4268                         $callback = "$confirm?($callback):false";
4269                 } else {
4270                         $callback = $confirm;
4271                 }
4272         }
4273         $onclick = $callback ? " onclick='return " . addcslashes($callback, "'") . "'" : "";
4274         $title = $title ? " title='$title'" : "";
4275
4276         return "<form class='bouton_action_post $class' method='post' action='$url'><div>" . form_hidden($url)
4277         . "<button type='submit' class='submit'$title$onclick>$libelle</button></div></form>";
4278 }
4279
4280
4281 /**
4282  * Proteger les champs passes dans l'url et utiliser dans {tri ...}
4283  * preserver l'espace pour interpreter ensuite num xxx et multi xxx
4284  * on permet d'utiliser les noms de champ prefixes
4285  * articles.titre
4286  * et les propriete json
4287  * properties.gis[0].ville
4288  *
4289  * @param string $t
4290  * @return string
4291  */
4292 function tri_protege_champ($t) {
4293         return preg_replace(',[^\s\w.+\[\]],', '', $t);
4294 }
4295
4296 /**
4297  * Interpreter les multi xxx et num xxx utilise comme tri
4298  * pour la clause order
4299  * 'multi xxx' devient simplement 'multi' qui est calcule dans le select
4300  *
4301  * @param string $t
4302  * @param array $from
4303  * @return string
4304  */
4305 function tri_champ_order($t, $from = null) {
4306         if (strncmp($t, 'multi ', 6) == 0) {
4307                 return "multi";
4308         }
4309
4310         $champ = $t;
4311
4312         if (strncmp($t, 'num ', 4) == 0) {
4313                 $champ = substr($t, 4);
4314         }
4315         // enlever les autres espaces non evacues par tri_protege_champ
4316         $champ = preg_replace(',\s,', '', $champ);
4317
4318         if (is_array($from)) {
4319                 $trouver_table = charger_fonction('trouver_table', 'base');
4320                 foreach ($from as $idt => $table_sql) {
4321                         if ($desc = $trouver_table($table_sql)
4322                                 and isset($desc['field'][$champ])
4323                         ) {
4324                                 $champ = "$idt.$champ";
4325                                 break;
4326                         }
4327                 }
4328         }
4329         if (strncmp($t, 'num ', 4) == 0) {
4330                 return "0+$champ";
4331         } else {
4332                 return $champ;
4333         }
4334 }
4335
4336 /**
4337  * Interpreter les multi xxx et num xxx utilise comme tri
4338  * pour la clause select
4339  * 'multi xxx' devient select "...." as multi
4340  * les autres cas ne produisent qu'une chaine vide '' en select
4341  * 'hasard' devient 'rand() AS hasard' dans le select
4342  *
4343  * @param string $t
4344  * @return string
4345  */
4346 function tri_champ_select($t) {
4347         if (strncmp($t, 'multi ', 6) == 0) {
4348                 $t = substr($t, 6);
4349                 $t = preg_replace(',\s,', '', $t);
4350                 $t = sql_multi($t, $GLOBALS['spip_lang']);
4351
4352                 return $t;
4353         }
4354         if (trim($t) == 'hasard') {
4355                 return 'rand() AS hasard';
4356         }
4357
4358         return "''";
4359 }
4360
4361
4362 /**
4363  * Donner n'importe quelle information sur un objet de maniere generique.
4364  *
4365  * La fonction va gerer en interne deux cas particuliers les plus utilises :
4366  * l'URL et le titre (qui n'est pas forcemment le champ SQL "titre").
4367  *
4368  * On peut ensuite personnaliser les autres infos en creant une fonction
4369  * generer_<nom_info>_entite($id_objet, $type_objet, $ligne).
4370  * $ligne correspond a la ligne SQL de tous les champs de l'objet, les fonctions
4371  * de personnalisation n'ont donc pas a refaire de requete.
4372  *
4373  * @param int $id_objet
4374  * @param string $type_objet
4375  * @param string $info
4376  * @param string $etoile
4377  * @return string
4378  */
4379 function generer_info_entite($id_objet, $type_objet, $info, $etoile = "") {
4380         static $trouver_table = null;
4381         static $objets;
4382
4383         // On verifie qu'on a tout ce qu'il faut
4384         $id_objet = intval($id_objet);
4385         if (!($id_objet and $type_objet and $info)) {
4386                 return '';
4387         }
4388
4389         // si on a deja note que l'objet n'existe pas, ne pas aller plus loin
4390         if (isset($objets[$type_objet]) and $objets[$type_objet] === false) {
4391                 return '';
4392         }
4393
4394         // Si on demande l'url, on retourne direct la fonction
4395         if ($info == 'url') {
4396                 return generer_url_entite($id_objet, $type_objet);
4397         }
4398
4399         // Sinon on va tout chercher dans la table et on garde en memoire
4400         $demande_titre = ($info == 'titre');
4401
4402         // 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
4403         if (!isset($objets[$type_objet][$id_objet])
4404                 or
4405                 ($demande_titre and !isset($objets[$type_objet][$id_objet]['titre']))
4406         ) {
4407                 if (!$trouver_table) {
4408                         $trouver_table = charger_fonction('trouver_table', 'base');
4409                 }
4410                 $desc = $trouver_table(table_objet_sql($type_objet));
4411                 if (!$desc) {
4412                         return $objets[$type_objet] = false;
4413                 }
4414
4415                 // Si on demande le titre, on le gere en interne
4416                 $champ_titre = "";
4417                 if ($demande_titre) {
4418                         // si pas de titre declare mais champ titre, il sera peuple par le select *
4419                         $champ_titre = (!empty($desc['titre'])) ? ', ' . $desc['titre'] : '';
4420                 }
4421                 include_spip('base/abstract_sql');
4422                 include_spip('base/connect_sql');
4423                 $objets[$type_objet][$id_objet] = sql_fetsel(
4424                         '*' . $champ_titre,
4425                         $desc['table_sql'],
4426                         id_table_objet($type_objet) . ' = ' . intval($id_objet)
4427                 );
4428         }
4429
4430         // Si la fonction generer_TRUC_TYPE existe, on l'utilise pour formater $info_generee
4431         if ($generer = charger_fonction("generer_${info}_${type_objet}", '', true)) {
4432                 $info_generee = $generer($id_objet, $objets[$type_objet][$id_objet]);
4433         } // Si la fonction generer_TRUC_entite existe, on l'utilise pour formater $info_generee
4434         else {
4435                 if ($generer = charger_fonction("generer_${info}_entite", '', true)) {
4436                         $info_generee = $generer($id_objet, $type_objet, $objets[$type_objet][$id_objet]);
4437                 } // Sinon on prend directement le champ SQL tel quel
4438                 else {
4439                         $info_generee = (isset($objets[$type_objet][$id_objet][$info]) ? $objets[$type_objet][$id_objet][$info] : '');
4440                 }
4441         }
4442
4443         // On va ensuite appliquer les traitements automatiques si besoin
4444         if (!$etoile) {
4445                 // FIXME: on fournit un ENV minimum avec id et type et connect=''
4446                 // mais ce fonctionnement est a ameliorer !
4447                 $info_generee = appliquer_traitement_champ($info_generee, $info, table_objet($type_objet),
4448                         array('id_objet' => $id_objet, 'objet' => $type_objet, ''));
4449         }
4450
4451         return $info_generee;
4452 }
4453
4454 /**
4455  * Appliquer a un champ SQL le traitement qui est configure pour la balise homonyme dans les squelettes
4456  *
4457  * @param string $texte
4458  * @param string $champ
4459  * @param string $table_objet
4460  * @param array $env
4461  * @param string $connect
4462  * @return string
4463  */
4464 function appliquer_traitement_champ($texte, $champ, $table_objet = '', $env = array(), $connect = '') {
4465         if (!$champ) {
4466                 return $texte;
4467         }
4468
4469         // On charge toujours les filtres de texte car la majorité des traitements les utilisent
4470         // et il ne faut pas partir du principe que c'est déjà chargé (form ajax, etc)
4471         include_spip('inc/texte');
4472
4473         $champ = strtoupper($champ);
4474         $traitements = isset($GLOBALS['table_des_traitements'][$champ]) ? $GLOBALS['table_des_traitements'][$champ] : false;
4475         if (!$traitements or !is_array($traitements)) {
4476                 return $texte;
4477         }
4478
4479         $traitement = '';
4480         if ($table_objet and (!isset($traitements[0]) or count($traitements) > 1)) {
4481                 // necessaire pour prendre en charge les vieux appels avec un table_objet_sql en 3e arg
4482                 $table_objet = table_objet($table_objet);
4483                 if (isset($traitements[$table_objet])) {
4484                         $traitement = $traitements[$table_objet];
4485                 }
4486         }
4487         if (!$traitement and isset($traitements[0])) {
4488                 $traitement = $traitements[0];
4489         }
4490         // (sinon prendre le premier de la liste par defaut ?)
4491
4492         if (!$traitement) {
4493                 return $texte;
4494         }
4495
4496         $traitement = str_replace('%s', "'" . texte_script($texte) . "'", $traitement);
4497
4498         // Fournir $connect et $Pile[0] au traitement si besoin
4499         $Pile = array(0 => $env);
4500         eval("\$texte = $traitement;");
4501
4502         return $texte;
4503 }
4504
4505
4506 /**
4507  * Generer un lien (titre clicable vers url) vers un objet
4508  *
4509  * @param int $id_objet
4510  * @param $objet
4511  * @param int $longueur
4512  * @param null|string $connect
4513  * @return string
4514  */
4515 function generer_lien_entite($id_objet, $objet, $longueur = 80, $connect = null) {
4516         include_spip('inc/liens');
4517         $titre = traiter_raccourci_titre($id_objet, $objet, $connect);
4518         // lorsque l'objet n'est plus declare (plugin desactive par exemple)
4519         // le raccourcis n'est plus valide
4520         $titre = isset($titre['titre']) ? typo($titre['titre']) : '';
4521         // on essaye avec generer_info_entite ?
4522         if (!strlen($titre) and !$connect) {
4523                 $titre = generer_info_entite($id_objet, $objet, 'titre');
4524         }
4525         if (!strlen($titre)) {
4526                 $titre = _T('info_sans_titre');
4527         }
4528         $url = generer_url_entite($id_objet, $objet, '', '', $connect);
4529
4530         return "<a href='$url' class='$objet'>" . couper($titre, $longueur) . "</a>";
4531 }
4532
4533
4534 /**
4535  * Englobe (Wrap) un texte avec des balises
4536  *
4537  * @example `wrap('mot','<b>')` donne `<b>mot</b>'`
4538  *
4539  * @filtre
4540  * @uses extraire_balises()
4541  *
4542  * @param string $texte
4543  * @param string $wrap
4544  * @return string
4545  */
4546 function wrap($texte, $wrap) {
4547         $balises = extraire_balises($wrap);
4548         if (preg_match_all(",<([a-z]\w*)\b[^>]*>,UimsS", $wrap, $regs, PREG_PATTERN_ORDER)) {
4549                 $texte = $wrap . $texte;
4550                 $regs = array_reverse($regs[1]);
4551                 $wrap = "</" . implode("></", $regs) . ">";
4552                 $texte = $texte . $wrap;
4553         }
4554
4555         return $texte;
4556 }
4557
4558
4559 /**
4560  * afficher proprement n'importe quoi
4561  * On affiche in fine un pseudo-yaml qui premet de lire humainement les tableaux et de s'y reperer
4562  *
4563  * Les textes sont retournes avec simplement mise en forme typo
4564  *
4565  * 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
4566  * les tableaux-listes (qui n'ont que des cles numeriques), sont affiches sous forme de liste separee par des virgules :
4567  * c'est VOULU !
4568  *
4569  * @param $u
4570  * @param string $join
4571  * @param int $indent
4572  * @return array|mixed|string
4573  */
4574 function filtre_print_dist($u, $join = "<br />", $indent = 0) {
4575         if (is_string($u)) {
4576                 $u = typo($u);
4577
4578                 return $u;
4579         }
4580
4581         // caster $u en array si besoin
4582         if (is_object($u)) {
4583                 $u = (array)$u;
4584         }
4585
4586         if (is_array($u)) {
4587                 $out = "";
4588                 // toutes les cles sont numeriques ?
4589                 // et aucun enfant n'est un tableau
4590                 // liste simple separee par des virgules
4591                 $numeric_keys = array_map('is_numeric', array_keys($u));
4592                 $array_values = array_map('is_array', $u);
4593                 $object_values = array_map('is_object', $u);
4594                 if (array_sum($numeric_keys) == count($numeric_keys)
4595                         and !array_sum($array_values)
4596                         and !array_sum($object_values)
4597                 ) {
4598                         return join(", ", array_map('filtre_print_dist', $u));
4599                 }
4600
4601                 // sinon on passe a la ligne et on indente
4602                 $i_str = str_pad("", $indent, " ");
4603                 foreach ($u as $k => $v) {
4604                         $out .= $join . $i_str . "$k: " . filtre_print_dist($v, $join, $indent + 2);
4605                 }
4606
4607                 return $out;
4608         }
4609
4610         // on sait pas quoi faire...
4611         return $u;
4612 }
4613
4614
4615 /**
4616  * Renvoyer l'info d'un objet
4617  * telles que definies dans declarer_tables_objets_sql
4618  *
4619  * @param string $objet
4620  * @param string $info
4621  * @return string
4622  */
4623 function objet_info($objet, $info) {
4624         $table = table_objet_sql($objet);
4625         $infos = lister_tables_objets_sql($table);
4626
4627         return (isset($infos[$info]) ? $infos[$info] : '');
4628 }
4629
4630 /**
4631  * Filtre pour afficher 'Aucun truc' ou '1 truc' ou 'N trucs'
4632  * avec la bonne chaîne de langue en fonction de l'objet utilisé
4633  *
4634  * @param int $nb
4635  *     Nombre d'éléments
4636  * @param string $objet
4637  *     Objet
4638  * @return mixed|string
4639  *     Texte traduit du comptage, tel que '3 articles'
4640  */
4641 function objet_afficher_nb($nb, $objet) {
4642         if (!$nb) {
4643                 return _T(objet_info($objet, 'info_aucun_objet'));
4644         } else {
4645                 return _T(objet_info($objet, $nb == 1 ? 'info_1_objet' : 'info_nb_objets'), array('nb' => $nb));
4646         }
4647 }
4648
4649 /**
4650  * Filtre pour afficher l'img icone d'un objet
4651  *
4652  * @param string $objet
4653  * @param int $taille
4654  * @return string
4655  */
4656 function objet_icone($objet, $taille = 24) {
4657         $icone = objet_info($objet, 'icone_objet') . "-" . $taille . ".png";
4658         $icone = chemin_image($icone);
4659         $balise_img = charger_filtre('balise_img');
4660
4661         return $icone ? $balise_img($icone, _T(objet_info($objet, 'texte_objet'))) : '';
4662 }
4663
4664 /**
4665  * Renvoyer une traduction d'une chaine de langue contextuelle à un objet si elle existe,
4666  * la traduction de la chaine generique
4667  *
4668  * Ex : [(#ENV{objet}|objet_label{trad_reference})]
4669  * va chercher si une chaine objet:trad_reference existe et renvoyer sa trad le cas echeant
4670  * sinon renvoie la trad de la chaine trad_reference
4671  * Si la chaine fournie contient un prefixe il est remplacé par celui de l'objet pour chercher la chaine contextuelle
4672  *
4673  * Les arguments $args et $options sont ceux de la fonction _T
4674  *
4675  * @param string $objet
4676  * @param string $chaine
4677  * @param array $args
4678  * @param array $options
4679  * @return string
4680  */
4681 function objet_T($objet, $chaine, $args = array(), $options = array()){
4682         $chaine = explode(':',$chaine);
4683         if ($t = _T($objet . ':' . end($chaine), $args, array_merge($options, array('force'=>false)))) {
4684                 return $t;
4685         }
4686         $chaine = implode(':',$chaine);
4687         return _T($chaine, $args, $options);
4688 }
4689
4690 /**
4691  * Fonction de secours pour inserer le head_css de facon conditionnelle
4692  *
4693  * Appelée en filtre sur le squelette qui contient #INSERT_HEAD,
4694  * elle vérifie l'absence éventuelle de #INSERT_HEAD_CSS et y suplée si besoin
4695  * pour assurer la compat avec les squelettes qui n'utilisent pas.
4696  *
4697  * @param string $flux Code HTML
4698  * @return string      Code HTML
4699  */
4700 function insert_head_css_conditionnel($flux) {
4701         if (strpos($flux, '<!-- insert_head_css -->') === false
4702                 and $p = strpos($flux, '<!-- insert_head -->')
4703         ) {
4704                 // plutot avant le premier js externe (jquery) pour etre non bloquant
4705                 if ($p1 = stripos($flux, '<script src=') and $p1 < $p) {
4706                         $p = $p1;
4707                 }
4708                 $flux = substr_replace($flux, pipeline('insert_head_css', '<!-- insert_head_css -->'), $p, 0);
4709         }
4710
4711         return $flux;
4712 }
4713
4714 /**
4715  * Produire un fichier statique à partir d'un squelette dynamique
4716  *
4717  * Permet ensuite à Apache de le servir en statique sans repasser
4718  * par spip.php à chaque hit sur le fichier.
4719  *
4720  * Si le format (css ou js) est passe dans `contexte['format']`, on l'utilise
4721  * sinon on regarde si le fond finit par .css ou .js, sinon on utilie "html"
4722  *
4723  * @uses urls_absolues_css()
4724  *
4725  * @param string $fond
4726  * @param array $contexte
4727  * @param array $options
4728  * @param string $connect
4729  * @return string
4730  */
4731 function produire_fond_statique($fond, $contexte = array(), $options = array(), $connect = '') {
4732         if (isset($contexte['format'])) {
4733                 $extension = $contexte['format'];
4734                 unset($contexte['format']);
4735         } else {
4736                 $extension = "html";
4737                 if (preg_match(',[.](css|js|json)$,', $fond, $m)) {
4738                         $extension = $m[1];
4739                 }
4740         }
4741         // recuperer le contenu produit par le squelette
4742         $options['raw'] = true;
4743         $cache = recuperer_fond($fond, $contexte, $options, $connect);
4744
4745         // calculer le nom de la css
4746         $dir_var = sous_repertoire(_DIR_VAR, 'cache-' . $extension);
4747         $nom_safe = preg_replace(",\W,", '_', str_replace('.', '_', $fond));
4748         $contexte_implicite = calculer_contexte_implicite();
4749         $filename = $dir_var . $extension . "dyn-$nom_safe-"
4750                 . substr(md5($fond . serialize($contexte_implicite) . serialize($contexte) . $connect), 0, 8)
4751                 . ".$extension";
4752
4753         // mettre a jour le fichier si il n'existe pas
4754         // ou trop ancien
4755         // le dernier fichier produit est toujours suffixe par .last
4756         // et recopie sur le fichier cible uniquement si il change
4757         if (!file_exists($filename)
4758                 or !file_exists($filename . ".last")
4759                 or (isset($cache['lastmodified']) and $cache['lastmodified'] and filemtime($filename . ".last") < $cache['lastmodified'])
4760                 or (defined('_VAR_MODE') and _VAR_MODE == 'recalcul')
4761         ) {
4762                 $contenu = $cache['texte'];
4763                 // passer les urls en absolu si c'est une css
4764                 if ($extension == "css") {
4765                         $contenu = urls_absolues_css($contenu,
4766                                 test_espace_prive() ? generer_url_ecrire('accueil') : generer_url_public($fond));
4767                 }
4768
4769                 $comment = '';
4770                 // ne pas insérer de commentaire si c'est du json
4771                 if ($extension != "json") {
4772                         $comment = "/* #PRODUIRE{fond=$fond";
4773                         foreach ($contexte as $k => $v) {
4774                                 $comment .= ",$k=$v";
4775                         }
4776                         // pas de date dans le commentaire car sinon ca invalide le md5 et force la maj
4777                         // mais on peut mettre un md5 du contenu, ce qui donne un aperu rapide si la feuille a change ou non
4778                         $comment .= "}\n   md5:" . md5($contenu) . " */\n";
4779                 }
4780                 // et ecrire le fichier
4781                 ecrire_fichier($filename . ".last", $comment . $contenu);
4782                 // regarder si on recopie
4783                 if (!file_exists($filename)
4784                         or md5_file($filename) !== md5_file($filename . ".last")
4785                 ) {
4786                         @copy($filename . ".last", $filename);
4787                         clearstatcache(true, $filename); // eviter que PHP ne reserve le vieux timestamp
4788                 }
4789         }
4790
4791         return timestamp($filename);
4792 }
4793
4794 /**
4795  * Ajouter un timestamp a une url de fichier
4796  * [(#CHEMIN{monfichier}|timestamp)]
4797  *
4798  * @param string $fichier
4799  *    Le chemin du fichier sur lequel on souhaite ajouter le timestamp
4800  * @return string
4801  *    $fichier auquel on a ajouté le timestamp
4802  */
4803 function timestamp($fichier) {
4804         if (!$fichier
4805                 or !file_exists($fichier)
4806                 or !$m = filemtime($fichier)
4807         ) {
4808                 return $fichier;
4809         }
4810
4811         return "$fichier?$m";
4812 }
4813
4814 /**
4815  * Supprimer le timestamp d'une url
4816  *
4817  * @param string $url
4818  * @return string
4819  */
4820 function supprimer_timestamp($url) {
4821         if (strpos($url, "?") === false) {
4822                 return $url;
4823         }
4824
4825         return preg_replace(",\?[[:digit:]]+$,", "", $url);
4826 }
4827
4828 /**
4829  * Nettoyer le titre d'un email
4830  *
4831  * Éviter une erreur lorsqu'on utilise `|nettoyer_titre_email` dans un squelette de mail
4832  *
4833  * @filtre
4834  * @uses nettoyer_titre_email()
4835  *
4836  * @param string $titre
4837  * @return string
4838  */
4839 function filtre_nettoyer_titre_email_dist($titre) {
4840         include_spip('inc/envoyer_mail');
4841
4842         return nettoyer_titre_email($titre);
4843 }
4844
4845 /**
4846  * Afficher le sélecteur de rubrique
4847  *
4848  * Il permet de placer un objet dans la hiérarchie des rubriques de SPIP
4849  *
4850  * @uses chercher_rubrique()
4851  *
4852  * @param string $titre
4853  * @param int $id_objet
4854  * @param int $id_parent
4855  * @param string $objet
4856  * @param int $id_secteur
4857  * @param bool $restreint
4858  * @param bool $actionable
4859  *   true : fournit le selecteur dans un form directement postable
4860  * @param bool $retour_sans_cadre
4861  * @return string
4862  */
4863 function filtre_chercher_rubrique_dist(
4864         $titre,
4865         $id_objet,
4866         $id_parent,
4867         $objet,
4868         $id_secteur,
4869         $restreint,
4870         $actionable = false,
4871         $retour_sans_cadre = false
4872 ) {
4873         include_spip('inc/filtres_ecrire');
4874
4875         return chercher_rubrique($titre, $id_objet, $id_parent, $objet, $id_secteur, $restreint, $actionable,
4876                 $retour_sans_cadre);
4877 }
4878
4879 /**
4880  * Rediriger une page suivant une autorisation,
4881  * et ce, n'importe où dans un squelette, même dans les inclusions.
4882  *
4883  * En l'absence de redirection indiquée, la fonction redirige par défaut
4884  * sur une 403 dans l'espace privé et 404 dans l'espace public.
4885  *
4886  * @example
4887  *     ```
4888  *     [(#AUTORISER{non}|sinon_interdire_acces)]
4889  *     [(#AUTORISER{non}|sinon_interdire_acces{#URL_PAGE{login}, 401})]
4890  *     ```
4891  *
4892  * @filtre
4893  * @param bool $ok
4894  *     Indique si l'on doit rediriger ou pas
4895  * @param string $url
4896  *     Adresse eventuelle vers laquelle rediriger
4897  * @param int $statut
4898  *     Statut HTML avec lequel on redirigera
4899  * @param string $message
4900  *     message d'erreur
4901  * @return string|void
4902  *     Chaîne vide si l'accès est autorisé
4903  */
4904 function sinon_interdire_acces($ok = false, $url = '', $statut = 0, $message = null) {
4905         if ($ok) {
4906                 return '';
4907         }
4908
4909         // Vider tous les tampons
4910         $level = @ob_get_level();
4911         while ($level--) {
4912                 @ob_end_clean();
4913         }
4914
4915         include_spip('inc/headers');
4916
4917         // S'il y a une URL, on redirige (si pas de statut, la fonction mettra 302 par défaut)
4918         if ($url) {
4919                 redirige_par_entete($url, '', $statut);
4920         }
4921
4922         // ecriture simplifiee avec message en 3eme argument (= statut 403)
4923         if (!is_numeric($statut) and is_null($message)) {
4924                 $message = $statut;
4925                 $statut = 0;
4926         }
4927         if (!$message) {
4928                 $message = '';
4929         }
4930         $statut = intval($statut);
4931
4932         // Si on est dans l'espace privé, on génère du 403 Forbidden par defaut ou du 404
4933         if (test_espace_prive()) {
4934                 if (!$statut or !in_array($statut, array(404, 403))) {
4935                         $statut = 403;
4936                 }
4937                 http_status(403);
4938                 $echec = charger_fonction('403', 'exec');
4939                 $echec($message);
4940         } else {
4941                 // Sinon dans l'espace public on redirige vers une 404 par défaut, car elle toujours présente normalement
4942                 if (!$statut) {
4943                         $statut = 404;
4944                 }
4945                 // Dans tous les cas on modifie l'entité avec ce qui est demandé
4946                 http_status($statut);
4947                 // Si le statut est une erreur et qu'il n'y a pas de redirection on va chercher le squelette du même nom
4948                 if ($statut >= 400) {
4949                         echo recuperer_fond("$statut", array('erreur' => $message));
4950                 }
4951         }
4952
4953
4954         exit;
4955 }
4956
4957 /**
4958  * Assurer le fonctionnement de |compacte meme sans l'extension compresseur
4959  *
4960  * @param string $source
4961  * @param null|string $format
4962  * @return string
4963  */
4964 function filtre_compacte_dist($source, $format = null) {
4965         if (function_exists('compacte')) {
4966                 return compacte($source, $format);
4967         }
4968
4969         return $source;
4970 }