www/ecrire/inc/filtres.php

   1 <?php
   2
   3 /***************************************************************************\
   4  *  SPIP, Systeme de publication pour l'internet                           *
   5  *                                                                         *
   6  *  Copyright (c) 2001-2012                                                *
   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 if (!defined('_ECRIRE_INC_VERSION')) return;
  14
  15 include_spip('inc/charsets');
  16 include_spip('inc/filtres_mini');
  17 include_spip('base/objets');
  18 include_spip('public/parametrer'); // charger les fichiers fonctions
  19
  20 /**
  21  * Charger un filtre depuis le php :
  22  * - on inclue tous les fichiers fonctions des plugins et du skel
  23  * - on appelle chercher_filtre
  24  *
  25  * @param string $fonc
  26  * @param string $default
  27  * @return string
  28  */
  29 function charger_filtre($fonc, $default='filtre_identite_dist') {
  30         include_spip('public/parametrer'); // inclure les fichiers fonctions
  31         return chercher_filtre($fonc, $default);
  32 }
  33
  34 function filtre_identite_dist($texte){return $texte;}
  35
  36 /**
  37  * http://doc.spip.org/@chercher_filtre
  38  *
  39  * @param string $fonc
  40  * @param null $default
  41  * @return string
  42  */
  43 function chercher_filtre($fonc, $default=NULL) {
  44         if (!$fonc) return $default;
  45         // Cas des types mime, sans confondre avec les appels de fonction de classe
  46         // Foo::Bar
  47         // qui peuvent etre avec un namespace : space\Foo::Bar
  48         if (preg_match(',^[\w]+/,',$fonc)){
  49                 $nom = preg_replace(',\W,','_', $fonc);
  50                 $f = chercher_filtre($nom);
  51                 // cas du sous-type MIME sans filtre associe, passer au type:
  52                 // si filtre_text_plain pas defini, passe a filtre_text
  53                 if (!$f AND $nom!==$fonc)
  54                         $f = chercher_filtre(preg_replace(',\W.*$,','', $fonc));
  55                 return $f;
  56         }
  57         foreach (
  58         array('filtre_'.$fonc, 'filtre_'.$fonc.'_dist', $fonc) as $f){
  59                 if (isset( $GLOBALS['spip_matrice'][$f]) AND is_string($g = $GLOBALS['spip_matrice'][$f]))
  60                         find_in_path($g,'', true);
  61                 if (function_exists($f)
  62                 OR (preg_match("/^(\w*)::(\w*)$/", $f, $regs)
  63                         AND is_callable(array($regs[1], $regs[2]))
  64                 )) {
  65                         return $f;
  66                 }
  67         }
  68         return $default;
  69 }
  70
  71 // http://doc.spip.org/@appliquer_filtre
  72 function appliquer_filtre($arg, $filtre) {
  73         $f = chercher_filtre($filtre);
  74         if (!$f)
  75                 return ''; // ou faut-il retourner $arg inchange == filtre_identite?
  76
  77         $args = func_get_args();
  78         array_shift($args); // enlever $arg
  79         array_shift($args); // enlever $filtre
  80         array_unshift($args, $arg); // remettre $arg
  81         return call_user_func_array($f,$args);
  82 }
  83
  84 // http://doc.spip.org/@spip_version
  85 function spip_version() {
  86         $version = $GLOBALS['spip_version_affichee'];
  87         if ($svn_revision = version_svn_courante(_DIR_RACINE))
  88                 $version .= ($svn_revision<0 ? ' SVN':'').' ['.abs($svn_revision).']';
  89         return $version;
  90 }
  91
  92
  93 //
  94 // Mention de la revision SVN courante de l'espace restreint standard
  95 // (numero non garanti pour l'espace public et en cas de mutualisation)
  96 // on est negatif si on est sur .svn, et positif si on utilise svn.revision
  97 // http://doc.spip.org/@version_svn_courante
  98 function version_svn_courante($dir) {
  99         if (!$dir) $dir = '.';
 100
 101         // version installee par paquet ZIP
 102         if (lire_fichier($dir.'/svn.revision', $c)
 103         AND preg_match(',Revision: (\d+),', $c, $d))
 104                 return intval($d[1]);
 105
 106         // version installee par SVN
 107         if (lire_fichier($dir . '/.svn/entries', $c)
 108         AND (
 109         (preg_match_all(
 110         ',committed-rev="([0-9]+)",', $c, $r1, PREG_PATTERN_ORDER)
 111         AND $v = max($r1[1])
 112         )
 113         OR
 114         (preg_match(',^\d.*dir[\r\n]+(\d+),ms', $c, $r1) # svn >= 1.4
 115         AND $v = $r1[1]
 116         )))
 117                 return -$v;
 118
 119         // Bug ou paquet fait main
 120         return 0;
 121 }
 122
 123 // La matrice est necessaire pour ne filtrer _que_ des fonctions definies dans filtres_images
 124 // et laisser passer les fonctions personnelles baptisees image_...
 125 $GLOBALS['spip_matrice']['image_graver'] = true;//'inc/filtres_images_mini.php';
 126 $GLOBALS['spip_matrice']['image_select'] = true;//'inc/filtres_images_mini.php';
 127 $GLOBALS['spip_matrice']['image_reduire'] = true;//'inc/filtres_images_mini.php';
 128 $GLOBALS['spip_matrice']['image_reduire_par'] = true;//'inc/filtres_images_mini.php';
 129 $GLOBALS['spip_matrice']['image_passe_partout'] = true;//'inc/filtres_images_mini.php';
 130
 131 $GLOBALS['spip_matrice']['couleur_html_to_hex'] = 'inc/filtres_images_mini.php';
 132 $GLOBALS['spip_matrice']['couleur_foncer'] = 'inc/filtres_images_mini.php';
 133 $GLOBALS['spip_matrice']['couleur_eclaircir'] = 'inc/filtres_images_mini.php';
 134
 135 // ou pour inclure un script au moment ou l'on cherche le filtre
 136 $GLOBALS['spip_matrice']['filtre_image_dist'] = 'inc/filtres_mime.php';
 137 $GLOBALS['spip_matrice']['filtre_audio_dist'] = 'inc/filtres_mime.php';
 138 $GLOBALS['spip_matrice']['filtre_video_dist'] = 'inc/filtres_mime.php';
 139 $GLOBALS['spip_matrice']['filtre_application_dist'] = 'inc/filtres_mime.php';
 140 $GLOBALS['spip_matrice']['filtre_message_dist'] = 'inc/filtres_mime.php';
 141 $GLOBALS['spip_matrice']['filtre_multipart_dist'] = 'inc/filtres_mime.php';
 142 $GLOBALS['spip_matrice']['filtre_text_dist'] = 'inc/filtres_mime.php';
 143 $GLOBALS['spip_matrice']['filtre_text_csv_dist'] = 'inc/filtres_mime.php';
 144 $GLOBALS['spip_matrice']['filtre_text_html_dist'] = 'inc/filtres_mime.php';
 145 $GLOBALS['spip_matrice']['filtre_audio_x_pn_realaudio'] = 'inc/filtres_mime.php';
 146
 147
 148 // charge les fonctions graphiques et applique celle demandee
 149 // http://doc.spip.org/@filtrer
 150 function filtrer($filtre) {
 151         if (isset($GLOBALS['spip_matrice'][$filtre]) and is_string($f = $GLOBALS['spip_matrice'][$filtre])){
 152                 find_in_path($f,'', true);
 153                 $GLOBALS['spip_matrice'][$filtre] = true;
 154         }
 155         $tous = func_get_args();
 156         if (substr($filtre,0,6)=='image_' && $GLOBALS['spip_matrice'][$filtre])
 157                 return image_filtrer($tous);
 158         elseif($f = chercher_filtre($filtre)) {
 159                 array_shift($tous);
 160                 return call_user_func_array($f, $tous);
 161         }
 162         else {
 163                 // le filtre n'existe pas, on provoque une erreur
 164                 $msg = array('zbug_erreur_filtre', array('filtre'=>texte_script($filtre)));
 165                 erreur_squelette($msg);
 166                 return '';
 167         }
 168 }
 169
 170 // fonction generique d'entree des filtres images
 171 // accepte en entree un texte complet, un img-log (produit par #LOGO_XX),
 172 // un tag <img ...> complet, ou encore un nom de fichier *local* (passer
 173 // le filtre |copie_locale si on veut l'appliquer a un document)
 174 // applique le filtre demande a chacune des occurrences
 175
 176 // http://doc.spip.org/@image_filtrer
 177 function image_filtrer($args){
 178         $filtre = array_shift($args); # enlever $filtre
 179         $texte = array_shift($args);
 180         if (!strlen($texte)) return;
 181         find_in_path('filtres_images_mini.php','inc/', true);
 182         statut_effacer_images_temporaires(true); // activer la suppression des images temporaires car le compilo finit la chaine par un image_graver
 183         // Cas du nom de fichier local
 184         if ( strpos(substr($texte,strlen(_DIR_RACINE)),'..')===FALSE
 185         AND !preg_match(',^/|[<>]|\s,S', $texte)
 186         AND (
 187                 file_exists(preg_replace(',[?].*$,','',$texte))
 188                 OR preg_match(';^(\w{3,7}://);', $texte)
 189                 )) {
 190                 array_unshift($args,"<img src='$texte' />");
 191                 $res = call_user_func_array($filtre, $args);
 192                 statut_effacer_images_temporaires(false); // desactiver pour les appels hors compilo
 193                 return $res;
 194         }
 195
 196         // Cas general : trier toutes les images, avec eventuellement leur <span>
 197         if (preg_match_all(
 198                 ',(<([a-z]+) [^<>]*spip_documents[^<>]*>)?\s*(<img\s.*>),UimsS',
 199                 $texte, $tags, PREG_SET_ORDER)) {
 200                 foreach ($tags as $tag) {
 201                         $class = extraire_attribut($tag[3],'class');
 202                         if (!$class || (strpos($class,'no_image_filtrer')===FALSE)){
 203                                 array_unshift($args,$tag[3]);
 204                                 if ($reduit = call_user_func_array($filtre, $args)) {
 205                                         // En cas de span spip_documents, modifier le style=...width:
 206                                         if($tag[1]){
 207                                                 $w = extraire_attribut($reduit, 'width');
 208                                                 if (!$w AND preg_match(",width:\s*(\d+)px,S",extraire_attribut($reduit,'style'),$regs))
 209                                                         $w = $regs[1];
 210                                                 if ($w AND ($style = extraire_attribut($tag[1], 'style'))){
 211                                                         $style = preg_replace(",width:\s*\d+px,S", "width:${w}px", $style);
 212                                                         $replace = inserer_attribut($tag[1], 'style', $style);
 213                                                         $texte = str_replace($tag[1], $replace, $texte);
 214                                                 }
 215                                         }
 216                                         // traiter aussi un eventuel mouseover
 217                                         if ($mouseover = extraire_attribut($reduit,'onmouseover')){
 218                                                 if (preg_match(",this[.]src=['\"]([^'\"]+)['\"],ims", $mouseover, $match)){
 219                                                         $srcover = $match[1];
 220                                                         array_shift($args);
 221                                                         array_unshift($args,"<img src='".$match[1]."' />");
 222                                                         $srcover_filter = call_user_func_array($filtre, $args);
 223                                                         $srcover_filter = extraire_attribut($srcover_filter,'src');
 224                                                         $reduit = str_replace($srcover,$srcover_filter,$reduit);
 225                                                 }
 226                                         }
 227                                         $texte = str_replace($tag[3], $reduit, $texte);
 228                                 }
 229                                 array_shift($args);
 230                         }
 231                 }
 232         }
 233         statut_effacer_images_temporaires(false); // desactiver pour les appels hors compilo
 234         return $texte;
 235 }
 236
 237 //
 238 // Retourner taille d'une image
 239 // pour les filtres |largeur et |hauteur
 240 //
 241 // http://doc.spip.org/@taille_image
 242 function taille_image($img) {
 243
 244         static $largeur_img =array(), $hauteur_img= array();
 245         $srcWidth = 0;
 246         $srcHeight = 0;
 247
 248         $logo = extraire_attribut($img,'src');
 249
 250         if (!$logo) $logo = $img;
 251         else {
 252                 $srcWidth = extraire_attribut($img,'width');
 253                 $srcHeight = extraire_attribut($img,'height');
 254         }
 255
 256         // ne jamais operer directement sur une image distante pour des raisons de perfo
 257         // la copie locale a toutes les chances d'etre la ou de resservir
 258         if (preg_match(';^(\w{3,7}://);', $logo)){
 259                 include_spip('inc/distant');
 260                 $fichier = copie_locale($logo);
 261                 $logo = $fichier ? _DIR_RACINE . $fichier : $logo;
 262         }
 263         if (($p=strpos($logo,'?'))!==FALSE)
 264                 $logo=substr($logo,0,$p);
 265
 266         $srcsize = false;
 267         if (isset($largeur_img[$logo]))
 268                 $srcWidth = $largeur_img[$logo];
 269         if (isset($hauteur_img[$logo]))
 270                 $srcHeight = $hauteur_img[$logo];
 271         if (!$srcWidth OR !$srcHeight){
 272                 if (file_exists($logo)
 273                         AND $srcsize = @getimagesize($logo)){
 274                         if (!$srcWidth) $largeur_img[$logo] = $srcWidth = $srcsize[0];
 275                         if (!$srcHeight)        $hauteur_img[$logo] = $srcHeight = $srcsize[1];
 276                 }
 277                 // $logo peut etre une reference a une image temporaire dont a n'a que le log .src
 278                 // on s'y refere, l'image sera reconstruite en temps utile si necessaire
 279                 elseif(@file_exists($f = "$logo.src")
 280                   AND lire_fichier($f,$valeurs)
 281                   AND $valeurs=unserialize($valeurs)) {
 282                         if (!$srcWidth) $largeur_img[$logo] = $srcWidth = $valeurs["largeur_dest"];
 283                         if (!$srcHeight)        $hauteur_img[$logo] = $srcHeight = $valeurs["hauteur_dest"];
 284           }
 285         }
 286         return array($srcHeight, $srcWidth);
 287 }
 288 // http://doc.spip.org/@largeur
 289 function largeur($img) {
 290         if (!$img) return;
 291         list ($h,$l) = taille_image($img);
 292         return $l;
 293 }
 294 // http://doc.spip.org/@hauteur
 295 function hauteur($img) {
 296         if (!$img) return;
 297         list ($h,$l) = taille_image($img);
 298         return $h;
 299 }
 300
 301
 302 // Echappement des entites HTML avec correction des entites "brutes"
 303 // (generees par les butineurs lorsqu'on rentre des caracteres n'appartenant
 304 // pas au charset de la page [iso-8859-1 par defaut])
 305 //
 306 // Attention on limite cette correction aux caracteres "hauts" (en fait > 99
 307 // pour aller plus vite que le > 127 qui serait logique), de maniere a
 308 // preserver des echappements de caracteres "bas" (par exemple [ ou ")
 309 // et au cas particulier de &amp; qui devient &amp;amp; dans les url
 310 // http://doc.spip.org/@corriger_entites_html
 311 function corriger_entites_html($texte) {
 312         if (strpos($texte,'&amp;') === false) return $texte;
 313         return preg_replace(',&amp;(#[0-9][0-9][0-9]+;|amp;),iS', '&\1', $texte);
 314 }
 315 // idem mais corriger aussi les &amp;eacute; en &eacute;
 316 // http://doc.spip.org/@corriger_toutes_entites_html
 317 function corriger_toutes_entites_html($texte) {
 318         if (strpos($texte,'&amp;') === false) return $texte;
 319         return preg_replace(',&amp;(#?[a-z0-9]+;),iS', '&\1', $texte);
 320 }
 321
 322 // http://doc.spip.org/@proteger_amp
 323 function proteger_amp($texte){
 324         return str_replace('&','&amp;',$texte);
 325 }
 326
 327 //
 328 /**
 329  * http://doc.spip.org/@entites_html
 330  *
 331  * @param string $texte
 332  *   chaine a echapper
 333  * @param bool $tout
 334  *   corriger toutes les &amp;xx; en &xx;
 335  * @param bool $quote
 336  *   echapper aussi les simples quotes en &#039;
 337  * @return mixed|string
 338  */
 339 function entites_html($texte, $tout=false, $quote=true) {
 340         if (!is_string($texte) OR !$texte
 341         OR strpbrk($texte, "&\"'<>")==false
 342         ) return $texte;
 343         include_spip('inc/texte');
 344         $texte = htmlspecialchars(echappe_retour(echappe_html($texte,'',true),'','proteger_amp'),$quote?ENT_QUOTES:(ENT_COMPAT|ENT_HTML401));
 345         if ($tout)
 346                 return corriger_toutes_entites_html($texte);
 347         else
 348                 return corriger_entites_html($texte);
 349 }
 350
 351 // Transformer les &eacute; dans le charset local
 352 // http://doc.spip.org/@filtrer_entites
 353 function filtrer_entites($texte) {
 354         if (strpos($texte,'&') === false) return $texte;
 355         // filtrer
 356         $texte = html2unicode($texte);
 357         // remettre le tout dans le charset cible
 358         return unicode2charset($texte);
 359 }
 360
 361 // caracteres de controle - http://www.w3.org/TR/REC-xml/#charsets
 362 // http://doc.spip.org/@supprimer_caracteres_illegaux
 363 function supprimer_caracteres_illegaux($texte) {
 364         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";
 365         static $to = null;
 366
 367         if (is_array($texte)) {
 368                 return array_map('corriger_caracteres_windows', $texte);
 369         }
 370
 371         if (!$to) $to = str_repeat('-', strlen($from));
 372         return strtr($texte, $from, $to);
 373 }
 374
 375 // Supprimer caracteres windows et les caracteres de controle ILLEGAUX
 376 // http://doc.spip.org/@corriger_caracteres
 377 function corriger_caracteres ($texte) {
 378         $texte = corriger_caracteres_windows($texte);
 379         $texte = supprimer_caracteres_illegaux($texte);
 380         return $texte;
 381 }
 382
 383 /**
 384  * Encode du HTML pour transmission XML
 385  * notamment dans les flux RSS
 386  *
 387  * http://doc.spip.org/@texte_backend
 388  *
 389  * @param $texte
 390  * @return mixed
 391  */
 392 function texte_backend($texte) {
 393
 394         static $apostrophe = array("&#8217;", "'"); # n'allouer qu'une fois
 395
 396         // si on a des liens ou des images, les passer en absolu
 397         $texte = liens_absolus($texte);
 398
 399         // echapper les tags &gt; &lt;
 400         $texte = preg_replace(',&(gt|lt);,S', '&amp;\1;', $texte);
 401
 402         // importer les &eacute;
 403         $texte = filtrer_entites($texte);
 404
 405         // " -> &quot; et tout ce genre de choses
 406         $u = $GLOBALS['meta']['pcre_u'];
 407         $texte = str_replace("&nbsp;", " ", $texte);
 408         $texte = preg_replace('/\s{2,}/S'.$u, " ", $texte);
 409         // ne pas echapper les sinqle quotes car certains outils de syndication gerent mal
 410         $texte = entites_html($texte, false, false);
 411
 412         // verifier le charset
 413         $texte = charset2unicode($texte);
 414
 415         // Caracteres problematiques en iso-latin 1
 416         if ($GLOBALS['meta']['charset'] == 'iso-8859-1') {
 417                 $texte = str_replace(chr(156), '&#156;', $texte);
 418                 $texte = str_replace(chr(140), '&#140;', $texte);
 419                 $texte = str_replace(chr(159), '&#159;', $texte);
 420         }
 421
 422         // l'apostrophe curly pose probleme a certains lecteure de RSS
 423         // et le caractere apostrophe alourdit les squelettes avec PHP
 424         // ==> on les remplace par l'entite HTML
 425         return str_replace($apostrophe, "'", $texte);
 426 }
 427
 428 // Comme ci-dessus, mais avec addslashes final pour squelettes avec PHP (rss)
 429
 430 function texte_backendq($texte) {
 431         return addslashes(texte_backend($texte));
 432 }
 433
 434 // Enleve le numero des titres numerotes ("1. Titre" -> "Titre")
 435 // http://doc.spip.org/@supprimer_numero
 436 function supprimer_numero($texte) {
 437         return preg_replace(
 438         ",^[[:space:]]*([0-9]+)([.)]|".chr(194).'?'.chr(176).")[[:space:]]+,S",
 439         "", $texte);
 440 }
 441
 442 // et la fonction inverse
 443 // http://doc.spip.org/@recuperer_numero
 444 function recuperer_numero($texte) {
 445         if (preg_match(
 446         ",^[[:space:]]*([0-9]+)([.)]|".chr(194).'?'.chr(176).")[[:space:]]+,S",
 447         $texte, $regs))
 448                 return intval($regs[1]);
 449         else
 450                 return '';
 451 }
 452
 453 // Suppression basique et brutale de tous les <...>
 454 // http://doc.spip.org/@supprimer_tags
 455 function supprimer_tags($texte, $rempl = "") {
 456         $texte = preg_replace(",<[^>]*>,US", $rempl, $texte);
 457         // ne pas oublier un < final non ferme
 458         // mais qui peut aussi etre un simple signe plus petit que
 459         $texte = str_replace('<', ' ', $texte);
 460         return $texte;
 461 }
 462
 463 // Convertit les <...> en la version lisible en HTML
 464 // http://doc.spip.org/@echapper_tags
 465 function echapper_tags($texte, $rempl = "") {
 466         $texte = preg_replace("/<([^>]*)>/", "&lt;\\1&gt;", $texte);
 467         return $texte;
 468 }
 469
 470 // Convertit un texte HTML en texte brut
 471 // http://doc.spip.org/@textebrut
 472 function textebrut($texte) {
 473         $u = $GLOBALS['meta']['pcre_u'];
 474         $texte = preg_replace('/\s+/S'.$u, " ", $texte);
 475         $texte = preg_replace("/<(p|br)( [^>]*)?".">/iS", "\n\n", $texte);
 476         $texte = preg_replace("/^\n+/", "", $texte);
 477         $texte = preg_replace("/\n+$/", "", $texte);
 478         $texte = preg_replace("/\n +/", "\n", $texte);
 479         $texte = supprimer_tags($texte);
 480         $texte = preg_replace("/(&nbsp;| )+/S", " ", $texte);
 481         // nettoyer l'apostrophe curly qui pose probleme a certains rss-readers, lecteurs de mail...
 482         $texte = str_replace("&#8217;","'",$texte);
 483         return $texte;
 484 }
 485
 486 // Remplace les liens SPIP en liens ouvrant dans une nouvelle fenetre (target=blank)
 487 // http://doc.spip.org/@liens_ouvrants
 488 function liens_ouvrants ($texte) {
 489         return preg_replace(",<a\s+([^>]*https?://[^>]*class=[\"']spip_(out|url)\b[^>]+)>,",
 490                 "<a \\1 target=\"_blank\">", $texte);
 491 }
 492
 493 // Transformer les sauts de paragraphe en simples passages a la ligne
 494 // http://doc.spip.org/@PtoBR
 495 function PtoBR($texte){
 496         $u = $GLOBALS['meta']['pcre_u'];
 497         $texte = preg_replace("@</p>@iS", "\n", $texte);
 498         $texte = preg_replace("@<p\b.*>@UiS", "<br />", $texte);
 499         $texte = preg_replace("@^\s*<br />@S".$u, "", $texte);
 500         return $texte;
 501 }
 502
 503
 504 /**
 505  * lignes_longues assure qu'un texte ne vas pas deborder d'un bloc
 506  * par la faute d'un mot trop long (souvent des URLs)
 507  * Ne devrait plus etre utilise et fait directement en CSS par un style
 508  * word-wrap:break-word;
 509  * cf http://www.alsacreations.com/tuto/lire/1038-gerer-debordement-contenu-css.html
 510  *
 511  * Pour assurer la compatibilite du filtre, on encapsule le contenu par
 512  * un div ou span portant ce style inline.
 513  *
 514  * http://doc.spip.org/@lignes_longues
 515  *
 516  * @param string $texte
 517  * @return string
 518  */
 519 function lignes_longues($texte) {
 520         if (!strlen(trim($texte))) return $texte;
 521         include_spip('inc/texte');
 522         $tag = preg_match(',</?('._BALISES_BLOCS.')[>[:space:]],iS', $texte) ?
 523                 'div' : 'span';
 524
 525         return "<$tag style='word-wrap:break-word;'>$texte</$tag>";
 526 }
 527
 528 // Majuscules y compris accents, en HTML
 529 // http://doc.spip.org/@majuscules
 530 function majuscules($texte) {
 531         if (!strlen($texte)) return '';
 532
 533         // Cas du turc
 534         if ($GLOBALS['spip_lang'] == 'tr') {
 535                 # remplacer hors des tags et des entites
 536                 if (preg_match_all(',<[^<>]+>|&[^;]+;,S', $texte, $regs, PREG_SET_ORDER))
 537                         foreach ($regs as $n => $match)
 538                                 $texte = str_replace($match[0], "@@SPIP_TURC$n@@", $texte);
 539
 540                 $texte = str_replace('i', '&#304;', $texte);
 541
 542                 if ($regs)
 543                         foreach ($regs as $n => $match)
 544                                 $texte = str_replace("@@SPIP_TURC$n@@", $match[0], $texte);
 545         }
 546
 547         // Cas general
 548         return "<span style='text-transform: uppercase;'>$texte</span>";
 549 }
 550
 551 // "127.4 ko" ou "3.1 Mo"
 552 // http://doc.spip.org/@taille_en_octets
 553 function taille_en_octets ($taille) {
 554         if ($taille < 1) return '';
 555         if ($taille < 1024) {$taille = _T('taille_octets', array('taille' => $taille));}
 556         else if ($taille < 1024*1024) {
 557                 $taille = _T('taille_ko', array('taille' => round($taille/1024, 1)));
 558         } else if ($taille < 1024*1024*1024) {
 559                 $taille = _T('taille_mo', array('taille' => round($taille/1024/1024, 1)));
 560         } else {
 561                 $taille = _T('taille_go', array('taille' => round($taille/1024/1024/1024, 2)));
 562         }
 563         return $taille;
 564 }
 565
 566
 567 // Rend une chaine utilisable sans dommage comme attribut HTML
 568 // http://doc.spip.org/@attribut_html
 569 function attribut_html($texte,$textebrut = true) {
 570         $u = $GLOBALS['meta']['pcre_u'];
 571         if ($textebrut)
 572                 $texte = preg_replace(array(",\n,",",\s(?=\s),msS".$u),array(" ",""),textebrut($texte));
 573         $texte = texte_backend($texte);
 574         $texte = str_replace(array("'",'"'),array('&#039;', '&#034;'), $texte);
 575
 576         return preg_replace(array("/&(amp;|#38;)/","/&(?![A-Za-z]{0,4}\w{2,3};|#[0-9]{2,5};)/"),array("&","&#38;") , $texte);
 577 }
 578
 579 // Vider les url nulles comme 'http://' ou 'mailto:'
 580 // et leur appliquer un htmlspecialchars() + gerer les &amp;
 581 // http://doc.spip.org/@vider_url
 582 function vider_url($url, $entites = true) {
 583         # un message pour abs_url
 584         $GLOBALS['mode_abs_url'] = 'url';
 585
 586         $url = trim($url);
 587         if (preg_match(",^(http:?/?/?|mailto:?)$,iS", $url))
 588                 return '';
 589
 590         if ($entites) $url = entites_html($url);
 591
 592         return $url;
 593 }
 594
 595 // Extraire une date de n'importe quel champ (a completer...)
 596 // http://doc.spip.org/@extraire_date
 597 function extraire_date($texte) {
 598         // format = 2001-08
 599         if (preg_match(",([1-2][0-9]{3})[^0-9]*(1[0-2]|0?[1-9]),",$texte,$regs))
 600                 return $regs[1]."-".sprintf("%02d", $regs[2])."-01";
 601 }
 602
 603 // Maquiller une adresse e-mail
 604 // http://doc.spip.org/@antispam
 605 function antispam($texte) {
 606         include_spip('inc/acces');
 607         $masque = creer_pass_aleatoire(3);
 608         return preg_replace("/@/", " $masque ", $texte);
 609 }
 610
 611 // http://doc.spip.org/@securiser_acces
 612 function securiser_acces($id_auteur, $cle, $dir, $op='', $args='')
 613 {
 614         include_spip('inc/acces');
 615         if ($op) $dir .= " $op $args";
 616         return verifier_low_sec($id_auteur, $cle, $dir);
 617 }
 618
 619 /**
 620  * La fonction sinon retourne le second parametre lorsque
 621  * le premier est considere vide, sinon retourne le premier parametre.
 622  *
 623  * En php sinon($a, 'rien') retourne $a ou 'rien' si $a est vide.
 624  * En filtre spip |sinon{#TEXTE, rien} : affiche #TEXTE ou "rien" si #TEXTE est vide,
 625  *
 626  * Note : l'utilisation de |sinon en tant que filtre de squelette
 627  * est directement compile dans public/references par la fonction filtre_logique()
 628  *
 629  * @param mixed $texte
 630  *              Contenu de reference a tester
 631  * @param mixed $sinon
 632  *              Contenu a retourner si le contenu de reference est vide
 633  * @return mixed
 634  *              Retourne $texte, sinon $sinon.
 635 **/
 636 function sinon ($texte, $sinon='') {
 637         if ($texte OR (!is_array($texte) AND strlen($texte)))
 638                 return $texte;
 639         else
 640                 return $sinon;
 641 }
 642
 643 // |choixsivide{vide,pasvide} affiche pasvide si la chaine n'est pas vide...
 644 // http://doc.spip.org/@choixsivide
 645 function choixsivide($a, $vide, $pasvide) {
 646         return $a ? $pasvide : $vide;
 647 }
 648
 649 // |choixsiegal{aquoi,oui,non} affiche oui si la chaine est egal a aquoi ...
 650 // http://doc.spip.org/@choixsiegal
 651 function choixsiegal($a1,$a2,$v,$f) {
 652         return ($a1 == $a2) ? $v : $f;
 653 }
 654
 655
 656 //
 657 // Date, heure, saisons
 658 //
 659
 660 // on normalise la date, si elle vient du contexte (public/parametrer.php), on force le jour
 661 // http://doc.spip.org/@normaliser_date
 662 function normaliser_date($date, $forcer_jour = false) {
 663         $date = vider_date($date);
 664         if ($date) {
 665                 if (preg_match("/^[0-9]{8,10}$/", $date))
 666                         $date = date("Y-m-d H:i:s", $date);
 667                 if (preg_match("#^([12][0-9]{3})([-/]00)?( [-0-9:]+)?$#", $date, $regs))
 668                         $date = $regs[1]."-00-00".$regs[3];
 669                 else if (preg_match("#^([12][0-9]{3}[-/][01]?[0-9])([-/]00)?( [-0-9:]+)?$#", $date, $regs))
 670                         $date = preg_replace("@/@","-",$regs[1])."-00".$regs[3];
 671                 else
 672                         $date = date("Y-m-d H:i:s", strtotime($date));
 673
 674                 if ($forcer_jour)
 675                         $date = str_replace('-00', '-01', $date);
 676         }
 677         return $date;
 678 }
 679
 680 // http://doc.spip.org/@vider_date
 681 function vider_date($letexte) {
 682         if (strncmp("0000-00-00", $letexte,10)==0) return '';
 683         if (strncmp("0001-01-01", $letexte,10)==0) return '';
 684         if (strncmp("1970-01-01", $letexte,10)==0) return '';   // eviter le bug GMT-1
 685         return $letexte;
 686 }
 687
 688 // http://doc.spip.org/@recup_heure
 689 function recup_heure($date){
 690
 691         static $d = array(0,0,0);
 692         if (!preg_match('#([0-9]{1,2}):([0-9]{1,2}):([0-9]{1,2})#', $date, $r))
 693                 return $d;
 694
 695         array_shift($r);
 696         return $r;
 697 }
 698
 699 // http://doc.spip.org/@heures
 700 function heures($numdate) {
 701         $date_array = recup_heure($numdate);
 702         if ($date_array)
 703                 list($heures, $minutes, $secondes) = $date_array;
 704         return $heures;
 705 }
 706
 707 // http://doc.spip.org/@minutes
 708 function minutes($numdate) {
 709         $date_array = recup_heure($numdate);
 710         if ($date_array)
 711                 list($heures, $minutes, $secondes) = $date_array;
 712         return $minutes;
 713 }
 714
 715 // http://doc.spip.org/@secondes
 716 function secondes($numdate) {
 717         $date_array = recup_heure($numdate);
 718         if ($date_array)
 719                 list($heures,$minutes,$secondes) = $date_array;
 720         return $secondes;
 721 }
 722
 723 // http://doc.spip.org/@heures_minutes
 724 function heures_minutes($numdate) {
 725         return _T('date_fmt_heures_minutes', array('h'=> heures($numdate), 'm'=> minutes($numdate)));
 726 }
 727
 728 // http://doc.spip.org/@recup_date
 729 function recup_date($numdate, $forcer_jour = true){
 730         if (!$numdate) return '';
 731         $heures = $minutes = $secondes = 0;
 732         if (preg_match('#([0-9]{1,2})/([0-9]{1,2})/([0-9]{4}|[0-9]{1,2})#', $numdate, $regs)) {
 733                 $jour = $regs[1];
 734                 $mois = $regs[2];
 735                 $annee = $regs[3];
 736                 if ($annee < 90){
 737                         $annee = 2000 + $annee;
 738                 } elseif ($annee<100) {
 739                         $annee = 1900 + $annee ;
 740                 }
 741                 list($heures, $minutes, $secondes) = recup_heure($numdate);
 742
 743         }
 744         elseif (preg_match('#([0-9]{4})-([0-9]{1,2})-([0-9]{1,2})#',$numdate, $regs)) {
 745                 $annee = $regs[1];
 746                 $mois = $regs[2];
 747                 $jour = $regs[3];
 748                 list($heures, $minutes, $secondes) = recup_heure($numdate);
 749         }
 750         elseif (preg_match('#([0-9]{4})-([0-9]{2})#', $numdate, $regs)){
 751                 $annee = $regs[1];
 752                 $mois = $regs[2];
 753                 $jour ='';
 754                 list($heures, $minutes, $secondes) = recup_heure($numdate);
 755         }
 756         elseif (preg_match('#^([0-9]{4})([0-9]{2})([0-9]{2})([0-9]{2})([0-9]{2})([0-9]{2})$#', $numdate, $regs)){
 757                 $annee = $regs[1];
 758                 $mois = $regs[2];
 759                 $jour = $regs[3];
 760                 $heures = $regs[4];
 761                 $minutes = $regs[5];
 762                 $secondes = $regs[6];
 763         } else $annee = $mois =  $jour ='';
 764         if ($annee > 4000) $annee -= 9000;
 765         if (substr($jour, 0, 1) == '0') $jour = substr($jour, 1);
 766
 767         if ($forcer_jour AND $jour == '0') $jour = '1';
 768         if ($forcer_jour AND $mois == '0') $mois = '1';
 769         if ($annee OR $mois OR $jour OR $heures OR $minutes OR $secondes)
 770                 return array($annee, $mois, $jour, $heures, $minutes, $secondes);
 771 }
 772
 773 // une date pour l'interface : utilise date_relative si le decalage
 774 // avec time() est de moins de douze heures, sinon la date complete
 775 // http://doc.spip.org/@date_interface
 776 function date_interface($date, $decalage_maxi = 43200/* 12*3600 */) {
 777         return sinon(
 778                 date_relative($date, $decalage_maxi),
 779                 affdate_heure($date)
 780         );
 781 }
 782
 783 // http://doc.spip.org/@date_relative
 784 function date_relative($date, $decalage_maxi=0,$ref_date=null) {
 785
 786         if (is_null($ref_date))
 787                 $ref_time = time();
 788         else
 789                 $ref_time = strtotime($ref_date);
 790
 791         if (!$date) return;
 792         $decal = date("U",$ref_time) - date("U", strtotime($date));
 793
 794         if ($decalage_maxi AND ($decal > $decalage_maxi OR $decal < 0))
 795                 return '';
 796
 797         if ($decal < 0) {
 798                 $il_y_a = "date_dans";
 799                 $decal = -1 * $decal;
 800         } else {
 801                 $il_y_a = "date_il_y_a";
 802         }
 803
 804         if ($decal > 3600 * 24 * 30 * 6)
 805                 return affdate_court($date);
 806
 807         if ($decal > 3600 * 24 * 30) {
 808                 $mois = floor ($decal / (3600 * 24 * 30));
 809                 if ($mois < 2)
 810                         $delai = "$mois "._T("date_un_mois");
 811                 else
 812                         $delai = "$mois "._T("date_mois");
 813         }
 814         else if ($decal > 3600 * 24 * 7) {
 815                 $semaines = floor ($decal / (3600 * 24 * 7));
 816                 if ($semaines < 2)
 817                         $delai = "$semaines "._T("date_une_semaine");
 818                 else
 819                         $delai = "$semaines "._T("date_semaines");
 820         }
 821         else if ($decal > 3600 * 24) {
 822                 $jours = floor ($decal / (3600 * 24));
 823                 if ($jours < 2)
 824                         return $il_y_a=="date_dans"?_T("date_demain"):_T("date_hier");
 825                 else
 826                         $delai = "$jours "._T("date_jours");
 827         }
 828         else if ($decal >= 3600) {
 829                 $heures = floor ($decal / 3600);
 830                 if ($heures < 2)
 831                         $delai = "$heures "._T("date_une_heure");
 832                 else
 833                         $delai = "$heures "._T("date_heures");
 834         }
 835         else if ($decal >= 60) {
 836                 $minutes = floor($decal / 60);
 837                 if ($minutes < 2)
 838                         $delai = "$minutes "._T("date_une_minute");
 839                 else
 840                         $delai = "$minutes "._T("date_minutes");
 841         } else {
 842                 $secondes = ceil($decal);
 843                 if ($secondes < 2)
 844                         $delai = "$secondes "._T("date_une_seconde");
 845                 else
 846                         $delai = "$secondes "._T("date_secondes");
 847         }
 848
 849         return _T($il_y_a, array("delai"=> $delai));
 850 }
 851
 852
 853 // http://doc.spip.org/@date_relativecourt
 854 function date_relativecourt($date, $decalage_maxi=0) {
 855
 856         if (!$date) return;
 857         $decal = date("U",strtotime(date('Y-m-d'))-strtotime(date('Y-m-d',strtotime($date))));
 858
 859         if ($decalage_maxi AND ($decal > $decalage_maxi OR $decal < 0))
 860                 return '';
 861
 862         if ($decal < -24*3600) {
 863                 $retour = date_relative($date, $decalage_maxi);
 864         }
 865         elseif ($decal < 0) {
 866                 $retour = _T("date_demain");
 867         }
 868         else if ($decal < (3600 * 24) ) {
 869                 $retour = _T("date_aujourdhui");
 870         }
 871         else if ($decal < (3600 * 24 *2) ) {
 872                 $retour = _T("date_hier");
 873         }
 874         else {
 875                 $retour = date_relative($date, $decalage_maxi);
 876         }
 877
 878
 879
 880         return $retour;
 881 }
 882
 883 /**
 884  * Formatage humain de la date $numdate selon le format $vue
 885  * http://doc.spip.org/@affdate_base
 886  *
 887  * @param $numdate
 888  * @param $vue
 889  * @param array $options
 890  *   param : 'abbr' ou 'initiale' permet d'afficher les jours au format court ou initiale
 891  *   annee_courante : permet de definir l'annee de reference pour l'affichage des dates courtes
 892  * @return mixed|string
 893  */
 894 function affdate_base($numdate, $vue, $options = array()) {
 895         if (is_string($options))
 896                 $options = array('param'=>$options);
 897         $date_array = recup_date($numdate, false);
 898         if (!$date_array) return;
 899         list($annee, $mois, $jour, $heures, $minutes, $secondes)= $date_array;
 900
 901         // 1er, 21st, etc.
 902         $journum = $jour;
 903
 904         if ($jour == 0) {
 905                 $jour = '';
 906         } else {
 907                 $njour = intval($jour);
 908                 if ($jourth = _T('date_jnum'.$jour))
 909                         $jour = $jourth;
 910         }
 911
 912         $mois = intval($mois);
 913         if ($mois > 0 AND $mois < 13) {
 914                 $nommois = _T('date_mois_'.$mois);
 915                 if ($jour)
 916                         $jourmois = _T('date_de_mois_'.$mois, array('j'=>$jour, 'nommois'=>$nommois));
 917                 else
 918                         $jourmois = $nommois;
 919         } else $nommois = '';
 920
 921         if ($annee < 0) {
 922                 $annee = -$annee." "._T('date_avant_jc');
 923                 $avjc = true;
 924         }
 925         else $avjc = false;
 926
 927         switch ($vue) {
 928         case 'saison':
 929                 $saison = '';
 930                 if ($mois > 0){
 931                         $saison = 1;
 932                         if (($mois == 3 AND $jour >= 21) OR $mois > 3) $saison = 2;
 933                         if (($mois == 6 AND $jour >= 21) OR $mois > 6) $saison = 3;
 934                         if (($mois == 9 AND $jour >= 21) OR $mois > 9) $saison = 4;
 935                         if (($mois == 12 AND $jour >= 21) OR $mois > 12) $saison = 1;
 936                 }
 937                 return $saison?_T('date_saison_'.$saison):'';
 938
 939         case 'court':
 940                 if ($avjc) return $annee;
 941                 $a = ((isset($options['annee_courante']) AND $options['annee_courante'])?$options['annee_courante']:date('Y'));
 942                 if ($annee < ($a - 100) OR $annee > ($a + 100)) return $annee;
 943                 if ($annee != $a) return _T('date_fmt_mois_annee', array ('mois'=>$mois, 'nommois'=>spip_ucfirst($nommois), 'annee'=>$annee));
 944                 return _T('date_fmt_jour_mois', array ('jourmois'=>$jourmois, 'jour'=>$jour, 'mois'=>$mois, 'nommois'=>$nommois, 'annee'=>$annee));
 945
 946         case 'jourcourt':
 947                 if ($avjc) return $annee;
 948                 $a = ((isset($options['annee_courante']) AND $options['annee_courante'])?$options['annee_courante']:date('Y'));
 949                 if ($annee < ($a - 100) OR $annee > ($a + 100)) return $annee;
 950                 if ($annee != $a) return _T('date_fmt_jour_mois_annee', array ('jourmois'=>$jourmois, 'jour'=>$jour, 'mois'=>$mois, 'nommois'=>$nommois, 'annee'=>$annee));
 951                 return _T('date_fmt_jour_mois', array ('jourmois'=>$jourmois, 'jour'=>$jour, 'mois'=>$mois, 'nommois'=>$nommois, 'annee'=>$annee));
 952
 953         case 'entier':
 954                 if ($avjc) return $annee;
 955                 if ($jour)
 956                         return _T('date_fmt_jour_mois_annee', array ('jourmois'=>$jourmois, 'jour'=>$jour, 'mois'=>$mois, 'nommois'=>$nommois, 'annee'=>$annee));
 957                 elseif ($mois)
 958                         return trim(_T('date_fmt_mois_annee', array ('mois'=>$mois, 'nommois'=>$nommois, 'annee'=>$annee)));
 959                 else
 960                         return $annee;
 961
 962         case 'nom_mois':
 963                 $param = ((isset($options['param']) AND $options['param']) ? '_'.$options['param'] : '');
 964                 if ($param and $mois) {
 965                         return _T('date_mois_'.$mois.$param);
 966                 }
 967                 return $nommois;
 968
 969         case 'mois':
 970                 return sprintf("%02s",$mois);
 971
 972         case 'jour':
 973                 return $jour;
 974
 975         case 'journum':
 976                 return $journum;
 977
 978         case 'nom_jour':
 979                 if (!$mois OR !$njour)
 980                         return '';
 981                 $nom = mktime(1,1,1,$mois,$njour,$annee);
 982                 $nom = 1+date('w',$nom);
 983                 $param = ((isset($options['param']) AND $options['param']) ? '_'.$options['param'] : '');
 984                 return _T('date_jour_'.$nom.$param);
 985
 986         case 'mois_annee':
 987                 if ($avjc) return $annee;
 988                 return trim(_T('date_fmt_mois_annee', array('mois'=>$mois, 'nommois'=>$nommois, 'annee'=>$annee)));
 989
 990         case 'annee':
 991                 return $annee;
 992
 993         // Cas d'une vue non definie : retomber sur le format
 994         // de date propose par http://www.php.net/date
 995         default:
 996                 return date($vue, strtotime($numdate));
 997         }
 998 }
 999
1000 // http://doc.spip.org/@nom_jour
1001 function nom_jour($numdate, $forme = '') {
1002         if(!($forme == 'abbr' OR $forme == 'initiale')) $forme = '';
1003         return affdate_base($numdate, 'nom_jour', $forme);
1004 }
1005
1006 // http://doc.spip.org/@jour
1007 function jour($numdate) {
1008         return affdate_base($numdate, 'jour');
1009 }
1010
1011 // http://doc.spip.org/@journum
1012 function journum($numdate) {
1013         return affdate_base($numdate, 'journum');
1014 }
1015
1016 // http://doc.spip.org/@mois
1017 function mois($numdate) {
1018         return affdate_base($numdate, 'mois');
1019 }
1020
1021 // http://doc.spip.org/@nom_mois
1022 function nom_mois($numdate, $forme='') {
1023         if(!($forme == 'abbr')) $forme = '';
1024         return affdate_base($numdate, 'nom_mois', $forme);
1025 }
1026
1027 // http://doc.spip.org/@annee
1028 function annee($numdate) {
1029         return affdate_base($numdate, 'annee');
1030 }
1031
1032 // http://doc.spip.org/@saison
1033 function saison($numdate) {
1034         return affdate_base($numdate, 'saison');
1035 }
1036
1037 // http://doc.spip.org/@affdate
1038 function affdate($numdate, $format='entier') {
1039         return affdate_base($numdate, $format);
1040 }
1041
1042 // http://doc.spip.org/@affdate_court
1043 function affdate_court($numdate, $annee_courante=null) {
1044         return affdate_base($numdate, 'court', array('annee_courante'=>$annee_courante));
1045 }
1046
1047 // http://doc.spip.org/@affdate_jourcourt
1048 function affdate_jourcourt($numdate, $annee_courante=null) {
1049         return affdate_base($numdate, 'jourcourt', array('annee_courante'=>$annee_courante));
1050 }
1051
1052 // http://doc.spip.org/@affdate_mois_annee
1053 function affdate_mois_annee($numdate) {
1054         return affdate_base($numdate, 'mois_annee');
1055 }
1056
1057 // http://doc.spip.org/@affdate_heure
1058 function affdate_heure($numdate) {
1059         $date_array = recup_date($numdate);
1060         if (!$date_array) return;
1061         list($annee, $mois, $jour, $heures, $minutes, $sec)= $date_array;
1062         return _T('date_fmt_jour_heure', array('jour' => affdate($numdate), 'heure' =>  _T('date_fmt_heures_minutes', array('h'=> $heures, 'm'=> $minutes))));
1063 }
1064
1065 /**
1066  * Afficher de facon textuelle les dates de debut et fin en fonction des cas
1067  * - Lundi 20 fevrier a 18h
1068  * - Le 20 fevrier de 18h a 20h
1069  * - Du 20 au 23 fevrier
1070  * - Du 20 fevrier au 30 mars
1071  * - Du 20 fevrier 2007 au 30 mars 2008
1072  * $horaire='oui' ou true permet d'afficher l'horaire, toute autre valeur n'indique que le jour
1073  * $forme peut contenir une ou plusieurs valeurs parmi
1074  *  - abbr (afficher le nom des jours en abbrege)
1075  *  - hcal (generer une date au format hcal)
1076  *  - jour (forcer l'affichage des jours)
1077  *  - annee (forcer l'affichage de l'annee)
1078  *
1079  * @param string $date_debut
1080  * @param string $date_fin
1081  * @param string $horaire
1082  * @param string $forme
1083  * @return string
1084  */
1085 function affdate_debut_fin($date_debut, $date_fin, $horaire = 'oui', $forme=''){
1086         $abbr = $jour = '';
1087         $affdate = "affdate_jourcourt";
1088         if (strpos($forme,'abbr') !==false) $abbr = 'abbr';
1089         if (strpos($forme,'annee')!==false) $affdate = 'affdate';
1090         if (strpos($forme,'jour') !==false) $jour = 'jour';
1091
1092         $dtstart = $dtend = $dtabbr = "";
1093         if (strpos($forme,'hcal')!==false) {
1094                 $dtstart = "<abbr class='dtstart' title='".date_iso($date_debut)."'>";
1095                 $dtend = "<abbr class='dtend' title='".date_iso($date_fin)."'>";
1096                 $dtabbr = "</abbr>";
1097         }
1098
1099         $date_debut = strtotime($date_debut);
1100         $date_fin = strtotime($date_fin);
1101         $d = date("Y-m-d", $date_debut);
1102         $f = date("Y-m-d", $date_fin);
1103         $h = ($horaire==='oui' OR $horaire===true);
1104         $hd = _T('date_fmt_heures_minutes_court', array('h'=> date("H",$date_debut), 'm'=> date("i",$date_debut)));
1105         $hf = _T('date_fmt_heures_minutes_court', array('h'=> date("H",$date_fin), 'm'=> date("i",$date_fin)));
1106
1107         if ($d==$f)
1108         { // meme jour
1109                 $nomjour = nom_jour($d,$abbr);
1110                 $s = $affdate($d);
1111                 $s = _T('date_fmt_jour',array('nomjour'=>$nomjour,'jour' => $s));
1112                 if ($h){
1113                         if ($hd==$hf){
1114                                 // Lundi 20 fevrier a 18h25
1115                                 $s = spip_ucfirst(_T('date_fmt_jour_heure',array('jour'=>$s,'heure'=>$hd)));
1116                                 $s = "$dtstart$s$dtabbr";
1117                         }else{
1118                                 // Le <abbr...>lundi 20 fevrier de 18h00</abbr> a <abbr...>20h00</abbr>
1119                                 if($dtabbr && $dtstart && $dtend)
1120                                         $s = spip_ucfirst(_T('date_fmt_jour_heure_debut_fin_abbr',array('jour'=>$s,'heure_debut'=>$hd,'heure_fin'=>$hf,'dtstart'=>$dtstart,'dtend'=>$dtend,'dtabbr'=>$dtabbr)));
1121                                 // Le lundi 20 fevrier de 18h00 a 20h00
1122                                 else
1123                                         $s = spip_ucfirst(_T('date_fmt_jour_heure_debut_fin',array('jour'=>$s,'heure_debut'=>$hd,'heure_fin'=>$hf)));
1124                         }
1125                 }else{
1126                         if($dtabbr && $dtstart)
1127                                 $s = $dtstart.spip_ucfirst($s).$dabbr;
1128                         else
1129                                 $s = spip_ucfirst($s);
1130                 }
1131         }
1132         else if ((date("Y-m",$date_debut))==date("Y-m",$date_fin))
1133         { // meme annee et mois, jours differents
1134                 if(!$h)
1135                         $date_debut = jour($d);
1136                 else
1137                         $date_debut = $affdate($d);
1138                 $date_fin = $affdate($f);
1139                 if($jour){
1140                         $nomjour_debut = nom_jour($d,$abbr);
1141                         $date_debut = _T('date_fmt_jour',array('nomjour'=>$nomjour_debut,'jour' => $date_debut));
1142                         $nomjour_fin = nom_jour($f,$abbr);
1143                         $date_fin = _T('date_fmt_jour',array('nomjour'=>$nomjour_fin,'jour' => $date_fin));
1144                 }
1145                 if ($h){
1146                         $date_debut = _T('date_fmt_jour_heure',array('jour'=>$date_debut,'heure'=>$hd));
1147                         $date_fin = _T('date_fmt_jour_heure',array('jour'=>$date_fin,'heure'=>$hf));
1148                 }
1149                 $date_debut = $dtstart.$date_debut.$dtabbr;
1150                 $date_fin = $dtend.$date_fin.$dtabbr;
1151
1152                 $s = _T('date_fmt_periode',array('date_debut' => $date_debut,'date_fin'=>$date_fin));
1153         }
1154         else {
1155                 $date_debut = affdate($d);
1156                 $date_fin = affdate($f);
1157                 if($jour){
1158                         $nomjour_debut = nom_jour($d,$abbr);
1159                         $date_debut = _T('date_fmt_jour_periode',array('nomjour'=>$nomjour_debut,'jour' => $date_debut));
1160                         $nomjour_fin = nom_jour($f,$abbr);
1161                         $date_fin = _T('date_fmt_jour_periode',array('nomjour'=>$nomjour_fin,'jour' => $date_fin));
1162                 }
1163                 if ($h){
1164                         $date_debut = _T('date_fmt_jour_heure',array('jour'=>$date_debut,'heure'=>$hd));
1165                         $date_fin = _T('date_fmt_jour_heure',array('jour'=>$date_fin,'heure'=>$hf));
1166                 }
1167
1168                 $date_debut = $dtstart.$date_debut.$dtabbr;
1169                 $date_fin=$dtend.$date_fin.$dtabbr;
1170                 $s = _T('date_fmt_periode',array('date_debut' => $date_debut,'date_fin'=>$date_fin));
1171
1172         }
1173         return $s;
1174 }
1175
1176 /**
1177  * Alignements en HTML (Old-style, preferer CSS)
1178  * Cette fonction ne cree pas de paragraphe
1179  *
1180  * http://doc.spip.org/@aligner
1181  *
1182  * @param  $letexte
1183  * @param string $justif
1184  * @return string
1185  */
1186 function aligner($letexte, $justif='') {
1187         $letexte = trim($letexte);
1188         if (!strlen($letexte)) return '';
1189
1190         // Paragrapher rapidement
1191         $letexte = "<div style='text-align:$justif'>"
1192                 . $letexte
1193           ."</div>";
1194
1195         return $letexte;
1196 }
1197 // http://doc.spip.org/@justifier
1198 function justifier($letexte) { return aligner($letexte,'justify');}
1199 // http://doc.spip.org/@aligner_droite
1200 function aligner_droite($letexte) { return aligner($letexte,'right');}
1201 // http://doc.spip.org/@aligner_gauche
1202 function aligner_gauche($letexte) {return aligner($letexte,'left');}
1203 // http://doc.spip.org/@centrer
1204 function centrer($letexte) {return aligner($letexte,'center');}
1205
1206 // http://doc.spip.org/@style_align
1207 function style_align($bof) {
1208         global $spip_lang_left;
1209         return "text-align: $spip_lang_left";
1210 }
1211
1212 //
1213 // Export iCal
1214 //
1215
1216 // http://doc.spip.org/@filtrer_ical
1217 function filtrer_ical($texte) {
1218         #include_spip('inc/charsets');
1219         $texte = html2unicode($texte);
1220         $texte = unicode2charset(charset2unicode($texte, $GLOBALS['meta']['charset'], 1), 'utf-8');
1221         $texte = preg_replace("/\n/", " ", $texte);
1222         $texte = preg_replace("/,/", "\,", $texte);
1223
1224         return $texte;
1225 }
1226
1227 // http://doc.spip.org/@date_ical
1228 function date_ical($date, $addminutes = 0) {
1229         list($heures, $minutes, $secondes) = recup_heure($date);
1230         list($annee, $mois, $jour) = recup_date($date);
1231         return date("Ymd\THis",
1232                     mktime($heures, $minutes+$addminutes,$secondes,$mois,$jour,$annee));
1233 }
1234
1235 // date_iso retourne la date au format "RFC 3339" / "ISO 8601"
1236 // voir http://www.php.net/manual/fr/ref.datetime.php#datetime.constants
1237 // http://doc.spip.org/@date_iso
1238 function date_iso($date_heure) {
1239         list($annee, $mois, $jour) = recup_date($date_heure);
1240         list($heures, $minutes, $secondes) = recup_heure($date_heure);
1241         $time = @mktime($heures, $minutes, $secondes, $mois, $jour, $annee);
1242         return gmdate('Y-m-d\TH:i:s\Z', $time);
1243 }
1244
1245 // date_822 retourne la date au format "RFC 822"
1246 // utilise pour <pubdate> dans certains feeds RSS
1247 // http://doc.spip.org/@date_822
1248 function date_822($date_heure) {
1249         list($annee, $mois, $jour) = recup_date($date_heure);
1250         list($heures, $minutes, $secondes) = recup_heure($date_heure);
1251         $time = mktime($heures, $minutes, $secondes, $mois, $jour, $annee);
1252         return date('r', $time);
1253 }
1254
1255 // http://doc.spip.org/@date_anneemoisjour
1256 function date_anneemoisjour($d)  {
1257         if (!$d) $d = date("Y-m-d");
1258         return  substr($d, 0, 4) . substr($d, 5, 2) .substr($d, 8, 2);
1259 }
1260
1261 // http://doc.spip.org/@date_anneemois
1262 function date_anneemois($d)  {
1263         if (!$d) $d = date("Y-m-d");
1264         return  substr($d, 0, 4) . substr($d, 5, 2);
1265 }
1266
1267 // http://doc.spip.org/@date_debut_semaine
1268 function date_debut_semaine($annee, $mois, $jour) {
1269   $w_day = date("w", mktime(0,0,0,$mois, $jour, $annee));
1270   if ($w_day == 0) $w_day = 7; // Gaffe: le dimanche est zero
1271   $debut = $jour-$w_day+1;
1272   return date("Ymd", mktime(0,0,0,$mois,$debut,$annee));
1273 }
1274
1275 // http://doc.spip.org/@date_fin_semaine
1276 function date_fin_semaine($annee, $mois, $jour) {
1277   $w_day = date("w", mktime(0,0,0,$mois, $jour, $annee));
1278   if ($w_day == 0) $w_day = 7; // Gaffe: le dimanche est zero
1279   $debut = $jour-$w_day+1;
1280   return date("Ymd", mktime(0,0,0,$mois,$debut+6,$annee));
1281 }
1282
1283
1284 //
1285 // Recuperation de donnees dans le champ extra
1286 // Ce filtre n'a de sens qu'avec la balise #EXTRA
1287 //
1288 // http://doc.spip.org/@extra
1289 function extra($letexte, $champ) {
1290         $champs = unserialize($letexte);
1291         return $champs[$champ];
1292 }
1293
1294 // postautobr : transforme les sauts de ligne en _
1295 // http://doc.spip.org/@post_autobr
1296 function post_autobr($texte, $delim="\n_ ") {
1297         if (!function_exists('echappe_html'))
1298                 include_spip('inc/texte_mini');
1299         $texte = str_replace("\r\n", "\r", $texte);
1300         $texte = str_replace("\r", "\n", $texte);
1301
1302         if (preg_match(",\n+$,", $texte, $fin))
1303                 $texte = substr($texte, 0, -strlen($fin = $fin[0]));
1304         else
1305                 $fin = '';
1306
1307         $texte = echappe_html($texte, '', true);
1308
1309         // echapper les modeles
1310         if (strpos($texte,"<")!==false){
1311                 include_spip('inc/lien');
1312                 if (defined('_PREG_MODELE')){
1313                         $preg_modeles = "@"._PREG_MODELE."@imsS";
1314                         $texte = echappe_html($texte, '', true, $preg_modeles);
1315                 }
1316         }
1317
1318         $debut = '';
1319         $suite = $texte;
1320         while ($t = strpos('-'.$suite, "\n", 1)) {
1321                 $debut .= substr($suite, 0, $t-1);
1322                 $suite = substr($suite, $t);
1323                 $car = substr($suite, 0, 1);
1324                 if (($car<>'-') AND ($car<>'_') AND ($car<>"\n") AND ($car<>"|") AND ($car<>"}")
1325                 AND !preg_match(',^\s*(\n|</?(quote|div|dl|dt|dd)|$),S',($suite))
1326                 AND !preg_match(',</?(quote|div|dl|dt|dd)> *$,iS', $debut)) {
1327                         $debut .= $delim;
1328                 } else
1329                         $debut .= "\n";
1330                 if (preg_match(",^\n+,", $suite, $regs)) {
1331                         $debut.=$regs[0];
1332                         $suite = substr($suite, strlen($regs[0]));
1333                 }
1334         }
1335         $texte = $debut.$suite;
1336
1337         $texte = echappe_retour($texte);
1338         return $texte.$fin;
1339 }
1340
1341
1342 define('_EXTRAIRE_MULTI', "@<multi>(.*?)</multi>@sS");
1343
1344 // Extraire et transformer les blocs multi ; on indique la langue courante
1345 // pour ne pas mettre de span@lang=fr si on est deja en fr
1346 // http://doc.spip.org/@extraire_multi
1347 function extraire_multi($letexte, $lang=null, $echappe_span=false) {
1348         if (preg_match_all(_EXTRAIRE_MULTI, $letexte, $regs, PREG_SET_ORDER)) {
1349                 if (!$lang) $lang = $GLOBALS['spip_lang'];
1350
1351                 foreach ($regs as $reg) {
1352                         // chercher la version de la langue courante
1353                         $trads = extraire_trads($reg[1]);
1354                         if ($l = approcher_langue($trads, $lang)) {
1355                                 $trad = $trads[$l];
1356                         } else {
1357                                 include_spip('inc/texte');
1358                                 // langue absente, prendre la premiere dispo
1359                                 // mais typographier le texte selon les regles de celle-ci
1360                                 // Attention aux blocs multi sur plusieurs lignes
1361                                 $l = key($trads);
1362                                 $trad = $trads[$l];
1363                                 $typographie = charger_fonction(lang_typo($l), 'typographie');
1364                                 $trad = $typographie($trad);
1365                                 include_spip('inc/texte');
1366                                 // Tester si on echappe en span ou en div
1367                                 // il ne faut pas echapper en div si propre produit un seul paragraphe
1368                                 $trad_propre = preg_replace(",(^<p[^>]*>|</p>$),Uims","",propre($trad));
1369                                 $mode = preg_match(',</?('._BALISES_BLOCS.')[>[:space:]],iS', $trad_propre) ? 'div' : 'span';
1370                                 $trad = code_echappement($trad, 'multi', false, $mode);
1371                                 $trad = str_replace("'", '"', inserer_attribut($trad, 'lang', $l));
1372                                 if (lang_dir($l) !== lang_dir($lang))
1373                                         $trad = str_replace("'", '"', inserer_attribut($trad, 'dir', lang_dir($l)));
1374                                 if (!$echappe_span)
1375                                         $trad = echappe_retour($trad, 'multi');
1376                         }
1377                         $letexte = str_replace($reg[0], $trad, $letexte);
1378                 }
1379         }
1380
1381         return $letexte;
1382 }
1383
1384 // convertit le contenu d'une balise multi en un tableau
1385 // http://doc.spip.org/@extraire_trad
1386 function extraire_trads($bloc) {
1387         $lang = '';
1388 // ce reg fait planter l'analyse multi s'il y a de l'{italique} dans le champ
1389 //      while (preg_match("/^(.*?)[{\[]([a-z_]+)[}\]]/siS", $bloc, $regs)) {
1390         while (preg_match("/^(.*?)[\[]([a-z_]+)[\]]/siS", $bloc, $regs)) {
1391                 $texte = trim($regs[1]);
1392                 if ($texte OR $lang)
1393                         $trads[$lang] = $texte;
1394                 $bloc = substr($bloc, strlen($regs[0]));
1395                 $lang = $regs[2];
1396         }
1397         $trads[$lang] = $bloc;
1398
1399         return $trads;
1400 }
1401
1402 //
1403 // Ce filtre retourne la donnee si c'est la premiere fois qu'il la voit ;
1404 // possibilite de gerer differentes "familles" de donnees |unique{famille}
1405 # |unique{famille,1} affiche le nombre d'elements affiches (preferer toutefois #TOTAL_UNIQUE)
1406 # ameliorations possibles :
1407 # 1) si la donnee est grosse, mettre son md5 comme cle
1408 # 2) purger $mem quand on change de squelette (sinon bug inclusions)
1409 //
1410 // http://www.spip.net/@unique
1411 // http://doc.spip.org/@unique
1412 function unique($donnee, $famille='', $cpt = false) {
1413         static $mem = array();
1414         // permettre de vider la pile et de la restaurer
1415         // pour le calcul de introduction...
1416         if ($famille=='_spip_raz_'){
1417                 $tmp = $mem;
1418                 $mem = array();
1419                 return $tmp;
1420         } elseif ($famille=='_spip_set_'){
1421                 $mem = $donnee;
1422                 return;
1423         }
1424         // eviter une notice
1425         if (!isset($mem[$famille])) {
1426                 $mem[$famille] = array();
1427         }
1428         if ($cpt) {
1429                 return count($mem[$famille]);
1430         }
1431         // eviter une notice
1432         if (!isset($mem[$famille][$donnee])) {
1433                 $mem[$famille][$donnee] = 0;
1434         }
1435         if (!($mem[$famille][$donnee]++)) {
1436                 return $donnee;
1437         }
1438 }
1439
1440 //
1441 // Filtre |alterner
1442 //
1443 // Exemple [(#COMPTEUR_BOUCLE|alterner{'bleu','vert','rouge'})]
1444 //
1445 // http://doc.spip.org/@alterner
1446 function alterner($i) {
1447         // recuperer les arguments (attention fonctions un peu space)
1448         $num = func_num_args();
1449         $args = func_get_args();
1450
1451         if($num == 2 && is_array($args[1])) {
1452     $args = $args[1];
1453     array_unshift($args,'');
1454     $num = count($args);
1455   }
1456
1457         // renvoyer le i-ieme argument, modulo le nombre d'arguments
1458         return $args[(intval($i)-1)%($num-1)+1];
1459 }
1460
1461 // recuperer un attribut d'une balise html
1462 // ($complet demande de retourner $r)
1463 // la regexp est mortelle : cf. tests/filtres/extraire_attribut.php
1464 // Si on a passe un tableau de balises, renvoyer un tableau de resultats
1465 // (dans ce cas l'option $complet n'est pas disponible)
1466 // http://doc.spip.org/@extraire_attribut
1467 function extraire_attribut($balise, $attribut, $complet = false) {
1468         if (is_array($balise)) {
1469                 array_walk($balise,
1470                         create_function('&$a,$key,$t',
1471                                 '$a = extraire_attribut($a,$t);'
1472                         ),
1473                         $attribut);
1474                 return $balise;
1475         }
1476         if (preg_match(
1477         ',(^.*?<(?:(?>\s*)(?>[\w:.-]+)(?>(?:=(?:"[^"]*"|\'[^\']*\'|[^\'"]\S*))?))*?)(\s+'
1478         .$attribut
1479         .'(?:=\s*("[^"]*"|\'[^\']*\'|[^\'"]\S*))?)()([^>]*>.*),isS',
1480
1481         $balise, $r)) {
1482                 if ($r[3][0] == '"' || $r[3][0] == "'") {
1483                         $r[4] = substr($r[3], 1, -1);
1484                         $r[3] = $r[3][0];
1485                 } elseif ($r[3]!=='') {
1486                         $r[4] = $r[3];
1487                         $r[3] = '';
1488                 } else {
1489                         $r[4] = trim($r[2]);
1490                 }
1491                 $att = filtrer_entites(str_replace("&#39;", "'", $r[4]));
1492         }
1493         else
1494                 $att = NULL;
1495
1496         if ($complet)
1497                 return array($att, $r);
1498         else
1499                 return $att;
1500 }
1501
1502 /**
1503  * modifier (ou inserer) un attribut html dans une balise
1504  *
1505  * http://doc.spip.org/@inserer_attribut
1506  *
1507  * @param string $balise
1508  * @param string $attribut
1509  * @param string $val
1510  * @param bool $proteger
1511  * @param bool $vider
1512  * @return string
1513  */
1514 function inserer_attribut($balise, $attribut, $val, $proteger=true, $vider=false) {
1515         // preparer l'attribut
1516         // supprimer les &nbsp; etc mais pas les balises html
1517         // qui ont un sens dans un attribut value d'un input
1518         if ($proteger) $val = attribut_html($val,false);
1519
1520         // echapper les ' pour eviter tout bug
1521         $val = str_replace("'", "&#039;", $val);
1522         if ($vider AND strlen($val)==0)
1523                 $insert = '';
1524         else
1525                 $insert = " $attribut='$val'";
1526
1527         list($old, $r) = extraire_attribut($balise, $attribut, true);
1528
1529         if ($old !== NULL) {
1530                 // Remplacer l'ancien attribut du meme nom
1531                 $balise = $r[1].$insert.$r[5];
1532         }
1533         else {
1534                 // preferer une balise " />" (comme <img />)
1535                 if (preg_match(',/>,', $balise))
1536                         $balise = preg_replace(",\s?/>,S", $insert." />", $balise, 1);
1537                 // sinon une balise <a ...> ... </a>
1538                 else
1539                         $balise = preg_replace(",\s?>,S", $insert.">", $balise, 1);
1540         }
1541
1542         return $balise;
1543 }
1544
1545 // http://doc.spip.org/@vider_attribut
1546 function vider_attribut ($balise, $attribut) {
1547         return inserer_attribut($balise, $attribut, '', false, true);
1548 }
1549
1550
1551 /**
1552  * Un filtre pour determiner le nom du satut des inscrits
1553  * @param void $dummy
1554  * @param string $mode
1555  * @return string
1556  */
1557 function tester_config($dummy, $mode='') {
1558         include_spip('action/inscrire_auteur');
1559         return tester_statut_inscription($mode);
1560 }
1561
1562 //
1563 // Quelques fonctions de calcul arithmetique
1564 //
1565 // http://doc.spip.org/@plus
1566 function plus($a,$b) {
1567         return $a+$b;
1568 }
1569 // http://doc.spip.org/@moins
1570 function moins($a,$b) {
1571         return $a-$b;
1572 }
1573 // http://doc.spip.org/@mult
1574 function mult($a,$b) {
1575         return $a*$b;
1576 }
1577 // http://doc.spip.org/@div
1578 function div($a,$b) {
1579         return $b?$a/$b:0;
1580 }
1581 // http://doc.spip.org/@modulo
1582 function modulo($nb, $mod, $add=0) {
1583         return ($mod?$nb%$mod:0)+$add;
1584 }
1585
1586
1587 // Verifier la conformite d'une ou plusieurs adresses email
1588 //  retourne false ou la  normalisation de la derniere adresse donnee
1589 // http://doc.spip.org/@email_valide
1590 function email_valide($adresses) {
1591         // eviter d'injecter n'importe quoi dans preg_match
1592         if (!is_string($adresses))
1593                 return false;
1594
1595         // Si c'est un spammeur autant arreter tout de suite
1596         if (preg_match(",[\n\r].*(MIME|multipart|Content-),i", $adresses)) {
1597                 spip_log("Tentative d'injection de mail : $adresses");
1598                 return false;
1599         }
1600
1601         foreach (explode(',', $adresses) as $v) {
1602                 // nettoyer certains formats
1603                 // "Marie Toto <Marie@toto.com>"
1604                 $adresse = trim(preg_replace(",^[^<>\"]*<([^<>\"]+)>$,i", "\\1", $v));
1605                 // RFC 822
1606                 if (!preg_match('#^[^()<>@,;:\\"/[:space:]]+(@([-_0-9a-z]+\.)*[-_0-9a-z]+)$#i', $adresse))
1607                         return false;
1608         }
1609         return $adresse;
1610 }
1611
1612 // http://doc.spip.org/@afficher_enclosures
1613 function afficher_enclosures($tags) {
1614         $s = array();
1615         foreach (extraire_balises($tags, 'a') as $tag) {
1616                 if (extraire_attribut($tag, 'rel') == 'enclosure'
1617                 AND $t = extraire_attribut($tag, 'href')) {
1618                         $s[] = preg_replace(',>[^<]+</a>,S',
1619                                 '>'
1620                                 .http_img_pack('attachment-16.png', $t,
1621                                         'title="'.attribut_html($t).'"')
1622                                 .'</a>', $tag);
1623                 }
1624         }
1625         return join('&nbsp;', $s);
1626 }
1627 // http://doc.spip.org/@afficher_tags
1628 function afficher_tags($tags, $rels='tag,directory') {
1629         $s = array();
1630         foreach (extraire_balises($tags, 'a') as $tag) {
1631                 $rel = extraire_attribut($tag, 'rel');
1632                 if (strstr(",$rels,", ",$rel,"))
1633                         $s[] = $tag;
1634         }
1635         return join(', ', $s);
1636 }
1637
1638 // Passe un <enclosure url="fichier" length="5588242" type="audio/mpeg"/>
1639 // au format microformat <a rel="enclosure" href="fichier" ...>fichier</a>
1640 // attention length="zz" devient title="zz", pour rester conforme
1641 // http://doc.spip.org/@enclosure2microformat
1642 function enclosure2microformat($e) {
1643         if (!$url = filtrer_entites(extraire_attribut($e, 'url')))
1644                 $url = filtrer_entites(extraire_attribut($e, 'href'));
1645         $type = extraire_attribut($e, 'type');
1646         if (!$length = extraire_attribut($e, 'length')) {
1647                 # <media:content : longeur dans fileSize. On tente.
1648                 $length = extraire_attribut($e, 'fileSize');
1649         }
1650         $fichier = basename($url);
1651         return '<a rel="enclosure"'
1652                 . ($url? ' href="'.htmlspecialchars($url).'"' : '')
1653                 . ($type? ' type="'.htmlspecialchars($type).'"' : '')
1654                 . ($length? ' title="'.htmlspecialchars($length).'"' : '')
1655                 . '>'.$fichier.'</a>';
1656 }
1657 // La fonction inverse
1658 // http://doc.spip.org/@microformat2enclosure
1659 function microformat2enclosure($tags) {
1660         $enclosures = array();
1661         foreach (extraire_balises($tags, 'a') as $e)
1662         if (extraire_attribut($e, 'rel') == 'enclosure') {
1663                 $url = filtrer_entites(extraire_attribut($e, 'href'));
1664                 $type = extraire_attribut($e, 'type');
1665                 if (!$length = intval(extraire_attribut($e, 'title')))
1666                         $length = intval(extraire_attribut($e, 'length')); # vieux data
1667                 $fichier = basename($url);
1668                 $enclosures[] = '<enclosure'
1669                         . ($url? ' url="'.htmlspecialchars($url).'"' : '')
1670                         . ($type? ' type="'.htmlspecialchars($type).'"' : '')
1671                         . ($length? ' length="'.$length.'"' : '')
1672                         . ' />';
1673         }
1674         return join("\n", $enclosures);
1675 }
1676 // Creer les elements ATOM <dc:subject> a partir des tags
1677 // http://doc.spip.org/@tags2dcsubject
1678 function tags2dcsubject($tags) {
1679         $subjects = '';
1680         foreach (extraire_balises($tags, 'a') as $e) {
1681                 if (extraire_attribut($e, rel) == 'tag') {
1682                         $subjects .= '<dc:subject>'
1683                                 . texte_backend(textebrut($e))
1684                                 . '</dc:subject>'."\n";
1685                 }
1686         }
1687         return $subjects;
1688 }
1689
1690 // retourne la premiere balise du type demande
1691 // ex: [(#DESCRIPTIF|extraire_balise{img})]
1692 // Si on a passe un tableau de textes, renvoyer un tableau de resultats
1693 // http://doc.spip.org/@extraire_balise
1694 function extraire_balise($texte, $tag='a') {
1695         if (is_array($texte)) {
1696                 array_walk($texte,
1697                         create_function('&$a,$key,$t', '$a = extraire_balise($a,$t);'),
1698                         $tag);
1699                 return $texte;
1700         }
1701
1702         if (preg_match(
1703         ",<$tag\b[^>]*(/>|>.*</$tag\b[^>]*>|>),UimsS",
1704         $texte, $regs))
1705                 return $regs[0];
1706 }
1707
1708 // extraire toutes les balises du type demande, sous forme de tableau
1709 // Si on a passe un tableau de textes, renvoyer un tableau de resultats
1710 // http://doc.spip.org/@extraire_balises
1711 function extraire_balises($texte, $tag='a') {
1712         if (is_array($texte)) {
1713                 array_walk($texte,
1714                         create_function('&$a,$key,$t', '$a = extraire_balises($a,$t);'),
1715                         $tag);
1716                 return $texte;
1717         }
1718
1719         if (preg_match_all(
1720         ",<${tag}\b[^>]*(/>|>.*</${tag}\b[^>]*>|>),UimsS",
1721         $texte, $regs, PREG_PATTERN_ORDER))
1722                 return $regs[0];
1723         else
1724                 return array();
1725 }
1726
1727 // comme in_array mais renvoie son 3e arg si le 2er arg n'est pas un tableau
1728 // prend ' ' comme representant de vrai et '' de faux
1729
1730 // http://doc.spip.org/@in_any
1731 function in_any($val, $vals, $def='') {
1732         if (!is_array($vals) AND $v=unserialize($vals)) $vals = $v;
1733   return (!is_array($vals) ? $def : (in_array($val, $vals) ? ' ' : ''));
1734 }
1735
1736 // valeur_numerique("3*2") => 6
1737 // n'accepte que les *, + et - (a ameliorer si on l'utilise vraiment)
1738 // http://doc.spip.org/@valeur_numerique
1739 function valeur_numerique($expr) {
1740         $a = 0;
1741         if (preg_match(',^[0-9]+(\s*[+*-]\s*[0-9]+)*$,S', trim($expr)))
1742                 eval("\$a = $expr;");
1743         return intval($a);
1744 }
1745
1746 // http://doc.spip.org/@regledetrois
1747 function regledetrois($a,$b,$c)
1748 {
1749   return round($a*$b/$c);
1750 }
1751
1752 // Fournit la suite de Input-Hidden correspondant aux parametres de
1753 // l'URL donnee en argument, compatible avec les types_urls depuis [14447].
1754 // cf. tests/filtres/form_hidden.html
1755 // http://doc.spip.org/@form_hidden
1756 function form_hidden($action) {
1757
1758         $contexte = array();
1759         include_spip('inc/urls');
1760         if ($p = urls_decoder_url($action, '')
1761                 AND reset($p)) {
1762                 $fond = array_shift($p);
1763                 if ($fond!='404'){
1764                         $contexte = array_shift($p);
1765                         $contexte['page'] = $fond;
1766                         $action = preg_replace('/([?]'.preg_quote($fond).'[^&=]*[0-9]+)(&|$)/', '?&', $action);
1767                 }
1768         }
1769         // defaire ce qu'a injecte urls_decoder_url : a revoir en modifiant la signature de urls_decoder_url
1770         if (defined('_DEFINIR_CONTEXTE_TYPE') AND _DEFINIR_CONTEXTE_TYPE)
1771                 unset($contexte['type']);
1772         if (defined('_DEFINIR_CONTEXTE_TYPE_PAGE') AND _DEFINIR_CONTEXTE_TYPE_PAGE)
1773                 unset($contexte['type-page']);
1774
1775         // on va remplir un tableau de valeurs en prenant bien soin de ne pas
1776         // ecraser les elements de la forme mots[]=1&mots[]=2
1777         $values = array();
1778
1779         // d'abord avec celles de l'url
1780         if (false !== ($p = strpos($action, '?'))) {
1781                 foreach(preg_split('/&(amp;)?/S',substr($action,$p+1)) as $c){
1782                         list($var,$val) = explode('=', $c, 2);
1783                         if ($var) {
1784                                 $val =  rawurldecode($val);
1785                                 $var =  rawurldecode($var); // decoder les [] eventuels
1786                                 if (preg_match(',\[\]$,S', $var))
1787                                         $values[] = array($var, $val);
1788                                 else if (!isset($values[$var]))
1789                                         $values[$var] = array($var, $val);
1790                         }
1791                 }
1792         }
1793
1794         // ensuite avec celles du contexte, sans doublonner !
1795         foreach($contexte as $var=>$val)
1796                 if (preg_match(',\[\]$,S', $var))
1797                         $values[] = array($var, $val);
1798                 else if (!isset($values[$var]))
1799                         $values[$var] = array($var, $val);
1800
1801         // puis on rassemble le tout
1802         $hidden = array();
1803         foreach($values as $value) {
1804                 list($var,$val) = $value;
1805                 $hidden[] = '<input name="'
1806                         . entites_html($var)
1807                         .'"'
1808                         . (is_null($val)
1809                                 ? ''
1810                                 : ' value="'.entites_html($val).'"'
1811                                 )
1812                         . ' type="hidden"'."\n/>";
1813         }
1814         return join("", $hidden);
1815 }
1816
1817 // http://doc.spip.org/@filtre_bornes_pagination_dist
1818 function filtre_bornes_pagination_dist($courante, $nombre, $max = 10) {
1819         if($max<=0 OR $max>=$nombre)
1820                 return array(1, $nombre);
1821
1822         $premiere = max(1, $courante-floor(($max-1)/2));
1823         $derniere = min($nombre, $premiere+$max-2);
1824         $premiere = $derniere == $nombre ? $derniere-$max+1 : $premiere;
1825         return array($premiere, $derniere);
1826 }
1827
1828
1829 // Ces trois fonctions permettent de simuler les filtres |reset et |end
1830 // pour extraire la premiere ou la derniere valeur d'un tableau ; utile
1831 // pour la pagination (mais peut-etre a refaire plus simplement)
1832 // http://doc.spip.org/@filtre_valeur_tableau
1833 function filtre_valeur_tableau($array, $index) {
1834         if (!is_array($array)
1835         OR !isset($array[$index]))
1836                 return null;
1837         return $array[$index];
1838 }
1839 // http://doc.spip.org/@filtre_reset
1840 function filtre_reset($array) {
1841         return !is_array($array) ? null : reset($array);
1842 }
1843 // http://doc.spip.org/@filtre_end
1844 function filtre_end($array) {
1845         return !is_array($array) ? null : end($array);
1846 }
1847
1848 // http://doc.spip.org/@filtre_push
1849 function filtre_push($array, $val) {
1850         if($array == '' OR !array_push($array, $val)) return '';
1851         return $array;
1852 }
1853
1854 // http://doc.spip.org/@filtre_find
1855 function filtre_find($array, $val) {
1856         return (is_array($array) AND in_array($val, $array));
1857 }
1858
1859
1860 //
1861 // fonction standard de calcul de la balise #PAGINATION
1862 // on peut la surcharger en definissant filtre_pagination dans mes_fonctions
1863 //
1864
1865 // http://doc.spip.org/@filtre_pagination_dist
1866 function filtre_pagination_dist($total, $nom, $position, $pas, $liste = true, $modele='', $connect='', $env=array()) {
1867         static $ancres = array();
1868         if ($pas<1) return '';
1869         $ancre = 'pagination'.$nom; // #pagination_articles
1870         $debut = 'debut'.$nom; // 'debut_articles'
1871
1872         // n'afficher l'ancre qu'une fois
1873         if (!isset($ancres[$ancre]))
1874                 $bloc_ancre = $ancres[$ancre] = "<a name='".$ancre."' id='".$ancre."'></a>";
1875         else $bloc_ancre = '';
1876         // liste = false : on ne veut que l'ancre
1877         if (!$liste)
1878                 return $ancres[$ancre];
1879
1880         $pagination = array(
1881                 'debut' => $debut,
1882                 'url' => parametre_url(self(),'fragment',''), // nettoyer l'id ahah eventuel
1883                 'total' => $total,
1884                 'position' => intval($position),
1885                 'pas' => $pas,
1886                 'nombre_pages' => floor(($total-1)/$pas)+1,
1887                 'page_courante' => floor(intval($position)/$pas)+1,
1888                 'ancre' => $ancre,
1889                 'bloc_ancre' => $bloc_ancre
1890         );
1891         if (is_array($env))
1892                 $pagination = array_merge($env,$pagination);
1893
1894         // Pas de pagination
1895         if ($pagination['nombre_pages']<=1)
1896                 return '';
1897
1898         if ($modele) $modele = '_'.$modele;
1899
1900         return recuperer_fond("modeles/pagination$modele", $pagination, array('trim'=>true), $connect);
1901 }
1902
1903 // passer les url relatives a la css d'origine en url absolues
1904 // http://doc.spip.org/@urls_absolues_css
1905 function urls_absolues_css($contenu, $source) {
1906         $path = suivre_lien(url_absolue($source),'./');
1907
1908         return preg_replace_callback(
1909                 ",url\s*\(\s*['\"]?([^'\"/][^:]*)['\"]?\s*\),Uims",
1910                 create_function('$x',
1911                         'return "url(\"".suivre_lien("'.$path.'",$x[1])."\")";'
1912                 ), $contenu);
1913 }
1914
1915 // recuperere le chemin d'une css existante et :
1916 // 1. regarde si une css inversee droite-gauche existe dans le meme repertoire
1917 // 2. sinon la cree (ou la recree) dans _DIR_VAR/cache_css/
1918 // SI on lui donne a manger une feuille nommee _rtl.css il va faire l'inverse
1919 // http://doc.spip.org/@direction_css
1920 function direction_css ($css, $voulue='') {
1921         if (!preg_match(',(_rtl)?\.css$,i', $css, $r)) return $css;
1922
1923         // si on a precise le sens voulu en argument, le prendre en compte
1924         if ($voulue = strtolower($voulue)) {
1925                 if ($voulue != 'rtl' AND $voulue != 'ltr')
1926                         $voulue = lang_dir($voulue);
1927         }
1928         else
1929                 $voulue =  lang_dir();
1930
1931         $r = count($r) > 1;
1932         $right = $r ? 'left' : 'right'; // 'right' de la css lue en entree
1933         $dir = $r ? 'rtl' : 'ltr';
1934         $ndir = $r ? 'ltr' : 'rtl';
1935
1936         if ($voulue == $dir)
1937                 return $css;
1938
1939         if (
1940                 // url absolue
1941                 preg_match(",^http:,i",$css)
1942                 // ou qui contient un ?
1943                 OR (($p=strpos($css,'?'))!==FALSE)) {
1944                 $distant = true;
1945                 $cssf = parse_url($css);
1946                 $cssf = $cssf['path'].($cssf['query']?"?".$cssf['query']:"");
1947                 $cssf = preg_replace(',[?:&=],', "_", $cssf);
1948         }
1949         else {
1950                 $distant = false;
1951                 $cssf = $css;
1952                 // 1. regarder d'abord si un fichier avec la bonne direction n'est pas aussi
1953                 //propose (rien a faire dans ce cas)
1954                 $f = preg_replace(',(_rtl)?\.css$,i', '_'.$ndir.'.css', $css);
1955                 if (@file_exists($f))
1956                         return $f;
1957         }
1958
1959         // 2.
1960         $dir_var = sous_repertoire (_DIR_VAR, 'cache-css');
1961         $f = $dir_var
1962                 . preg_replace(',.*/(.*?)(_rtl)?\.css,', '\1', $cssf)
1963                 . '.' . substr(md5($cssf), 0,4) . '_' . $ndir . '.css';
1964
1965         // la css peut etre distante (url absolue !)
1966         if ($distant){
1967                 include_spip('inc/distant');
1968                 $contenu = recuperer_page($css);
1969                 if (!$contenu) return $css;
1970         }
1971         else {
1972                 if ((@filemtime($f) > @filemtime($css))
1973                         AND (_VAR_MODE != 'recalcul'))
1974                         return $f;
1975                 if (!lire_fichier($css, $contenu))
1976                         return $css;
1977         }
1978
1979         $contenu = str_replace(
1980                 array('right', 'left', '@@@@L E F T@@@@'),
1981                 array('@@@@L E F T@@@@', 'right', 'left'),
1982                 $contenu);
1983
1984         // reperer les @import auxquels il faut propager le direction_css
1985         preg_match_all(",\@import\s*url\s*\(\s*['\"]?([^'\"/][^:]*)['\"]?\s*\),Uims",$contenu,$regs);
1986         $src = array();$src_direction_css = array();$src_faux_abs=array();
1987         $d = dirname($css);
1988         foreach($regs[1] as $k=>$import_css){
1989                 $css_direction = direction_css("$d/$import_css",$voulue);
1990                 // si la css_direction est dans le meme path que la css d'origine, on tronque le path, elle sera passee en absolue
1991                 if (substr($css_direction,0,strlen($d)+1)=="$d/") $css_direction = substr($css_direction,strlen($d)+1);
1992                 // si la css_direction commence par $dir_var on la fait passer pour une absolue
1993                 elseif (substr($css_direction,0,strlen($dir_var))==$dir_var) {
1994                         $css_direction = substr($css_direction,strlen($dir_var));
1995                         $src_faux_abs["/@@@@@@/".$css_direction] = $css_direction;
1996                         $css_direction = "/@@@@@@/".$css_direction;
1997                 }
1998                 $src[] = $regs[0][$k];
1999                 $src_direction_css[] = str_replace($import_css,$css_direction,$regs[0][$k]);
2000         }
2001         $contenu = str_replace($src,$src_direction_css,$contenu);
2002
2003         $contenu = urls_absolues_css($contenu, $css);
2004
2005         // virer les fausses url absolues que l'on a mis dans les import
2006         if (count($src_faux_abs))
2007                 $contenu = str_replace(array_keys($src_faux_abs),$src_faux_abs,$contenu);
2008
2009         if (!ecrire_fichier($f, $contenu))
2010                 return $css;
2011
2012         return $f;
2013 }
2014
2015 // recuperere le chemin d'une css existante et :
2016 // cree (ou recree) dans _DIR_VAR/cache_css/ une css dont les url relatives sont passees en url absolues
2017 // http://doc.spip.org/@url_absolue_css
2018 function url_absolue_css ($css) {
2019         if (!preg_match(',\.css$,i', $css, $r)) return $css;
2020
2021         $url_absolue_css = url_absolue($css);
2022
2023         $f = basename($css,'.css');
2024         $f = sous_repertoire (_DIR_VAR, 'cache-css')
2025                 . preg_replace(",(.*?)(_rtl|_ltr)?$,","\\1-urlabs-" . substr(md5("$css-urlabs"), 0,4) . "\\2",$f)
2026                 . '.css';
2027
2028         if ((@filemtime($f) > @filemtime($css))
2029         AND (_VAR_MODE != 'recalcul'))
2030                 return $f;
2031
2032         if ($url_absolue_css==$css){
2033                 if (strncmp($GLOBALS['meta']['adresse_site'],$css,$l=strlen($GLOBALS['meta']['adresse_site']))!=0
2034                  OR !lire_fichier(_DIR_RACINE . substr($css,$l), $contenu)){
2035                                 include_spip('inc/distant');
2036                                 if (!$contenu = recuperer_page($css))
2037                                         return $css;
2038                 }
2039         }
2040         elseif (!lire_fichier($css, $contenu))
2041                 return $css;
2042
2043         // passer les url relatives a la css d'origine en url absolues
2044         $contenu = urls_absolues_css($contenu, $css);
2045
2046         // ecrire la css
2047         if (!ecrire_fichier($f, $contenu))
2048                 return $css;
2049
2050         return $f;
2051 }
2052
2053
2054
2055 /**
2056  * Le filtre table_valeur
2057  * permet de recuperer la valeur d'une cle donnee
2058  * dans un tableau (ou un objet).
2059  *
2060  * @param mixed $table
2061  *              Tableau ou objet
2062  *              (ou chaine serialisee de tableau, ce qui permet d'enchainer le filtre)
2063  *
2064  * @param string $cle
2065  *              Cle du tableau (ou parametre public de l'objet)
2066  *              Cette cle peut contenir des caracteres / pour selectionner
2067  *              des sous elements dans le tableau, tel que "sous/element/ici"
2068  *              pour obtenir la valeur de $tableau['sous']['element']['ici']
2069  *
2070  * @param mixed $defaut
2071  *              Valeur par defaut retournee si la cle demandee n'existe pas
2072  *
2073  * @return mixed Valeur trouvee ou valeur par defaut.
2074 **/
2075 function table_valeur($table, $cle, $defaut='') {
2076         foreach (explode('/', $cle) as $k) {
2077
2078                 $table = is_string($table) ? @unserialize($table) : $table;
2079
2080                 if (is_object($table)) {
2081                         $table =  (($k !== "") and isset($table->$k)) ? $table->$k : $defaut;
2082                 } elseif (is_array($table)) {
2083                         $table = isset($table[$k]) ? $table[$k] : $defaut;
2084                 } else {
2085                         $table = $defaut;
2086                 }
2087         }
2088         return $table;
2089 }
2090
2091 // filtre match pour faire des tests avec expression reguliere
2092 // [(#TEXTE|match{^ceci$,Uims})]
2093 // retourne le fragment de chaine qui "matche"
2094 // il est possible de passer en 3eme argument optionnel le numero de parenthese capturante
2095 // accepte egalement la syntaxe #TRUC|match{truc(...)$,1} ou le modificateur n'est pas passe en second argument
2096 // http://doc.spip.org/@match
2097 function match($texte, $expression, $modif="UimsS",$capte=0) {
2098         if (intval($modif) AND $capte==0){
2099                 $capte = $modif;
2100                 $modif = "UimsS";
2101         }
2102         $expression=str_replace("\/","/",$expression);
2103         $expression=str_replace("/","\/",$expression);
2104
2105         if (preg_match('/' . $expression . '/' . $modif,$texte, $r)) {
2106                 if (isset($r[$capte]))
2107                         return $r[$capte];
2108                 else
2109                         return true;
2110         }
2111         return false;
2112 }
2113
2114 // filtre replace pour faire des operations avec expression reguliere
2115 // [(#TEXTE|replace{^ceci$,cela,UimsS})]
2116 // http://doc.spip.org/@replace
2117 function replace($texte, $expression, $replace='', $modif="UimsS") {
2118         $expression=str_replace("\/","/", $expression);
2119         $expression=str_replace("/","\/",$expression);
2120         return preg_replace('/' . $expression . '/' . $modif, $replace, $texte);
2121 }
2122
2123
2124 // cherche les documents numerotes dans un texte traite par propre()
2125 // et affecte les doublons['documents']
2126 // http://doc.spip.org/@traiter_doublons_documents
2127 // http://doc.spip.org/@traiter_doublons_documents
2128 function traiter_doublons_documents(&$doublons, $letexte) {
2129
2130         // Verifier dans le texte & les notes (pas beau, helas)
2131         $t = $letexte.$GLOBALS['les_notes'];
2132
2133         if (strstr($t, 'spip_document_') // evite le preg_match_all si inutile
2134         AND preg_match_all(
2135         ',<[^>]+\sclass=["\']spip_document_([0-9]+)[\s"\'],imsS',
2136         $t, $matches, PREG_PATTERN_ORDER))
2137                 $doublons['documents'] .= "," . join(',', $matches[1]);
2138
2139         return $letexte;
2140 }
2141
2142 // filtre vide qui ne renvoie rien
2143 // http://doc.spip.org/@vide
2144 function vide($texte){
2145         return "";
2146 }
2147
2148 //
2149 // Filtres pour le modele/emb (embed document)
2150 //
2151
2152 // A partir d'un #ENV, retourne des <param ...>
2153 // http://doc.spip.org/@env_to_params
2154 function env_to_params ($texte, $ignore_params=array()) {
2155         $ignore_params = array_merge (
2156                 array('id', 'lang', 'id_document', 'date', 'date_redac', 'align', 'fond', '', 'recurs', 'emb', 'dir_racine'),
2157         $ignore_params);
2158         $tableau = unserialize($texte);
2159         $texte = "";
2160         foreach ($tableau as $i => $j)
2161                 if (is_string($j) AND !in_array($i,$ignore_params))
2162                         $texte .= "<param name='".$i."'\n\tvalue='".$j."' />";
2163         return $texte;
2164 }
2165 // A partir d'un #ENV, retourne des attributs
2166 // http://doc.spip.org/@env_to_attributs
2167 function env_to_attributs ($texte, $ignore_params=array()) {
2168         $ignore_params = array_merge (
2169                 array('id', 'lang', 'id_document', 'date', 'date_redac', 'align', 'fond', '', 'recurs', 'emb', 'dir_racine'),
2170         $ignore_params);
2171         $tableau = unserialize($texte);
2172         $texte = "";
2173         foreach ($tableau as $i => $j)
2174                 if (is_string($j) AND !in_array($i,$ignore_params))
2175                         $texte .= $i."='".$j."' ";
2176         return $texte;
2177 }
2178
2179 // Concatener des chaines
2180 // #TEXTE|concat{texte1,texte2,...}
2181 // http://doc.spip.org/@concat
2182 function concat(){
2183         $args = func_get_args();
2184         return join('', $args);
2185 }
2186
2187
2188 // http://doc.spip.org/@charge_scripts
2189 function charge_scripts($scripts) {
2190   $flux = "";
2191   $args = is_array($scripts)?$scripts:explode("|",$scripts);
2192   foreach($args as $script) {
2193     if(preg_match(",^\w+$,",$script)) {
2194       $path = find_in_path("javascript/$script.js");
2195       if($path) $flux .= spip_file_get_contents($path);
2196     }
2197   }
2198   return $flux;
2199 }
2200
2201
2202
2203 /**
2204  * produit une balise img avec un champ alt d'office si vide
2205  * attention le htmlentities et la traduction doivent etre appliques avant.
2206  *
2207  * http://doc.spip.org/@http_img_pack
2208  *
2209  * @param $img
2210  * @param $alt
2211  * @param string $atts
2212  * @param string $title
2213  * @param array $options
2214  *   chemin_image : utiliser chemin_image sur $img fourni, ou non (oui par dafaut)
2215  *   utiliser_suffixe_size : utiliser ou non le suffixe de taille dans le nom de fichier de l'image
2216  *   sous forme -xx.png (pour les icones essentiellement) (oui par defaut)
2217  * @return string
2218  */
2219 function http_img_pack($img, $alt, $atts='', $title='', $options = array()) {
2220         if (!isset($options['chemin_image']) OR $options['chemin_image']==true)
2221                 $img = chemin_image($img);
2222         if (stripos($atts, 'width')===false){
2223                 // utiliser directement l'info de taille presente dans le nom
2224                 if ((!isset($options['utiliser_suffixe_size']) OR $options['utiliser_suffixe_size']==true)
2225                     AND preg_match(',-([0-9]+)[.](png|gif)$,',$img,$regs)){
2226                         $largeur = $hauteur = intval($regs[1]);
2227                 }
2228                 else{
2229                         $taille = taille_image($img);
2230                         list($hauteur,$largeur) = $taille;
2231                         if (!$hauteur OR !$largeur)
2232                                 return "";
2233                 }
2234                 $atts.=" width='".$largeur."' height='".$hauteur."'";
2235         }
2236         return  "<img src='$img' alt='" . attribut_html($alt ? $alt : $title) . "'"
2237           . ($title ? ' title="'.attribut_html($title).'"' : '')
2238           . " ".ltrim($atts)
2239           . " />";
2240 }
2241
2242 /**
2243  * generer une directive style='background:url()' a partir d'un fichier image
2244  *
2245  * http://doc.spip.org/@http_style_background
2246  *
2247  * @param string $img
2248  * @param string $att
2249  * @return string
2250  */
2251 function http_style_background($img, $att=''){
2252   return " style='background".($att?"":"-image").": url(\"".chemin_image($img)."\")" . ($att ? (' ' . $att) : '') . ";'";
2253 }
2254
2255 /**
2256  * une fonction pour generer une balise img a partir d'un nom de fichier
2257  *
2258  * @param string $img
2259  * @param string $alt
2260  * @param string $class
2261  * @return string
2262  */
2263 function filtre_balise_img_dist($img,$alt="",$class=""){
2264         return http_img_pack($img, $alt, $class?" class='".attribut_html($class)."'":'', '', array('chemin_image'=>false,'utiliser_suffixe_size'=>false));
2265 }
2266
2267
2268 //[(#ENV*|unserialize|foreach)]
2269 // http://doc.spip.org/@filtre_foreach_dist
2270 function filtre_foreach_dist($balise_deserializee, $modele = 'foreach') {
2271         $texte = '';
2272         if(is_array($balise_deserializee))
2273                 foreach($balise_deserializee as $k => $v) {
2274                         $res = recuperer_fond('modeles/'.$modele,
2275                                 array_merge(array('cle' => $k), (is_array($v) ? $v : array('valeur' => $v)))
2276                         );
2277                         $texte .= $res;
2278                 }
2279         return $texte;
2280 }
2281
2282 // renvoie la liste des plugins actifs du site
2283 // si le premier parametre est un prefix de cette liste, renvoie vrai, faux sinon
2284 // la valeur du second parametre si celui-ci renvoie a une information connue
2285 // cf liste_plugin_actifs() pour connaitre les informations affichables
2286 // appelee par la balise #PLUGIN
2287 // http://doc.spip.org/@filtre_info_plugin_dist
2288 function filtre_info_plugin_dist($plugin, $type_info) {
2289         include_spip('inc/plugin');
2290         $plugin = strtoupper($plugin);
2291         $plugins_actifs = liste_plugin_actifs();
2292
2293         if (!$plugin)
2294                 return serialize(array_keys($plugins_actifs));
2295         elseif (empty($plugins_actifs[$plugin]))
2296                 return '';
2297         elseif ($type_info == 'est_actif')
2298                 return $plugins_actifs[$plugin] ? 1 : 0;
2299         elseif (isset($plugins_actifs[$plugin][$type_info]))
2300                 return $plugins_actifs[$plugin][$type_info];
2301         else {
2302                 $get_infos = charger_fonction('get_infos','plugins');
2303                 // On prend en compte les extensions
2304                 if (!is_dir($plugins_actifs[$plugin]['dir_type']))
2305                         $dir_plugins = constant($plugins_actifs[$plugin]['dir_type']);
2306                 else
2307                         $dir_plugins = $plugins_actifs[$plugin]['dir_type'];
2308                 if (!$infos = $get_infos($plugins_actifs[$plugin]['dir'], false, $dir_plugins))
2309                         return '';
2310                 if ($type_info == 'tout')
2311                         return $infos;
2312                 else
2313                         return strval($infos[$type_info]);
2314         }
2315 }
2316
2317
2318 // http://doc.spip.org/@puce_changement_statut
2319 function puce_changement_statut($id_objet, $statut, $id_rubrique, $type, $ajax=false){
2320         $puce_statut = charger_fonction('puce_statut','inc');
2321         return $puce_statut($id_objet, $statut, $id_rubrique, $type, $ajax);
2322 }
2323
2324 /**
2325  * [(#STATUT|puce_statut{article})] affiche une puce passive
2326  * [(#STATUT|puce_statut{article,#ID_ARTICLE,#ID_RUBRIQUE})] affiche une puce avec changement rapide
2327  *
2328  * utilisable sur tout objet qui a declare
2329  * @param string $statut
2330  * @param string $objet
2331  * @param int $id_objet
2332  * @param int $id_parent
2333  * @return string
2334  */
2335 function filtre_puce_statut_dist($statut,$objet,$id_objet=0,$id_parent=0){
2336         static $puce_statut = null;
2337         if (!$puce_statut)
2338                 $puce_statut = charger_fonction('puce_statut','inc');
2339         return $puce_statut($id_objet, $statut, $id_parent, $objet, false, objet_info($objet,'editable')?_ACTIVER_PUCE_RAPIDE:false);
2340 }
2341
2342
2343 /**
2344  * Encoder un contexte pour l'ajax, le signer avec une cle, le crypter
2345  * avec le secret du site, le gziper si possible...
2346  * l'entree peut etre serialisee (le #ENV** des fonds ajax et ajax_stat)
2347  *
2348  * http://doc.spip.org/@encoder_contexte_ajax
2349  *
2350  * @param string|array $c
2351  *   contexte, peut etre un tableau serialize
2352  * @param string $form
2353  *   nom du formulaire eventuel
2354  * @param string $emboite
2355  *   contenu a emboiter dans le conteneur ajax
2356  * @param string $ajaxid
2357  *   ajaxid pour cibler le bloc et forcer sa mise a jour
2358  * @return string
2359  */
2360 function encoder_contexte_ajax($c,$form='', $emboite=NULL, $ajaxid='') {
2361         if (is_string($c)
2362         AND !is_null(@unserialize($c))) {
2363                 $c = unserialize($c);
2364         }
2365
2366         // supprimer les parametres debut_x
2367         // pour que la pagination ajax ne soit pas plantee
2368         // si on charge la page &debut_x=1 : car alors en cliquant sur l'item 0,
2369         // le debut_x=0 n'existe pas, et on resterait sur 1
2370         foreach ($c as $k => $v) {
2371                 if (strpos($k,'debut_') === 0) {
2372                         unset($c[$k]);
2373                 }
2374         }
2375
2376         if (!function_exists('calculer_cle_action'))
2377                 include_spip("inc/securiser_action");
2378         $cle = calculer_cle_action($form.(is_array($c)?serialize($c):$c));
2379         $c = serialize(array($c,$cle));
2380
2381         // on ne stocke pas les contextes dans des fichiers caches
2382         // par defaut, sauf si cette configuration a ete forcee
2383         // OU que la longueur de l''argument generee est plus long
2384         // que ce que telere Suhosin.
2385         $cache_contextes_ajax = (defined('_CACHE_CONTEXTES_AJAX') AND _CACHE_CONTEXTES_AJAX);
2386         if (!$cache_contextes_ajax) {
2387                 $env = $c;
2388                 if (function_exists('gzdeflate') && function_exists('gzinflate')) {
2389                         $env = gzdeflate($env);
2390                         // http://core.spip.org/issues/2667 | https://bugs.php.net/bug.php?id=61287
2391                         if (substr(phpversion(),0,5) == '5.4.0' AND !@gzinflate($env)) {
2392                                 $cache_contextes_ajax = true;
2393                                 spip_log("Contextes AJAX forces en fichiers ! Erreur PHP 5.4.0", _LOG_AVERTISSEMENT);
2394                         }
2395                 }
2396                 $env = _xor($env);
2397                 $env = base64_encode($env);
2398                 // tester Suhosin et la valeur maximale des variables en GET...
2399                 if ($max_len = @ini_get('suhosin.get.max_value_length')
2400                 and $max_len < ($len = strlen($env))) {
2401                         $cache_contextes_ajax = true;
2402                         spip_log("Contextes AJAX forces en fichiers !"
2403                                 . " Cela arrive lorsque la valeur du contexte"
2404                                 . " depasse la longueur maximale autorisee par Suhosin"
2405                                 . " ($max_len) dans 'suhosin.get.max_value_length'. Ici : $len."
2406                                 . " Vous devriez modifier les parametres de Suhosin"
2407                                 . " pour accepter au moins 1024 caracteres.", _LOG_AVERTISSEMENT);
2408                 }
2409         }
2410
2411         if ($cache_contextes_ajax) {
2412                 $dir = sous_repertoire(_DIR_CACHE, 'contextes');
2413                 // stocker les contextes sur disque et ne passer qu'un hash dans l'url
2414                 $md5 = md5($c);
2415                 ecrire_fichier("$dir/c$md5",$c);
2416                 $env = $md5;
2417         }
2418
2419         if ($emboite === NULL) return $env;
2420         if (!trim($emboite)) return "";
2421         // toujours encoder l'url source dans le bloc ajax
2422         $r = self();
2423         $r = ' data-origin="'.$r.'"';
2424         $class = 'ajaxbloc';
2425         if ($ajaxid AND is_string($ajaxid)){
2426                 $class .= ' ajax-id-'.$ajaxid;
2427         }
2428         $compl = "aria-live='polite' aria-atomic='true' ";
2429         return "<div class='$class' ".$compl."data-ajax-env='$env'$r>\n$emboite</div><!--ajaxbloc-->\n";
2430 }
2431
2432 // la procedure inverse de encoder_contexte_ajax()
2433 // http://doc.spip.org/@decoder_contexte_ajax
2434 function decoder_contexte_ajax($c,$form='') {
2435         if (!function_exists('calculer_cle_action'))
2436                 include_spip("inc/securiser_action");
2437         if (( (defined('_CACHE_CONTEXTES_AJAX') AND _CACHE_CONTEXTES_AJAX) OR strlen($c)==32)
2438                 AND $dir = sous_repertoire(_DIR_CACHE, 'contextes')
2439                 AND lire_fichier("$dir/c$c",$contexte)) {
2440                         $c = $contexte;
2441         } else {
2442                 $c = @base64_decode($c);
2443                 $c = _xor($c);
2444                 if (function_exists('gzdeflate') && function_exists('gzinflate'))
2445                         $c = @gzinflate($c);
2446         }
2447         list($env, $cle) = @unserialize($c);
2448
2449         if ($cle == calculer_cle_action($form.(is_array($env)?serialize($env):$env)))
2450                 return $env;
2451         return false;
2452 }
2453
2454 // encrypter/decrypter un message
2455 // http://www.php.net/manual/fr/language.operators.bitwise.php#81358
2456 // http://doc.spip.org/@_xor
2457 function _xor($message, $key=null){
2458         if (is_null($key)) {
2459                 if (!function_exists('calculer_cle_action'))
2460                         include_spip("inc/securiser_action");
2461                 $key = pack("H*", calculer_cle_action('_xor'));
2462         }
2463
2464         $keylen = strlen($key);
2465         $messagelen = strlen($message);
2466         for($i=0; $i<$messagelen; $i++)
2467                 $message[$i] = ~($message[$i]^$key[$i%$keylen]);
2468
2469         return $message;
2470 }
2471
2472 // Les vrai fonctions sont dans le plugin forum, mais on evite ici une erreur du compilateur
2473 // en absence du plugin
2474 function url_reponse_forum($texte){return $texte;}
2475 function url_rss_forum($texte){return $texte;}
2476
2477
2478 /**
2479  * une fonction pour generer des menus avec liens
2480  * ou un <strong class='on'> non clicable lorsque l'item est selectionne
2481  *
2482  * @param string $url
2483  * @param string $libelle
2484  *   le texte du lien
2485  * @param bool $on
2486  *   etat expose (genere un strong) ou non (genere un lien)
2487  * @param string $class
2488  * @param string $title
2489  * @param string $rel
2490  * @param string $evt
2491  *   complement a la balise a pour gerer un evenement javascript, de la forme " onclick='...'"
2492  * @return string
2493  */
2494 function lien_ou_expose($url,$libelle=NULL,$on=false,$class="",$title="",$rel="", $evt=''){
2495         if ($on) {
2496                 $bal = "strong";
2497                 $att = "class='on'";
2498         } else {
2499                 $bal = 'a';
2500                 $att = "href='$url'"
2501                 .($title?" title='".attribut_html($title)."'":'')
2502                 .($class?" class='".attribut_html($class)."'":'')
2503                 .($rel?" rel='".attribut_html($rel)."'":'')
2504                 .$evt;
2505         }
2506         if ($libelle === NULL)
2507                 $libelle = $url;
2508         return "<$bal $att>$libelle</$bal>";
2509 }
2510
2511
2512 /**
2513  * Afficher un message "un truc"/"N trucs"
2514  * Les items sont à indiquer comme pour la fonction _T() sous la forme :
2515  * "module:chaine"
2516  *
2517  * @param int $nb : le nombre
2518  * @param string $chaine_un : l'item de langue si $nb vaut un
2519  * @param string $chaine_plusieurs : l'item de lanque si $nb > 1
2520  * @param string $var : La variable à remplacer par $nb dans l'item de langue (facultatif, défaut "nb")
2521  * @param array $vars : Les autres variables nécessaires aux chaines de langues (facultatif)
2522  * @return string : la chaine de langue finale en utilisant la fonction _T()
2523  */
2524 function singulier_ou_pluriel($nb,$chaine_un,$chaine_plusieurs,$var='nb',$vars=array()){
2525         if (!$nb=intval($nb)) return "";
2526         if (!is_array($vars)) return "";
2527         $vars[$var] = $nb;
2528         if ($nb>1) return _T($chaine_plusieurs, $vars);
2529         else return _T($chaine_un,$vars);
2530 }
2531
2532
2533 /**
2534  * Fonction de base pour une icone dans un squelette
2535  * structure html : <span><a><img><b>texte</b></span>
2536  *
2537  * @param string $type
2538  *  'lien' ou 'bouton'
2539  * @param string $lien
2540  *  url
2541  * @param string $texte
2542  *  texte du lien / alt de l'image
2543  * @param string $fond
2544  *  objet avec ou sans son extension et sa taille (article, article-24, article-24.png)
2545  * @param string $fonction
2546  *  new/del/edit
2547  * @param string $class
2548  *  classe supplementaire (horizontale, verticale, ajax ...)
2549  * @param string $javascript
2550  *  "onclick='...'" par exemple
2551  * @return string
2552  */
2553 function prepare_icone_base($type, $lien, $texte, $fond, $fonction="", $class="",$javascript=""){
2554         if (in_array($fonction,array("del","supprimer.gif")))
2555                 $class .= ' danger';
2556         elseif ($fonction == "rien.gif")
2557                 $fonction = "";
2558         elseif ($fonction == "delsafe")
2559                 $fonction = "del";
2560
2561         // remappage des icone : article-24.png+new => article-new-24.png
2562         if ($icone_renommer = charger_fonction('icone_renommer','inc',true))
2563                 list($fond,$fonction) = $icone_renommer($fond,$fonction);
2564
2565         // ajouter le type d'objet dans la class de l'icone
2566         $class .= " " . substr(basename($fond),0,-4);
2567
2568         $alt = attribut_html($texte);
2569         $title = " title=\"$alt\""; // est-ce pertinent de doubler le alt par un title ?
2570
2571         $ajax = "";
2572         if (strpos($class,"ajax")!==false) {
2573                         $ajax="ajax";
2574                 if (strpos($class,"preload")!==false)
2575                         $ajax.=" preload";
2576                 if (strpos($class,"nocache")!==false)
2577                         $ajax.=" nocache";
2578                 $ajax=" class='$ajax'";
2579         }
2580
2581         $size = 24;
2582         if (preg_match("/-([0-9]{1,3})[.](gif|png)$/i",$fond,$match))
2583                 $size = $match[1];
2584
2585         if ($fonction){
2586                 // 2 images pour composer l'icone : le fond (article) en background,
2587                 // la fonction (new) en image
2588                 $icone = http_img_pack($fonction, $alt, "width='$size' height='$size'\n" .
2589                                         http_style_background($fond));
2590         }
2591         else {
2592                 $icone = http_img_pack($fond, $alt, "width='$size' height='$size'");
2593         }
2594
2595         if ($type=='lien')
2596                 return "<span class='icone s$size $class'>"
2597                 . "<a href='$lien'$title$ajax$javascript>"
2598                 . $icone
2599                 . "<b>$texte</b>"
2600                 . "</a></span>\n";
2601
2602         else
2603                 return bouton_action("$icone<b>$texte</b>",$lien,"icone s$size $class",$javascript,$alt);
2604 }
2605
2606 function icone_base($lien, $texte, $fond, $fonction="", $class="",$javascript=""){
2607         return prepare_icone_base('lien', $lien, $texte, $fond, $fonction, $class, $javascript);
2608 }
2609 function filtre_icone_verticale_dist($lien, $texte, $fond, $fonction="", $class="",$javascript=""){
2610         return icone_base($lien,$texte,$fond,$fonction,"verticale $class",$javascript);
2611 }
2612 function filtre_icone_horizontale_dist($lien, $texte, $fond, $fonction="", $class="",$javascript=""){
2613         return icone_base($lien,$texte,$fond,$fonction,"horizontale $class",$javascript);
2614 }
2615
2616 function filtre_bouton_action_horizontal_dist($lien, $texte, $fond, $fonction="", $class="",$confirm=""){
2617         return prepare_icone_base('bouton', $lien, $texte, $fond, $fonction, "horizontale $class", $confirm);
2618 }
2619 /*
2620  * Filtre icone pour compatibilite
2621  * mappe sur icone_base
2622  */
2623 function filtre_icone_dist($lien, $texte, $fond, $align="", $fonction="", $class="",$javascript=""){
2624         return icone_base($lien,$texte,$fond,$fonction,"verticale $align $class",$javascript);
2625 }
2626
2627
2628 /**
2629  * filtre explode pour les squelettes permettant d'ecrire
2630  * #GET{truc}|explode{-}
2631  *
2632  * @param strong $a
2633  * @param string $b
2634  * @return array
2635  */
2636 function filtre_explode_dist($a,$b){return explode($b,$a);}
2637
2638 /**
2639  * filtre implode pour les squelettes permettant d'ecrire
2640  * #GET{truc}|implode{-}
2641  *
2642  * @param array $a
2643  * @param string $b
2644  * @return string
2645  */
2646 function filtre_implode_dist($a,$b){return is_array($a)?implode($b,$a):$a;}
2647
2648 /**
2649  * Produire les styles prives qui associent item de menu avec icone en background
2650  * @return string
2651  */
2652 function bando_images_background(){
2653         include_spip('inc/bandeau');
2654         // recuperer tous les boutons et leurs images
2655         $boutons = definir_barre_boutons(definir_barre_contexte(),true,false);
2656
2657         $res = "";
2658         foreach($boutons as $page => $detail){
2659                 if ($detail->icone AND strlen(trim($detail->icone)))
2660                         $res .="\n.navigation_avec_icones #bando1_$page {background-image:url(".$detail->icone.");}";
2661                 $selecteur = (in_array($page,array('outils_rapides','outils_collaboratifs'))?"":".navigation_avec_icones ");
2662                 if (is_array($detail->sousmenu))
2663                         foreach($detail->sousmenu as $souspage=>$sousdetail)
2664                                 if ($sousdetail->icone AND strlen(trim($sousdetail->icone)))
2665                                         $res .="\n$selecteur.bando2_$souspage {background-image:url(".$sousdetail->icone.");}";
2666         }
2667         return $res;
2668 }
2669
2670 /**
2671  * Generer un bouton_action
2672  * utilise par #BOUTON_ACTION
2673  *
2674  * @param string $libelle
2675  * @param string $url
2676  * @param string $class
2677  * @param string $confirm
2678  *   message de confirmation oui/non avant l'action
2679  * @param string $title
2680  * @param string $callback
2681  *   callback js a appeler lors de l'evenement action (apres confirmation eventuelle si $confirm est non vide)
2682  *   et avant execution de l'action. Si la callback renvoie false, elle annule le declenchement de l'action
2683  * @return string
2684  */
2685 function bouton_action($libelle, $url, $class="", $confirm="", $title="", $callback=""){
2686         if ($confirm) {
2687                 $confirm = "confirm(\"" . attribut_html($confirm) . "\")";
2688           if ($callback)
2689                   $callback = "$confirm?($callback):false";
2690           else
2691                   $callback = $confirm;
2692         }
2693         $onclick = $callback?" onclick='return ".addcslashes($callback,"'")."'":"";
2694         $title = $title ? " title='$title'" : "";
2695         return "<form class='bouton_action_post $class' method='post' action='$url'><div>".form_hidden($url)
2696                 ."<button type='submit' class='submit'$title$onclick>$libelle</button></div></form>";
2697 }
2698
2699
2700 /**
2701  * Proteger les champs passes dans l'url et utiliser dans {tri ...}
2702  * preserver l'espace pour interpreter ensuite num xxx et multi xxx
2703  * @param string $t
2704  * @return string
2705  */
2706 function tri_protege_champ($t){
2707         return preg_replace(',[^\s\w.+],','',$t);
2708 }
2709
2710 /**
2711  * Interpreter les multi xxx et num xxx utilise comme tri
2712  * pour la clause order
2713  * 'multi xxx' devient simplement 'multi' qui est calcule dans le select
2714  * @param string $t
2715  * @param array $from
2716  * @return string
2717  */
2718 function tri_champ_order($t, $from=null){
2719         if(strncmp($t,'multi ',6)==0){
2720                 return "multi";
2721         }
2722
2723         $champ = $t;
2724
2725         if (strncmp($t,'num ',4)==0)
2726                 $champ = substr($t,4);
2727         // enlever les autres espaces non evacues par tri_protege_champ
2728         $champ = preg_replace(',\s,','',$champ);
2729
2730         if (is_array($from)){
2731                 $trouver_table = charger_fonction('trouver_table','base');
2732                 foreach($from as $idt=>$table_sql){
2733                         if ($desc = $trouver_table($table_sql)
2734                                 AND isset($desc['field'][$champ])){
2735                                 $champ = "$idt.$champ";
2736                                 break;
2737                         }
2738                 }
2739         }
2740         if (strncmp($t,'num ',4)==0)
2741                 return "0+$champ";
2742         else
2743                 return $champ;
2744 }
2745
2746 /**
2747  * Interpreter les multi xxx et num xxx utilise comme tri
2748  * pour la clause select
2749  * 'multi xxx' devient select "...." as multi
2750  * les autres cas ne produisent qu'une chaine vide '' en select
2751  * 'hasard' devient 'rand() AS hasard' dans le select
2752  *
2753  * @param string $t
2754  * @return string
2755  */
2756 function tri_champ_select($t){
2757         if(strncmp($t,'multi ',6)==0){
2758                 $t = substr($t,6);
2759                 $t = preg_replace(',\s,','',$t);
2760                 $t = sql_multi($t,$GLOBALS['spip_lang']);
2761                 return $t;
2762         }
2763         if(trim($t)=='hasard'){
2764                 return 'rand() AS hasard';
2765         }
2766         return "''";
2767 }
2768
2769
2770 /**
2771  * Donner n'importe quelle information sur un objet de maniere generique.
2772  *
2773  * La fonction va gerer en interne deux cas particuliers les plus utilises :
2774  * l'URL et le titre (qui n'est pas forcemment le champ SQL "titre").
2775  *
2776  * On peut ensuite personnaliser les autres infos en creant une fonction
2777  * generer_<nom_info>_entite($id_objet, $type_objet, $ligne).
2778  * $ligne correspond a la ligne SQL de tous les champs de l'objet, les fonctions
2779  * de personnalisation n'ont donc pas a refaire de requete.
2780  *
2781  * @param int $id_objet
2782  * @param string $type_objet
2783  * @param string $info
2784  * @param string $etoile
2785  * @return string
2786  */
2787 function generer_info_entite($id_objet, $type_objet, $info, $etoile=""){
2788         global $table_des_traitements;
2789         static $trouver_table=null;
2790         static $objets;
2791
2792         // On verifie qu'on a tout ce qu'il faut
2793         $id_objet = intval($id_objet);
2794         if (!($id_objet and $type_objet and $info))
2795                 return '';
2796
2797         // si on a deja note que l'objet n'existe pas, ne pas aller plus loin
2798         if (isset($objets[$type_objet]) AND $objets[$type_objet]===false)
2799                 return '';
2800
2801         // Si on demande l'url, on retourne direct la fonction
2802         if ($info == 'url')
2803                 return generer_url_entite($id_objet, $type_objet);
2804
2805         // Sinon on va tout chercher dans la table et on garde en memoire
2806         $demande_titre = ($info == 'titre');
2807
2808         // 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
2809         if (!isset($objets[$type_objet][$id_objet])
2810           OR
2811           ($demande_titre AND !isset($objets[$type_objet][$id_objet]['titre']))
2812           ){
2813                 if (!$trouver_table)
2814                         $trouver_table = charger_fonction('trouver_table','base');
2815                 $desc = $trouver_table(table_objet_sql($type_objet));
2816                 if (!$desc)
2817                         return $objets[$type_objet] = false;
2818
2819                 // Si on demande le titre, on le gere en interne
2820                 $champ_titre = "";
2821                 if ($demande_titre){
2822                         // si pas de titre declare mais champ titre, il sera peuple par le select *
2823                         $champ_titre = (!empty($desc['titre'])) ? ', ' . $desc['titre']:'';
2824                 }
2825                 include_spip('base/abstract_sql');
2826                 include_spip('base/connect_sql');
2827                 $objets[$type_objet][$id_objet] = sql_fetsel(
2828                         '*'.$champ_titre,
2829                         $desc['table_sql'],
2830                         id_table_objet($type_objet).' = '.intval($id_objet)
2831                 );
2832         }
2833
2834         // Si la fonction generer_TRUC_TYPE existe, on l'utilise pour formater $info_generee
2835         if ($generer = charger_fonction("generer_${info}_${type_objet}", '', true))
2836                 $info_generee = $generer($id_objet, $objets[$type_objet][$id_objet]);
2837         // Si la fonction generer_TRUC_entite existe, on l'utilise pour formater $info_generee
2838         else if ($generer = charger_fonction("generer_${info}_entite", '', true))
2839                 $info_generee = $generer($id_objet, $type_objet, $objets[$type_objet][$id_objet]);
2840         // Sinon on prend directement le champ SQL tel quel
2841         else
2842                 $info_generee = (isset($objets[$type_objet][$id_objet][$info])?$objets[$type_objet][$id_objet][$info]:'');
2843
2844         // On va ensuite chercher les traitements automatiques a faire
2845         $champ = strtoupper($info);
2846         $traitement = isset($table_des_traitements[$champ]) ? $table_des_traitements[$champ] : false;
2847         $table_sql = table_objet_sql($type_objet);
2848
2849         if (!$etoile
2850                 AND is_array($traitement)
2851           AND (isset($traitement[$table_sql]) OR isset($traitement[0]))){
2852                 $traitement = $traitement[isset($traitement[$table_sql]) ? $table_sql : 0];
2853                 $traitement = str_replace('%s', "'".texte_script($info_generee)."'", $traitement);
2854                 // FIXME: $connect et $Pile[0] font souvent partie des traitements.
2855                 // on les definit pour eviter des notices, mais ce fonctionnement est a ameliorer !
2856                 $connect = ""; $Pile = array(0 => array('id_objet'=>$id_objet,'objet'=>$type_objet));
2857                 eval("\$info_generee = $traitement;");
2858         }
2859
2860         return $info_generee;
2861 }
2862
2863 /**
2864  * Wrap un texte avec des balises
2865  * wrap('mot','<b>') => '<b>mot</b>'
2866  * @param string $texte
2867  * @param string $wrap
2868  * @return string
2869  */
2870 function wrap($texte,$wrap) {
2871         $balises = extraire_balises($wrap);
2872         if (preg_match_all(",<([a-z]\w*)\b[^>]*>,UimsS",$wrap, $regs, PREG_PATTERN_ORDER)) {
2873                 $texte = $wrap . $texte;
2874                 $regs = array_reverse($regs[1]);
2875                 $wrap = "</".implode("></",$regs).">";
2876                 $texte = $texte . $wrap;
2877         }
2878         return $texte;
2879 }
2880
2881
2882 // afficher proprement n'importe quoi
2883 // en cas de table profonde, l'option $join ne s'applique qu'au plus haut niveau
2884 // c'est VOULU !  Exemple : [(#VALEUR|print{<hr />})] va afficher de gros blocs
2885 // separes par des lignes, avec a l'interieur des trucs separes par des virgules
2886 function filtre_print_dist($u, $join=', ') {
2887         if (is_string($u))
2888                 return typo($u);
2889
2890         if (is_array($u))
2891                 return join($join, array_map('filtre_print_dist', $u));
2892
2893         if (is_object($u))
2894                 return join($join, array_map('filtre_print_dist', (array) $u));
2895
2896         return $u;
2897 }
2898
2899
2900 /**
2901  * Renvoyer l'info d'un objet
2902  * telles que definies dans declarer_tables_objets_sql
2903  *
2904  * @param string $objet
2905  * @param string $info
2906  * @return string
2907  */
2908 function objet_info($objet,$info){
2909         $table = table_objet_sql($objet);
2910         $infos = lister_tables_objets_sql($table);
2911         return (isset($infos[$info])?$infos[$info]:'');
2912 }
2913
2914 /**
2915  * Filtre pour afficher 'Aucun truc' ou '1 truc' ou 'N trucs'
2916  * avec la bonne chaine de langue en fonction de l'objet utilise
2917  * @param  $nb
2918  * @param  $objet
2919  * @return mixed|string
2920  */
2921 function objet_afficher_nb($nb, $objet){
2922         if (!$nb)
2923                 return _T(objet_info($objet,'info_aucun_objet'));
2924         else
2925                 return _T(objet_info($objet,$nb==1?'info_1_objet':'info_nb_objets'),array('nb'=>$nb));
2926 }
2927
2928 /**
2929  * Filtre pour afficher l'img icone d'un objet
2930  *
2931  * @param string $objet
2932  * @param int $taille
2933  * @return string
2934  */
2935 function objet_icone($objet,$taille=24){
2936         $icone = objet_info($objet,'icone_objet')."-".$taille.".png";
2937         $icone = chemin_image($icone);
2938         $balise_img = charger_filtre('balise_img');
2939         return $icone?$balise_img($icone,_T(objet_info($objet,'texte_objet'))):'';
2940 }
2941
2942 /**
2943  * Fonction de secours pour inserer le head_css de facon conditionnelle
2944  *
2945  * Appelée en filtre sur le squelette qui contient #INSERT_HEAD,
2946  * elle vérifie l'absence éventuelle de #INSERT_HEAD_CSS et y suplée si besoin
2947  * pour assurer la compat avec les squelettes qui n'utilisent pas.
2948  *
2949  * @param string $flux Code HTML
2950  * @return string      Code HTML
2951  */
2952 function insert_head_css_conditionnel($flux){
2953         if (strpos($flux,'<!-- insert_head_css -->')===false
2954                 AND $p=strpos($flux,'<!-- insert_head -->')){
2955                 // plutot avant le premier js externe (jquery) pour etre non bloquant
2956                 if ($p1 = stripos($flux,'<script src=') AND $p1<$p)
2957                         $p = $p1;
2958                 $flux = substr_replace($flux,pipeline('insert_head_css','<!-- insert_head_css -->'),$p,0);
2959         }
2960         return $flux;
2961 }
2962
2963 /**
2964  * Produire un fichier statique a partir d'un squelette dynamique
2965  * Permet ensuite a apache de le servir en statique sans repasser
2966  * par spip.php a chaque hit sur le fichier
2967  * si le format (css ou js) est passe dans contexte['format'], on l'utilise
2968  * sinon on regarde si le fond finit par .css ou .js
2969  * sinon on utilie "html"
2970  *
2971  * @param string $fond
2972  * @param array $contexte
2973  * @param array $options
2974  * @param string $connect
2975  * @return string
2976  */
2977 function produire_fond_statique($fond, $contexte=array(), $options = array(), $connect=''){
2978         if (isset($contexte['format'])){
2979                 $extension = $contexte['format'];
2980                 unset($contexte['format']);
2981         }
2982         else {
2983                 $extension = "html";
2984                 if (preg_match(',[.](css|js|json)$,',$fond,$m))
2985                         $extension = $m[1];
2986         }
2987         // recuperer le contenu produit par le squelette
2988         $options['raw'] = true;
2989         $cache = recuperer_fond($fond,$contexte,$options,$connect);
2990
2991         // calculer le nom de la css
2992         $dir_var = sous_repertoire (_DIR_VAR, 'cache-'.$extension);
2993         $nom_safe = preg_replace(",\W,",'_',str_replace('.','_',$fond));
2994         $filename = $dir_var . $extension."dyn-$nom_safe-".substr(md5($fond.serialize($contexte).$connect),0,8) .".$extension";
2995
2996         // mettre a jour le fichier si il n'existe pas
2997         // ou trop ancien
2998         if (!file_exists($filename)
2999                 OR (isset($cache['lastmodified']) AND $cache['lastmodified'] AND filemtime($filename)<$cache['lastmodified'])
3000                 OR (defined('_VAR_MODE') AND _VAR_MODE=='recalcul'))
3001         {
3002                 $contenu = $cache['texte'];
3003                 // passer les urls en absolu si c'est une css
3004                 if ($extension=="css")
3005                         $contenu = urls_absolues_css($contenu, test_espace_prive()?generer_url_ecrire('accueil'):generer_url_public($fond));
3006
3007                 // ne pas insérer de commentaire si c'est du json
3008                 if ($extension!="json") {
3009                         $comment = "/* #PRODUIRE{fond=$fond";
3010                         foreach($contexte as $k=>$v)
3011                                 $comment .= ",$k=$v";
3012                         $comment .="} le ".date("Y-m-d H:i:s")." */\n";
3013                 }
3014                 // et ecrire le fichier
3015                 ecrire_fichier($filename,$comment.$contenu);
3016         }
3017
3018         return $filename;
3019 }
3020
3021 /**
3022  * Ajouter un timestamp a une url de fichier
3023  * [(#CHEMIN{monfichier}|timestamp)]
3024  *
3025  * @param string $fichier
3026  * @return string
3027  */
3028 function timestamp($fichier){
3029         if (!$fichier) return $fichier;
3030         $m = filemtime($fichier);
3031         return "$fichier?$m";
3032 }
3033
3034 /**
3035  * Nettoyer le titre d'un email
3036  * eviter une erreur lorsqu'on utilise |nettoyer_titre_email dans un squelette de mail
3037  * @param  $titre
3038  * @return mixed
3039  */
3040 function filtre_nettoyer_titre_email_dist($titre){
3041         include_spip('inc/envoyer_mail');
3042         return nettoyer_titre_email($titre);
3043 }
3044
3045 /**
3046  * Afficher le sélecteur de rubrique
3047  *
3048  * Il permet de placer un objet dans la hiérarchie des rubriques de SPIP
3049  *
3050  * @param string $titre
3051  * @param int $id_objet
3052  * @param int $id_parent
3053  * @param string $objet
3054  * @param int $id_secteur
3055  * @param bool $restreint
3056  * @param bool $actionable
3057  *   true : fournit le selecteur dans un form directement postable
3058  * @param bool $retour_sans_cadre
3059  * @return string
3060  */
3061 function filtre_chercher_rubrique_dist($titre,$id_objet, $id_parent, $objet, $id_secteur, $restreint,$actionable = false, $retour_sans_cadre=false){
3062         include_spip('inc/filtres_ecrire');
3063         return chercher_rubrique($titre,$id_objet, $id_parent, $objet, $id_secteur, $restreint,$actionable, $retour_sans_cadre);
3064 }
3065
3066 /**
3067  * Rediriger une page suivant une autorisation,
3068  * et ce, n'importe où dans un squelette, même dans les inclusions.
3069  * Exemple :
3070  * [(#AUTORISER{non}|sinon_interdire_acces)]
3071  * [(#AUTORISER{non}|sinon_interdire_acces{#URL_PAGE{login}, 401})]
3072  *
3073  * @param bool $ok Indique si l'on doit rediriger ou pas
3074  * @param string $url Adresse vers laquelle rediriger
3075  * @param int $statut Statut HTML avec lequel on redirigera
3076  * @return string
3077  */
3078 function sinon_interdire_acces($ok=false, $url='', $statut=0){
3079         if ($ok) return '';
3080
3081         // Vider tous les tampons
3082         $level = @ob_get_level();
3083         while ($level--)
3084                 @ob_end_clean();
3085
3086         include_spip('inc/headers');
3087         $statut = intval($statut);
3088
3089         // Si aucun argument on essaye de deviner quoi faire par défaut
3090         if (!$url and !$statut){
3091                 // Si on est dans l'espace privé, on génère du 403 Forbidden
3092                 if (test_espace_prive()){
3093                         http_status(403);
3094                         $echec = charger_fonction('403','exec');
3095                         $echec();
3096                 }
3097                 // Sinon dans l'espace public on redirige vers une 404 par défaut, car elle toujours présente normalement
3098                 else{
3099                         $statut = 404;
3100                 }
3101         }
3102
3103         // On suit les directives indiquées dans les deux arguments
3104
3105         // S'il y a un statut
3106         if ($statut){
3107                 // Dans tous les cas on modifie l'entité avec ce qui est demandé
3108                 http_status($statut);
3109                 // Si le statut est une erreur et qu'il n'y a pas de redirection on va chercher le squelette du même nom
3110                 if ($statut >= 400 and !$url)
3111                         echo recuperer_fond("$statut");
3112         }
3113
3114         // S'il y a une URL, on redirige (si pas de statut, la fonction mettra 302 par défaut)
3115         if ($url) redirige_par_entete($url, '', $statut);
3116
3117         exit;
3118 }
3119
3120 /**
3121  * Assurer le fonctionnement de |compacte meme sans l'extension compresseur
3122  * @param string $source
3123  * @param null|string $format
3124  * @return string
3125  */
3126 function filtre_compacte_dist($source, $format = null){
3127         if (function_exists('compacte'))
3128                 return compacte($source, $format);
3129         return $source;
3130 }
3131
3132 ?>