www/ecrire/inc/filtres.php

   1 <?php
   2
   3 /***************************************************************************\
   4  *  SPIP, Systeme de publication pour l'internet                           *
   5  *                                                                         *
   6  *  Copyright (c) 2001-2011                                                *
   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
  18 /**
  19  * Charger un filtre depuis le php :
  20  * - on inclue tous les fichiers fonctions des plugins et du skel
  21  * - on appelle chercher_filtre
  22  */
  23 function charger_filtre($fonc, $default=NULL) {
  24         include_spip('public/parametrer'); // inclure les fichiers fonctions
  25         return chercher_filtre($fonc, $default);
  26 }
  27
  28 // http://adoc.spip.org/@chercher_filtre
  29 function chercher_filtre($fonc, $default=NULL) {
  30         // Cas MIME = type/subtype
  31         // sans confondre avec les appels de fonction de classe Foo::Bar
  32         // qui peuvent etre avec un namespace : space\Foo::Bar
  33         if (strpos($fonc, '/')){
  34                 $f = preg_replace(',\W,','_', $fonc);
  35                 if ($f = chercher_filtre($f)) return $f;
  36                 // cas du sous-type MIME sans filtre associe, passer au type:
  37                 // si filtre_text_plain pas defini, passe a filtre_text
  38                 $fonc = preg_replace(',\W.*$,','', $fonc);
  39         }
  40         if (!$fonc) return $default;
  41         foreach (
  42         array('filtre_'.$fonc, 'filtre_'.$fonc.'_dist', $fonc) as $f){
  43                 if (is_string($g = $GLOBALS['spip_matrice'][$f]))
  44                         find_in_path($g,'', true);
  45                 if (function_exists($f)
  46                 OR (preg_match("/^(\w*)::(\w*)$/", $f, $regs)
  47                         AND is_callable(array($regs[1], $regs[2]))
  48                 )) {
  49                         return $f;
  50                 }
  51         }
  52         return $default;
  53 }
  54
  55 // http://doc.spip.org/@appliquer_filtre
  56 function appliquer_filtre($arg, $filtre) {
  57         $f = chercher_filtre($filtre);
  58         if (!$f)
  59                 return ''; // ou faut-il retourner $arg inchange == filtre_identite?
  60
  61         $args = func_get_args();
  62         array_shift($args); // enlever $arg
  63         array_shift($args); // enlever $filtre
  64         array_unshift($args, $arg); // remettre $arg
  65         return call_user_func_array($f,$args);
  66 }
  67
  68 // http://doc.spip.org/@spip_version
  69 function spip_version() {
  70         $version = $GLOBALS['spip_version_affichee'];
  71         if ($svn_revision = version_svn_courante(_DIR_RACINE))
  72                 $version .= ($svn_revision<0 ? ' SVN':'').' ['.abs($svn_revision).']';
  73         return $version;
  74 }
  75
  76
  77 //
  78 // Mention de la revision SVN courante de l'espace restreint standard
  79 // (numero non garanti pour l'espace public et en cas de mutualisation)
  80 // on est negatif si on est sur .svn, et positif si on utilise svn.revision
  81 // http://doc.spip.org/@version_svn_courante
  82 function version_svn_courante($dir) {
  83         if (!$dir) $dir = '.';
  84
  85         // version installee par paquet ZIP
  86         if (lire_fichier($dir.'/svn.revision', $c)
  87         AND preg_match(',Revision: (\d+),', $c, $d))
  88                 return intval($d[1]);
  89
  90         // version installee par SVN
  91         if (lire_fichier($dir . '/.svn/entries', $c)
  92         AND (
  93         (preg_match_all(
  94         ',committed-rev="([0-9]+)",', $c, $r1, PREG_PATTERN_ORDER)
  95         AND $v = max($r1[1])
  96         )
  97         OR
  98         (preg_match(',^\d.*dir[\r\n]+(\d+),ms', $c, $r1) # svn >= 1.4
  99         AND $v = $r1[1]
 100         )))
 101                 return -$v;
 102
 103         // Bug ou paquet fait main
 104         return 0;
 105 }
 106
 107 // La matrice est necessaire pour ne filtrer _que_ des fonctions definies dans filtres_images
 108 // et laisser passer les fonctions personnelles baptisees image_...
 109 $GLOBALS['spip_matrice']['image_graver'] = 'inc/filtres_images_mini.php';
 110 $GLOBALS['spip_matrice']['image_select'] = 'inc/filtres_images_mini.php';
 111 $GLOBALS['spip_matrice']['image_reduire'] = 'inc/filtres_images_mini.php';
 112 $GLOBALS['spip_matrice']['image_reduire_par'] = 'inc/filtres_images_mini.php';
 113 $GLOBALS['spip_matrice']['image_passe_partout'] = 'inc/filtres_images_mini.php';
 114
 115 $GLOBALS['spip_matrice']['couleur_html_to_hex'] = 'inc/filtres_images_mini.php';
 116 $GLOBALS['spip_matrice']['couleur_foncer'] = 'inc/filtres_images_mini.php';
 117 $GLOBALS['spip_matrice']['couleur_eclaircir'] = 'inc/filtres_images_mini.php';
 118
 119 // ou pour inclure un script au moment ou l'on cherche le filtre
 120 $GLOBALS['spip_matrice']['filtre_image_dist'] = 'inc/filtres_mime.php';
 121 $GLOBALS['spip_matrice']['filtre_audio_dist'] = 'inc/filtres_mime.php';
 122 $GLOBALS['spip_matrice']['filtre_video_dist'] = 'inc/filtres_mime.php';
 123 $GLOBALS['spip_matrice']['filtre_application_dist'] = 'inc/filtres_mime.php';
 124 $GLOBALS['spip_matrice']['filtre_message_dist'] = 'inc/filtres_mime.php';
 125 $GLOBALS['spip_matrice']['filtre_multipart_dist'] = 'inc/filtres_mime.php';
 126 $GLOBALS['spip_matrice']['filtre_text_dist'] = 'inc/filtres_mime.php';
 127 $GLOBALS['spip_matrice']['filtre_text_csv_dist'] = 'inc/filtres_mime.php';
 128 $GLOBALS['spip_matrice']['filtre_text_html_dist'] = 'inc/filtres_mime.php';
 129 $GLOBALS['spip_matrice']['filtre_audio_x_pn_realaudio'] = 'inc/filtres_mime.php';
 130
 131
 132 // charge les fonctions graphiques et applique celle demandee
 133 // http://doc.spip.org/@filtrer
 134 function filtrer($filtre) {
 135         include_spip('public/parametrer'); // charger les fichiers fonctions
 136         if (is_string($f = $GLOBALS['spip_matrice'][$filtre]))
 137                 find_in_path($f,'', true);
 138         $tous = func_get_args();
 139         if (substr($filtre,0,6)=='image_' && $GLOBALS['spip_matrice'][$filtre])
 140                 return image_filtrer($tous);
 141         elseif($f = chercher_filtre($filtre)) {
 142                 array_shift($tous);
 143                 return call_user_func_array($f, $tous);
 144         }
 145         else {
 146                 // le filtre n'existe pas, on provoque une erreur
 147                 $msg = array('zbug_erreur_filtre', array('filtre'=>texte_script($filtre)));
 148                 erreur_squelette($msg);
 149                 return '';
 150         }
 151 }
 152
 153 // fonction generique d'entree des filtres images
 154 // accepte en entree un texte complet, un img-log (produit par #LOGO_XX),
 155 // un tag <img ...> complet, ou encore un nom de fichier *local* (passer
 156 // le filtre |copie_locale si on veut l'appliquer a un document)
 157 // applique le filtre demande a chacune des occurrences
 158
 159 // http://doc.spip.org/@image_filtrer
 160 function image_filtrer($args){
 161         $filtre = array_shift($args); # enlever $filtre
 162         $texte = array_shift($args);
 163         if (!strlen($texte)) return;
 164         find_in_path('filtres_images_mini.php','inc/', true);
 165         statut_effacer_images_temporaires(true); // activer la suppression des images temporaires car le compilo finit la chaine par un image_graver
 166         // Cas du nom de fichier local
 167         if ( strpos(substr($texte,strlen(_DIR_RACINE)),'..')===FALSE
 168         AND !preg_match(',^/|[<>]|\s,S', $texte)
 169         AND (
 170                 file_exists(preg_replace(',[?].*$,','',$texte))
 171                 OR preg_match(';^(\w{3,7}://);', $texte)
 172                 )) {
 173                 array_unshift($args,"<img src='$texte' />");
 174                 $res = call_user_func_array($filtre, $args);
 175                 statut_effacer_images_temporaires(false); // desactiver pour les appels hors compilo
 176                 return $res;
 177         }
 178
 179         // Cas general : trier toutes les images, avec eventuellement leur <span>
 180         if (preg_match_all(
 181                 ',(<([a-z]+) [^<>]*spip_documents[^<>]*>)?\s*(<img\s.*>),UimsS',
 182                 $texte, $tags, PREG_SET_ORDER)) {
 183                 foreach ($tags as $tag) {
 184                         $class = extraire_attribut($tag[3],'class');
 185                         if (!$class || (strpos($class,'no_image_filtrer')===FALSE)){
 186                                 array_unshift($args,$tag[3]);
 187                                 if ($reduit = call_user_func_array($filtre, $args)) {
 188                                         // En cas de span spip_documents, modifier le style=...width:
 189                                         if($tag[1]){
 190                                                 $w = extraire_attribut($reduit, 'width');
 191                                                 if (!$w AND preg_match(",width:\s*(\d+)px,S",extraire_attribut($reduit,'style'),$regs))
 192                                                         $w = $regs[1];
 193                                                 if ($w AND ($style = extraire_attribut($tag[1], 'style'))){
 194                                                         $style = preg_replace(",width:\s*\d+px,S", "width:${w}px", $style);
 195                                                         $replace = inserer_attribut($tag[1], 'style', $style);
 196                                                         $texte = str_replace($tag[1], $replace, $texte);
 197                                                 }
 198                                         }
 199                                         // traiter aussi un eventuel mouseover
 200                                         if ($mouseover = extraire_attribut($reduit,'onmouseover')){
 201                                                 if (preg_match(",this[.]src=['\"]([^'\"]+)['\"],ims", $mouseover, $match)){
 202                                                         $srcover = $match[1];
 203                                                         array_shift($args);
 204                                                         array_unshift($args,"<img src='".$match[1]."' />");
 205                                                         $srcover_filter = call_user_func_array($filtre, $args);
 206                                                         $srcover_filter = extraire_attribut($srcover_filter,'src');
 207                                                         $reduit = str_replace($srcover,$srcover_filter,$reduit);
 208                                                 }
 209                                         }
 210                                         $texte = str_replace($tag[3], $reduit, $texte);
 211                                 }
 212                                 array_shift($args);
 213                         }
 214                 }
 215         }
 216         statut_effacer_images_temporaires(false); // desactiver pour les appels hors compilo
 217         return $texte;
 218 }
 219
 220 // pour les feuilles de style CSS du prive
 221 function filtre_background_image_dist ($img, $couleur, $pos="") {
 222         if (!function_exists("imagecreatetruecolor")
 223           OR !include_spip('filtres/images_transforme')
 224           OR !function_exists('image_sepia')
 225           OR !function_exists('image_aplatir')
 226           )
 227                 return "background-color: #$couleur;";
 228         return "background: url(".url_absolue(extraire_attribut(image_aplatir(image_sepia($img, $couleur),"gif","cccccc", 64, true), "src")).") $pos;";
 229 }
 230
 231 //
 232 // Retourner taille d'une image
 233 // pour les filtres |largeur et |hauteur
 234 //
 235 // http://doc.spip.org/@taille_image
 236 function taille_image($img) {
 237
 238         static $largeur_img =array(), $hauteur_img= array();
 239         $srcWidth = 0;
 240         $srcHeight = 0;
 241
 242         $logo = extraire_attribut($img,'src');
 243
 244         if (!$logo) $logo = $img;
 245         else {
 246                 $srcWidth = extraire_attribut($img,'width');
 247                 $srcHeight = extraire_attribut($img,'height');
 248         }
 249
 250         // ne jamais operer directement sur une image distante pour des raisons de perfo
 251         // la copie locale a toutes les chances d'etre la ou de resservir
 252         if (preg_match(';^(\w{3,7}://);', $logo)){
 253                 include_spip('inc/distant');
 254                 $fichier = copie_locale($logo);
 255                 $logo = $fichier ? _DIR_RACINE . $fichier : $logo;
 256         }
 257         if (($p=strpos($logo,'?'))!==FALSE)
 258                 $logo=substr($logo,0,$p);
 259
 260         $srcsize = false;
 261         if (isset($largeur_img[$logo]))
 262                 $srcWidth = $largeur_img[$logo];
 263         if (isset($hauteur_img[$logo]))
 264                 $srcHeight = $hauteur_img[$logo];
 265         if (!$srcWidth OR !$srcHeight){
 266                 if ($srcsize = @getimagesize($logo)){
 267                         if (!$srcWidth) $largeur_img[$logo] = $srcWidth = $srcsize[0];
 268                         if (!$srcHeight)        $hauteur_img[$logo] = $srcHeight = $srcsize[1];
 269                 }
 270                 // $logo peut etre une reference a une image temporaire dont a n'a que le log .src
 271                 // on s'y refere, l'image sera reconstruite en temps utile si necessaire
 272                 elseif(@file_exists($f = "$logo.src")
 273                   AND lire_fichier($f,$valeurs)
 274                   AND $valeurs=unserialize($valeurs)) {
 275                         if (!$srcWidth) $largeur_img[$mem] = $srcWidth = $valeurs["largeur_dest"];
 276                         if (!$srcHeight)        $hauteur_img[$mem] = $srcHeight = $valeurs["hauteur_dest"];
 277           }
 278         }
 279         return array($srcHeight, $srcWidth);
 280 }
 281 // http://doc.spip.org/@largeur
 282 function largeur($img) {
 283         if (!$img) return;
 284         list ($h,$l) = taille_image($img);
 285         return $l;
 286 }
 287 // http://doc.spip.org/@hauteur
 288 function hauteur($img) {
 289         if (!$img) return;
 290         list ($h,$l) = taille_image($img);
 291         return $h;
 292 }
 293
 294
 295 // Echappement des entites HTML avec correction des entites "brutes"
 296 // (generees par les butineurs lorsqu'on rentre des caracteres n'appartenant
 297 // pas au charset de la page [iso-8859-1 par defaut])
 298 //
 299 // Attention on limite cette correction aux caracteres "hauts" (en fait > 99
 300 // pour aller plus vite que le > 127 qui serait logique), de maniere a
 301 // preserver des echappements de caracteres "bas" (par exemple [ ou ")
 302 // et au cas particulier de &amp; qui devient &amp;amp; dans les url
 303 // http://doc.spip.org/@corriger_entites_html
 304 function corriger_entites_html($texte) {
 305         if (strpos($texte,'&amp;') === false) return $texte;
 306         return preg_replace(',&amp;(#[0-9][0-9][0-9]+;|amp;),iS', '&\1', $texte);
 307 }
 308 // idem mais corriger aussi les &amp;eacute; en &eacute;
 309 // http://doc.spip.org/@corriger_toutes_entites_html
 310 function corriger_toutes_entites_html($texte) {
 311         if (strpos($texte,'&amp;') === false) return $texte;
 312         return preg_replace(',&amp;(#?[a-z0-9]+;),iS', '&\1', $texte);
 313 }
 314
 315 // http://doc.spip.org/@proteger_amp
 316 function proteger_amp($texte){
 317         return str_replace('&','&amp;',$texte);
 318 }
 319 // http://doc.spip.org/@entites_html
 320 function entites_html($texte, $tout=false) {
 321         if (!is_string($texte) OR !$texte
 322         OR !preg_match(",[&\"'<>],S", $texte) # strpbrk($texte, "&\"'<>")!==false
 323         ) return $texte;
 324         include_spip('inc/texte');
 325         $texte = htmlspecialchars(echappe_retour(echappe_html($texte,'',true),'','proteger_amp'));
 326         if ($tout)
 327                 return corriger_toutes_entites_html($texte);
 328         else
 329                 return corriger_entites_html($texte);
 330 }
 331
 332 // Transformer les &eacute; dans le charset local
 333 // http://doc.spip.org/@filtrer_entites
 334 function filtrer_entites($texte) {
 335         if (strpos($texte,'&') === false) return $texte;
 336         // filtrer
 337         $texte = html2unicode($texte);
 338         // remettre le tout dans le charset cible
 339         return unicode2charset($texte);
 340 }
 341
 342 // caracteres de controle - http://www.w3.org/TR/REC-xml/#charsets
 343 // http://doc.spip.org/@supprimer_caracteres_illegaux
 344 function supprimer_caracteres_illegaux($texte) {
 345         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";
 346         static $to = null;
 347
 348         if (is_array($texte)) {
 349                 return array_map('supprimer_caracteres_illegaux', $texte);
 350         }
 351         if (!$to) $to = str_repeat('-', strlen($from));
 352         return strtr($texte, $from, $to);
 353 }
 354
 355 // Supprimer caracteres windows et les caracteres de controle ILLEGAUX
 356 // http://doc.spip.org/@corriger_caracteres
 357 function corriger_caracteres ($texte) {
 358         $texte = corriger_caracteres_windows($texte);
 359         $texte = supprimer_caracteres_illegaux($texte);
 360         return $texte;
 361 }
 362
 363 // Encode du HTML pour transmission XML
 364 // http://doc.spip.org/@texte_backend
 365 function texte_backend($texte) {
 366
 367         static $apostrophe = array("&#8217;", "'"); # n'allouer qu'une fois
 368
 369         // si on a des liens ou des images, les passer en absolu
 370         $texte = liens_absolus($texte);
 371
 372         // echapper les tags &gt; &lt;
 373         $texte = preg_replace(',&(gt|lt);,S', '&amp;\1;', $texte);
 374
 375         // importer les &eacute;
 376         $texte = filtrer_entites($texte);
 377
 378         // " -> &quot; et tout ce genre de choses
 379         $u = $GLOBALS['meta']['pcre_u'];
 380         $texte = str_replace("&nbsp;", " ", $texte);
 381         $texte = preg_replace('/\s{2,}/S'.$u, " ", $texte);
 382         $texte = entites_html($texte);
 383
 384         // verifier le charset
 385         $texte = charset2unicode($texte);
 386
 387         // Caracteres problematiques en iso-latin 1
 388         if ($GLOBALS['meta']['charset'] == 'iso-8859-1') {
 389                 $texte = str_replace(chr(156), '&#156;', $texte);
 390                 $texte = str_replace(chr(140), '&#140;', $texte);
 391                 $texte = str_replace(chr(159), '&#159;', $texte);
 392         }
 393
 394         // l'apostrophe curly pose probleme a certains lecteure de RSS
 395         // et le caractere apostrophe alourdit les squelettes avec PHP
 396         // ==> on les remplace par l'entite HTML
 397         return str_replace($apostrophe, "'", $texte);
 398 }
 399
 400 // Comme ci-dessus, mais avec addslashes final pour squelettes avec PHP (rss)
 401
 402 function texte_backendq($texte) {
 403         return addslashes(texte_backend($texte));
 404 }
 405
 406 // Enleve le numero des titres numerotes ("1. Titre" -> "Titre")
 407 // http://doc.spip.org/@supprimer_numero
 408 function supprimer_numero($texte) {
 409         return preg_replace(
 410         ",^[[:space:]]*([0-9]+)([.)]|".chr(194).'?'.chr(176).")[[:space:]]+,S",
 411         "", $texte);
 412 }
 413
 414 // et la fonction inverse
 415 // http://doc.spip.org/@recuperer_numero
 416 function recuperer_numero($texte) {
 417         if (preg_match(
 418         ",^[[:space:]]*([0-9]+)([.)]|".chr(194).'?'.chr(176).")[[:space:]]+,S",
 419         $texte, $regs))
 420                 return intval($regs[1]);
 421         else
 422                 return '';
 423 }
 424
 425 // Suppression basique et brutale de tous les <...>
 426 // http://doc.spip.org/@supprimer_tags
 427 function supprimer_tags($texte, $rempl = "") {
 428         $texte = preg_replace(",<[^>]*>,US", $rempl, $texte);
 429         // ne pas oublier un < final non ferme
 430         // mais qui peut aussi etre un simple signe plus petit que
 431         $texte = str_replace('<', ' ', $texte);
 432         return $texte;
 433 }
 434
 435 // Convertit les <...> en la version lisible en HTML
 436 // http://doc.spip.org/@echapper_tags
 437 function echapper_tags($texte, $rempl = "") {
 438         $texte = preg_replace("/<([^>]*)>/", "&lt;\\1&gt;", $texte);
 439         return $texte;
 440 }
 441
 442 // Convertit un texte HTML en texte brut
 443 // http://doc.spip.org/@textebrut
 444 function textebrut($texte) {
 445         $u = $GLOBALS['meta']['pcre_u'];
 446         $texte = preg_replace('/\s+/S'.$u, " ", $texte);
 447         $texte = preg_replace("/<(p|br)( [^>]*)?".">/iS", "\n\n", $texte);
 448         $texte = preg_replace("/^\n+/", "", $texte);
 449         $texte = preg_replace("/\n+$/", "", $texte);
 450         $texte = preg_replace("/\n +/", "\n", $texte);
 451         $texte = supprimer_tags($texte);
 452         $texte = preg_replace("/(&nbsp;| )+/S", " ", $texte);
 453         // nettoyer l'apostrophe curly qui pose probleme a certains rss-readers, lecteurs de mail...
 454         $texte = str_replace("&#8217;","'",$texte);
 455         return $texte;
 456 }
 457
 458 // Remplace les liens SPIP en liens ouvrant dans une nouvelle fenetre (target=blank)
 459 // http://doc.spip.org/@liens_ouvrants
 460 function liens_ouvrants ($texte) {
 461         return preg_replace(",<a ([^>]*https?://[^>]*class=[\"']spip_(out|url)\b[^>]+)>,",
 462                 "<a \\1 target=\"_blank\">", $texte);
 463 }
 464
 465 // Transformer les sauts de paragraphe en simples passages a la ligne
 466 // http://doc.spip.org/@PtoBR
 467 function PtoBR($texte){
 468         $u = $GLOBALS['meta']['pcre_u'];
 469         $texte = preg_replace("@</p>@iS", "\n", $texte);
 470         $texte = preg_replace("@<p\b.*>@UiS", "<br />", $texte);
 471         $texte = preg_replace("@^\s*<br />@S".$u, "", $texte);
 472         return $texte;
 473 }
 474
 475 // Couper les "mots" de plus de $l caracteres (souvent des URLs)
 476 // en mettant des espaces (par defaut, soft hyphen &#173: = &shy;)
 477 // http://doc.spip.org/@lignes_longues
 478 function lignes_longues($texte, $l = 70, $espace='&#173;') {
 479         if ($l<1) return $texte;
 480         if (!preg_match("/[\w,\/.]{".$l."}/UmsS", $texte))
 481                 return $texte;
 482         // Passer en utf-8 pour ne pas avoir de coupes trop courtes avec les &#xxxx;
 483         // qui prennent 7 caracteres
 484         #include_spip('inc/charsets');
 485         $texte = str_replace("&nbsp;","<&nbsp>",$texte);
 486         $texte = html2unicode($texte, true);
 487         $texte = str_replace("<&nbsp>","&nbsp;",$texte);
 488         $texte = unicode_to_utf_8(charset2unicode(
 489                 $texte, $GLOBALS['meta']['charset'], true));
 490
 491         // echapper les tags (on ne veut pas casser les a href=...)
 492         $tags = array();
 493         if (preg_match_all('/<.+>|&(?:amp;)?#x?[0-9]+;|&(?:amp;)?[a-zA-Z1-4]{2,6};/UumsS', $texte, $t, PREG_SET_ORDER)) {
 494                 foreach ($t as $n => $tag) {
 495                         $tags[$n] = $tag[0];
 496                         $texte = str_replace($tag[0], "<---$n--->", $texte);
 497                 }
 498         }
 499         // casser les mots longs qui restent
 500         // note : on pourrait preferer couper sur les / , etc.
 501         if (preg_match_all("/[\w,\/.]{".$l."}/UmsS", $texte, $longs, PREG_SET_ORDER)) {
 502                 foreach ($longs as $long) {
 503                         $texte = str_replace($long[0], $long[0].$espace, $texte);
 504                 }
 505         }
 506
 507         // retablir les tags
 508         if (preg_match_all('/<---[\s0-9]+--->/UumsS', $texte, $t, PREG_SET_ORDER)) {
 509                 foreach ($t as $tag) {
 510                         $n = intval(preg_replace(',[^0-9]+,U','',$tag[0]));
 511                         $texte = str_replace($tag[0], $tags[$n], $texte);
 512                 }
 513         }
 514
 515         return importer_charset($texte, 'utf-8');
 516 }
 517
 518 // Majuscules y compris accents, en HTML
 519 // http://doc.spip.org/@majuscules
 520 function majuscules($texte) {
 521         if (!strlen($texte)) return '';
 522
 523         // Cas du turc
 524         if ($GLOBALS['spip_lang'] == 'tr') {
 525                 # remplacer hors des tags et des entites
 526                 if (preg_match_all(',<[^<>]+>|&[^;]+;,S', $texte, $regs, PREG_SET_ORDER))
 527                         foreach ($regs as $n => $match)
 528                                 $texte = str_replace($match[0], "@@SPIP_TURC$n@@", $texte);
 529
 530                 $texte = str_replace('i', '&#304;', $texte);
 531
 532                 if ($regs)
 533                         foreach ($regs as $n => $match)
 534                                 $texte = str_replace("@@SPIP_TURC$n@@", $match[0], $texte);
 535         }
 536
 537         // Cas general
 538         return "<span style='text-transform: uppercase;'>$texte</span>";
 539 }
 540
 541 // "127.4 ko" ou "3.1 Mo"
 542 // http://doc.spip.org/@taille_en_octets
 543 function taille_en_octets ($taille) {
 544         if ($taille < 1024) {$taille = _T('taille_octets', array('taille' => $taille));}
 545         else if ($taille < 1024*1024) {
 546                 $taille = _T('taille_ko', array('taille' => ((floor($taille / 102.4))/10)));
 547         } else {
 548                 $taille = _T('taille_mo', array('taille' => ((floor(($taille / 1024) / 102.4))/10)));
 549         }
 550         return $taille;
 551 }
 552
 553
 554 // Rend une chaine utilisable sans dommage comme attribut HTML
 555 // http://doc.spip.org/@attribut_html
 556 function attribut_html($texte,$textebrut = true) {
 557         $u = $GLOBALS['meta']['pcre_u'];
 558         if ($textebrut)
 559                 $texte = preg_replace(array(",\n,",",\s(?=\s),msS".$u),array(" ",""),textebrut($texte));
 560         $texte = texte_backend($texte);
 561         $texte = str_replace(array("'",'"'),array('&#39;', '&#34;'), $texte);
 562
 563         return preg_replace(array("/&(amp;|#38;)/","/&(?![A-Za-z]{0,4}\w{2,3};|#[0-9]{2,5};)/"),array("&","&#38;") , $texte);
 564 }
 565
 566 // Vider les url nulles comme 'http://' ou 'mailto:'
 567 // et leur appliquer un htmlspecialchars() + gerer les &amp;
 568 // http://doc.spip.org/@vider_url
 569 function vider_url($url, $entites = true) {
 570         # un message pour abs_url
 571         $GLOBALS['mode_abs_url'] = 'url';
 572
 573         $url = trim($url);
 574         if (preg_match(",^(http:?/?/?|mailto:?)$,iS", $url))
 575                 return '';
 576
 577         if ($entites) $url = entites_html($url);
 578
 579         return $url;
 580 }
 581
 582 // Extraire une date de n'importe quel champ (a completer...)
 583 // http://doc.spip.org/@extraire_date
 584 function extraire_date($texte) {
 585         // format = 2001-08
 586         if (preg_match(",([1-2][0-9]{3})[^0-9]*(1[0-2]|0?[1-9]),",$texte,$regs))
 587                 return $regs[1]."-".sprintf("%02d", $regs[2])."-01";
 588 }
 589
 590 // Maquiller une adresse e-mail
 591 // http://doc.spip.org/@antispam
 592 function antispam($texte) {
 593         include_spip('inc/acces');
 594         $masque = creer_pass_aleatoire(3);
 595         return preg_replace("/@/", " $masque ", $texte);
 596 }
 597
 598 // http://doc.spip.org/@securiser_acces
 599 function securiser_acces($id_auteur, $cle, $dir, $op='', $args='')
 600 {
 601         include_spip('inc/acces');
 602         if ($op) $dir .= " $op $args";
 603         return verifier_low_sec($id_auteur, $cle, $dir);
 604 }
 605
 606 // sinon{texte, rien} : affiche "rien" si la chaine est vide,
 607 // affiche la chaine si non vide ;
 608 // attention c'est compile directement dans inc/references
 609 // http://doc.spip.org/@sinon
 610 function sinon ($texte, $sinon='') {
 611         if ($texte OR (!is_array($texte) AND strlen($texte)))
 612                 return $texte;
 613         else
 614                 return $sinon;
 615 }
 616
 617 // |choixsivide{vide,pasvide} affiche pasvide si la chaine n'est pas vide...
 618 // http://doc.spip.org/@choixsivide
 619 function choixsivide($a, $vide, $pasvide) {
 620         return $a ? $pasvide : $vide;
 621 }
 622
 623 // |choixsiegal{aquoi,oui,non} affiche oui si la chaine est egal a aquoi ...
 624 // http://doc.spip.org/@choixsiegal
 625 function choixsiegal($a1,$a2,$v,$f) {
 626         return ($a1 == $a2) ? $v : $f;
 627 }
 628
 629
 630 //
 631 // Date, heure, saisons
 632 //
 633
 634 // on normalise la date, si elle vient du contexte (public/parametrer.php), on force le jour
 635 // http://doc.spip.org/@normaliser_date
 636 function normaliser_date($date, $forcer_jour = false) {
 637         $date = vider_date($date);
 638         if ($date) {
 639                 if (preg_match("/^[0-9]{8,10}$/", $date))
 640                         $date = date("Y-m-d H:i:s", $date);
 641                 if (preg_match("#^([12][0-9]{3})([-/]00)?( [-0-9:]+)?$#", $date, $regs))
 642                         $date = $regs[1]."-00-00".$regs[3];
 643                 else if (preg_match("#^([12][0-9]{3}[-/][01]?[0-9])([-/]00)?( [-0-9:]+)?$#", $date, $regs))
 644                         $date = preg_replace("@/@","-",$regs[1])."-00".$regs[3];
 645                 else
 646                         $date = date("Y-m-d H:i:s", strtotime($date));
 647
 648                 if ($forcer_jour)
 649                         $date = str_replace('-00', '-01', $date);
 650         }
 651         return $date;
 652 }
 653
 654 // http://doc.spip.org/@vider_date
 655 function vider_date($letexte) {
 656         if (strncmp("0000-00-00", $letexte,10)==0) return '';
 657         if (strncmp("0001-01-01", $letexte,10)==0) return '';
 658         if (strncmp("1970-01-01", $letexte,10)==0) return '';   // eviter le bug GMT-1
 659         return $letexte;
 660 }
 661
 662 // http://doc.spip.org/@recup_heure
 663 function recup_heure($date){
 664
 665         static $d = array(0,0,0);
 666         if (!preg_match('#([0-9]{1,2}):([0-9]{1,2}):([0-9]{1,2})#', $date, $r))
 667                 return $d;
 668
 669         array_shift($r);
 670         return $r;
 671 }
 672
 673 // http://doc.spip.org/@heures
 674 function heures($numdate) {
 675         $date_array = recup_heure($numdate);
 676         if ($date_array)
 677                 list($heures, $minutes, $secondes) = $date_array;
 678         return $heures;
 679 }
 680
 681 // http://doc.spip.org/@minutes
 682 function minutes($numdate) {
 683         $date_array = recup_heure($numdate);
 684         if ($date_array)
 685                 list($heures, $minutes, $secondes) = $date_array;
 686         return $minutes;
 687 }
 688
 689 // http://doc.spip.org/@secondes
 690 function secondes($numdate) {
 691         $date_array = recup_heure($numdate);
 692         if ($date_array)
 693                 list($heures,$minutes,$secondes) = $date_array;
 694         return $secondes;
 695 }
 696
 697 // http://doc.spip.org/@heures_minutes
 698 function heures_minutes($numdate) {
 699         return _T('date_fmt_heures_minutes', array('h'=> heures($numdate), 'm'=> minutes($numdate)));
 700 }
 701
 702 // http://doc.spip.org/@recup_date
 703 function recup_date($numdate, $forcer_jour = true){
 704         if (!$numdate) return '';
 705         $heures = $minutes = $secondes = 0;
 706         if (preg_match('#([0-9]{1,2})/([0-9]{1,2})/([0-9]{4}|[0-9]{1,2})#', $numdate, $regs)) {
 707                 $jour = $regs[1];
 708                 $mois = $regs[2];
 709                 $annee = $regs[3];
 710                 if ($annee < 90){
 711                         $annee = 2000 + $annee;
 712                 } elseif ($annee<100) {
 713                         $annee = 1900 + $annee ;
 714                 }
 715                 list($heures, $minutes, $secondes) = recup_heure($numdate);
 716
 717         }
 718         elseif (preg_match('#([0-9]{4})-([0-9]{1,2})-([0-9]{1,2})#',$numdate, $regs)) {
 719                 $annee = $regs[1];
 720                 $mois = $regs[2];
 721                 $jour = $regs[3];
 722                 list($heures, $minutes, $secondes) = recup_heure($numdate);
 723         }
 724         elseif (preg_match('#([0-9]{4})-([0-9]{2})#', $numdate, $regs)){
 725                 $annee = $regs[1];
 726                 $mois = $regs[2];
 727                 $jour ='';
 728                 list($heures, $minutes, $secondes) = recup_heure($numdate);
 729         }
 730         elseif (preg_match('#^([0-9]{4})([0-9]{2})([0-9]{2})([0-9]{2})([0-9]{2})([0-9]{2})$#', $numdate, $regs)){
 731                 $annee = $regs[1];
 732                 $mois = $regs[2];
 733                 $jour = $regs[3];
 734                 $heures = $regs[4];
 735                 $minutes = $regs[5];
 736                 $secondes = $regs[6];
 737         } else $annee = $mois =  $jour ='';
 738         if ($annee > 4000) $annee -= 9000;
 739         if (substr($jour, 0, 1) == '0') $jour = substr($jour, 1);
 740
 741         if ($forcer_jour AND $jour == '0') $jour = '1';
 742         if ($forcer_jour AND $mois == '0') $mois = '1';
 743         if ($annee OR $mois OR $jour OR $heures OR $minutes OR $secondes)
 744                 return array($annee, $mois, $jour, $heures, $minutes, $secondes);
 745 }
 746
 747 // une date pour l'interface : utilise date_relative si le decalage
 748 // avec time() est de moins de douze heures, sinon la date complete
 749 // http://doc.spip.org/@date_interface
 750 function date_interface($date, $decalage_maxi = 43200/* 12*3600 */) {
 751         return sinon(
 752                 date_relative($date, $decalage_maxi),
 753                 affdate_heure($date)
 754         );
 755 }
 756
 757 // http://doc.spip.org/@date_relative
 758 function date_relative($date, $decalage_maxi=0,$ref_date=null) {
 759
 760         if (is_null($ref_date))
 761                 $ref_time = time();
 762         else
 763                 $ref_time = strtotime($ref_date);
 764
 765         if (!$date) return;
 766         $decal = date("U",$ref_time) - date("U", strtotime($date));
 767
 768         if ($decalage_maxi AND ($decal > $decalage_maxi OR $decal < 0))
 769                 return '';
 770
 771         if ($decal < 0) {
 772                 $il_y_a = "date_dans";
 773                 $decal = -1 * $decal;
 774         } else {
 775                 $il_y_a = "date_il_y_a";
 776         }
 777
 778         if ($decal > 3600 * 24 * 30 * 6)
 779                 return affdate_court($date);
 780
 781         if ($decal > 3600 * 24 * 30) {
 782                 $mois = floor ($decal / (3600 * 24 * 30));
 783                 if ($mois < 2)
 784                         $delai = "$mois "._T("date_un_mois");
 785                 else
 786                         $delai = "$mois "._T("date_mois");
 787         }
 788         else if ($decal > 3600 * 24 * 7) {
 789                 $semaines = floor ($decal / (3600 * 24 * 7));
 790                 if ($semaines < 2)
 791                         $delai = "$semaines "._T("date_une_semaine");
 792                 else
 793                         $delai = "$semaines "._T("date_semaines");
 794         }
 795         else if ($decal > 3600 * 24) {
 796                 $jours = floor ($decal / (3600 * 24));
 797                 if ($jours < 2)
 798                         return $il_y_a=="date_dans"?_T("date_demain"):_T("date_hier");
 799                 else
 800                         $delai = "$jours "._T("date_jours");
 801         }
 802         else if ($decal >= 3600) {
 803                 $heures = floor ($decal / 3600);
 804                 if ($heures < 2)
 805                         $delai = "$heures "._T("date_une_heure");
 806                 else
 807                         $delai = "$heures "._T("date_heures");
 808         }
 809         else if ($decal >= 60) {
 810                 $minutes = floor($decal / 60);
 811                 if ($minutes < 2)
 812                         $delai = "$minutes "._T("date_une_minute");
 813                 else
 814                         $delai = "$minutes "._T("date_minutes");
 815         } else {
 816                 $secondes = ceil($decal);
 817                 if ($secondes < 2)
 818                         $delai = "$secondes "._T("date_une_seconde");
 819                 else
 820                         $delai = "$secondes "._T("date_secondes");
 821         }
 822
 823         return _T($il_y_a, array("delai"=> $delai));
 824 }
 825
 826
 827 // http://doc.spip.org/@date_relativecourt
 828 function date_relativecourt($date, $decalage_maxi=0) {
 829
 830         if (!$date) return;
 831         $decal = date("U",strtotime(date('Y-m-d'))-strtotime(date('Y-m-d',strtotime($date))));
 832
 833         if ($decalage_maxi AND ($decal > $decalage_maxi OR $decal < 0))
 834                 return '';
 835
 836         if ($decal < -24*3600) {
 837                 $retour = date_relative($date, $decalage_maxi);
 838         }
 839         elseif ($decal < 0) {
 840                 $retour = _T("date_demain");
 841         }
 842         else if ($decal < (3600 * 24) ) {
 843                 $retour = _T("date_aujourdhui");
 844         }
 845         else if ($decal < (3600 * 24 *2) ) {
 846                 $retour = _T("date_hier");
 847         }
 848         else {
 849                 $retour = date_relative($date, $decalage_maxi);
 850         }
 851
 852
 853
 854         return $retour;
 855 }
 856
 857 // http://doc.spip.org/@affdate_base
 858 function affdate_base($numdate, $vue, $param = '') {
 859         global $spip_lang;
 860         $date_array = recup_date($numdate, false);
 861         if (!$date_array) return;
 862         list($annee, $mois, $jour, $heures, $minutes, $secondes)= $date_array;
 863
 864         // 1er, 21st, etc.
 865         $journum = $jour;
 866
 867         if ($jour == 0) {
 868                 $jour = '';
 869         } else {
 870                 $njour = intval($jour);
 871                 if ($jourth = _T('date_jnum'.$jour))
 872                         $jour = $jourth;
 873         }
 874
 875         $mois = intval($mois);
 876         if ($mois > 0 AND $mois < 13) {
 877                 $nommois = _T('date_mois_'.$mois);
 878                 if ($jour)
 879                         $jourmois = _T('date_de_mois_'.$mois, array('j'=>$jour, 'nommois'=>$nommois));
 880                 else
 881                         $jourmois = $nommois;
 882         } else $nommois = '';
 883
 884         if ($annee < 0) {
 885                 $annee = -$annee." "._T('date_avant_jc');
 886                 $avjc = true;
 887         }
 888         else $avjc = false;
 889
 890         switch ($vue) {
 891         case 'saison':
 892                 if ($mois > 0){
 893                         $saison = 1;
 894                         if (($mois == 3 AND $jour >= 21) OR $mois > 3) $saison = 2;
 895                         if (($mois == 6 AND $jour >= 21) OR $mois > 6) $saison = 3;
 896                         if (($mois == 9 AND $jour >= 21) OR $mois > 9) $saison = 4;
 897                         if (($mois == 12 AND $jour >= 21) OR $mois > 12) $saison = 1;
 898                 }
 899                 return _T('date_saison_'.$saison);
 900
 901         case 'court':
 902                 if ($avjc) return $annee;
 903                 $a = date('Y');
 904                 if ($annee < ($a - 100) OR $annee > ($a + 100)) return $annee;
 905                 if ($annee != $a) return _T('date_fmt_mois_annee', array ('mois'=>$mois, 'nommois'=>ucfirst($nommois), 'annee'=>$annee));
 906                 return _T('date_fmt_jour_mois', array ('jourmois'=>$jourmois, 'jour'=>$jour, 'mois'=>$mois, 'nommois'=>$nommois, 'annee'=>$annee));
 907
 908         case 'jourcourt':
 909                 if ($avjc) return $annee;
 910                 $a = date('Y');
 911                 if ($annee < ($a - 100) OR $annee > ($a + 100)) return $annee;
 912                 if ($annee != $a) return _T('date_fmt_jour_mois_annee', array ('jourmois'=>$jourmois, 'jour'=>$jour, 'mois'=>$mois, 'nommois'=>$nommois, 'annee'=>$annee));
 913                 return _T('date_fmt_jour_mois', array ('jourmois'=>$jourmois, 'jour'=>$jour, 'mois'=>$mois, 'nommois'=>$nommois, 'annee'=>$annee));
 914
 915         case 'entier':
 916                 if ($avjc) return $annee;
 917                 if ($jour)
 918                         return _T('date_fmt_jour_mois_annee', array ('jourmois'=>$jourmois, 'jour'=>$jour, 'mois'=>$mois, 'nommois'=>$nommois, 'annee'=>$annee));
 919                 elseif ($mois)
 920                         return trim(_T('date_fmt_mois_annee', array ('mois'=>$mois, 'nommois'=>$nommois, 'annee'=>$annee)));
 921                 else
 922                         return $annee;
 923
 924         case 'nom_mois':
 925                 return $nommois;
 926
 927         case 'mois':
 928                 return sprintf("%02s",$mois);
 929
 930         case 'jour':
 931                 return $jour;
 932
 933         case 'journum':
 934                 return $journum;
 935
 936         case 'nom_jour':
 937                 if (!$mois OR !$njour)
 938                         return '';
 939                 $nom = mktime(1,1,1,$mois,$njour,$annee);
 940                 $nom = 1+date('w',$nom);
 941                 $param = $param ? '_'.$param : '';
 942                 return _T('date_jour_'.$nom.$param);
 943
 944         case 'mois_annee':
 945                 if ($avjc) return $annee;
 946                 return trim(_T('date_fmt_mois_annee', array('mois'=>$mois, 'nommois'=>$nommois, 'annee'=>$annee)));
 947
 948         case 'annee':
 949                 return $annee;
 950
 951         // Cas d'une vue non definie : retomber sur le format
 952         // de date propose par http://www.php.net/date
 953         default:
 954                 return date($vue, strtotime($numdate));
 955         }
 956 }
 957
 958 // http://doc.spip.org/@nom_jour
 959 function nom_jour($numdate, $forme = '') {
 960         if(!($forme == 'abbr' OR $forme == 'initiale')) $forme = '';
 961         return affdate_base($numdate, 'nom_jour', $forme);
 962 }
 963
 964 // http://doc.spip.org/@jour
 965 function jour($numdate) {
 966         return affdate_base($numdate, 'jour');
 967 }
 968
 969 // http://doc.spip.org/@journum
 970 function journum($numdate) {
 971         return affdate_base($numdate, 'journum');
 972 }
 973
 974 // http://doc.spip.org/@mois
 975 function mois($numdate) {
 976         return affdate_base($numdate, 'mois');
 977 }
 978
 979 // http://doc.spip.org/@nom_mois
 980 function nom_mois($numdate) {
 981         return affdate_base($numdate, 'nom_mois');
 982 }
 983
 984 // http://doc.spip.org/@annee
 985 function annee($numdate) {
 986         return affdate_base($numdate, 'annee');
 987 }
 988
 989 // http://doc.spip.org/@saison
 990 function saison($numdate) {
 991         return affdate_base($numdate, 'saison');
 992 }
 993
 994 // http://doc.spip.org/@affdate
 995 function affdate($numdate, $format='entier') {
 996         return affdate_base($numdate, $format);
 997 }
 998
 999 // http://doc.spip.org/@affdate_court
1000 function affdate_court($numdate) {
1001         return affdate_base($numdate, 'court');
1002 }
1003
1004 // http://doc.spip.org/@affdate_jourcourt
1005 function affdate_jourcourt($numdate) {
1006         return affdate_base($numdate, 'jourcourt');
1007 }
1008
1009 // http://doc.spip.org/@affdate_mois_annee
1010 function affdate_mois_annee($numdate) {
1011         return affdate_base($numdate, 'mois_annee');
1012 }
1013
1014 // http://doc.spip.org/@affdate_heure
1015 function affdate_heure($numdate) {
1016         $date_array = recup_date($numdate);
1017         if (!$date_array) return;
1018         list($annee, $mois, $jour, $heures, $minutes, $sec)= $date_array;
1019         return _T('date_fmt_jour_heure', array('jour' => affdate($numdate), 'heure' =>  _T('date_fmt_heures_minutes', array('h'=> $heures, 'm'=> $minutes))));
1020 }
1021
1022
1023 //
1024 // Alignements en HTML (Old-style, preferer CSS)
1025 //
1026
1027 // Cette fonction cree le paragraphe s'il n'existe pas (texte sur un seul para)
1028 // http://doc.spip.org/@aligner
1029 function aligner($letexte, $justif='') {
1030         $letexte = trim($letexte);
1031         if (!strlen($letexte)) return '';
1032
1033         // Paragrapher proprement
1034         $letexte = paragrapher($letexte, true);
1035
1036         // Inserer les alignements
1037         if ($justif)
1038                 $letexte = str_replace(
1039                 '<p class="spip">', '<p class="spip" align="'.$justif.'">',
1040                 $letexte);
1041
1042         return $letexte;
1043 }
1044
1045 // http://doc.spip.org/@justifier
1046 function justifier($letexte) {
1047         return aligner($letexte,'justify');
1048 }
1049
1050 // http://doc.spip.org/@aligner_droite
1051 function aligner_droite($letexte) {
1052         return aligner($letexte,'right');
1053 }
1054
1055 // http://doc.spip.org/@aligner_gauche
1056 function aligner_gauche($letexte) {
1057         return aligner($letexte,'left');
1058 }
1059
1060 // http://doc.spip.org/@centrer
1061 function centrer($letexte) {
1062         return aligner($letexte,'center');
1063 }
1064
1065 // http://doc.spip.org/@style_align
1066 function style_align($bof) {
1067         global $spip_lang_left;
1068         return "text-align: $spip_lang_left";
1069 }
1070
1071 //
1072 // Export iCal
1073 //
1074
1075 // http://doc.spip.org/@filtrer_ical
1076 function filtrer_ical($texte) {
1077         #include_spip('inc/charsets');
1078         $texte = html2unicode($texte);
1079         $texte = unicode2charset(charset2unicode($texte, $GLOBALS['meta']['charset'], 1), 'utf-8');
1080         $texte = preg_replace("/\n/", " ", $texte);
1081         $texte = preg_replace("/,/", "\,", $texte);
1082
1083         return $texte;
1084 }
1085
1086 // http://doc.spip.org/@date_ical
1087 function date_ical($date, $addminutes = 0) {
1088         list($heures, $minutes, $secondes) = recup_heure($date);
1089         list($annee, $mois, $jour) = recup_date($date);
1090         return date("Ymd\THis",
1091                     mktime($heures, $minutes+$addminutes,$secondes,$mois,$jour,$annee));
1092 }
1093
1094 // date_iso retourne la date au format "RFC 3339" / "ISO 8601"
1095 // voir http://www.php.net/manual/fr/ref.datetime.php#datetime.constants
1096 // http://doc.spip.org/@date_iso
1097 function date_iso($date_heure) {
1098         list($annee, $mois, $jour) = recup_date($date_heure);
1099         list($heures, $minutes, $secondes) = recup_heure($date_heure);
1100         $time = @mktime($heures, $minutes, $secondes, $mois, $jour, $annee);
1101         return gmdate('Y-m-d\TH:i:s\Z', $time);
1102 }
1103
1104 // date_822 retourne la date au format "RFC 822"
1105 // utilise pour <pubdate> dans certains feeds RSS
1106 // http://doc.spip.org/@date_822
1107 function date_822($date_heure) {
1108         list($annee, $mois, $jour) = recup_date($date_heure);
1109         list($heures, $minutes, $secondes) = recup_heure($date_heure);
1110         $time = mktime($heures, $minutes, $secondes, $mois, $jour, $annee);
1111         return date('r', $time);
1112 }
1113
1114 // http://doc.spip.org/@date_anneemoisjour
1115 function date_anneemoisjour($d)  {
1116         if (!$d) $d = date("Y-m-d");
1117         return  substr($d, 0, 4) . substr($d, 5, 2) .substr($d, 8, 2);
1118 }
1119
1120 // http://doc.spip.org/@date_anneemois
1121 function date_anneemois($d)  {
1122         if (!$d) $d = date("Y-m-d");
1123         return  substr($d, 0, 4) . substr($d, 5, 2);
1124 }
1125
1126 // http://doc.spip.org/@date_debut_semaine
1127 function date_debut_semaine($annee, $mois, $jour) {
1128   $w_day = date("w", mktime(0,0,0,$mois, $jour, $annee));
1129   if ($w_day == 0) $w_day = 7; // Gaffe: le dimanche est zero
1130   $debut = $jour-$w_day+1;
1131   return date("Ymd", mktime(0,0,0,$mois,$debut,$annee));
1132 }
1133
1134 // http://doc.spip.org/@date_fin_semaine
1135 function date_fin_semaine($annee, $mois, $jour) {
1136   $w_day = date("w", mktime(0,0,0,$mois, $jour, $annee));
1137   if ($w_day == 0) $w_day = 7; // Gaffe: le dimanche est zero
1138   $debut = $jour-$w_day+1;
1139   return date("Ymd", mktime(0,0,0,$mois,$debut+6,$annee));
1140 }
1141
1142 // http://doc.spip.org/@agenda_connu
1143 function agenda_connu($type)
1144 {
1145   return in_array($type, array('jour','mois','semaine','periode', 'trimestre')) ? ' ' : '';
1146 }
1147
1148
1149 // Cette fonction memorise dans un tableau indexe par son 5e arg
1150 // un evenement decrit par les 4 autres (date, descriptif, titre, URL).
1151 // Appellee avec une date nulle, elle renvoie le tableau construit.
1152 // l'indexation par le 5e arg autorise plusieurs calendriers dans une page
1153
1154 // http://doc.spip.org/@agenda_memo
1155 function agenda_memo($date=0 , $descriptif='', $titre='', $url='', $cal='')
1156 {
1157   static $agenda = array();
1158   if (!$date) return $agenda;
1159   $idate = date_ical($date);
1160   $cal = trim($cal); // func_get_args (filtre alterner) rajoute \n !!!!
1161   $agenda[$cal][(date_anneemoisjour($date))][] =  array(
1162                         'CATEGORIES' => $cal,
1163                         'DTSTART' => $idate,
1164                         'DTEND' => $idate,
1165                         'DESCRIPTION' => texte_script($descriptif),
1166                         'SUMMARY' => texte_script($titre),
1167                         'URL' => $url);
1168   // toujours retourner vide pour qu'il ne se passe rien
1169   return "";
1170 }
1171
1172 // Cette fonction recoit:
1173 // - un nombre d'evenements,
1174 // - une chaine a afficher si ce nombre est nul,
1175 // - un type de calendrier
1176 // -- et une suite de noms N.
1177 // Elle demande a la fonction precedente son tableau
1178 // et affiche selon le type les elements indexes par N dans ce tableau.
1179 // Si le suite de noms est vide, tout le tableau est pris
1180 // Ces noms N sont aussi des classes CSS utilisees par http_calendrier_init
1181 // Cette fonction recupere aussi par _request les parametres
1182 // jour, mois, annee, echelle, partie_cal (a ameliorer)
1183
1184 // http://doc.spip.org/@agenda_affiche
1185 function agenda_affiche($i)
1186 {
1187         $args = func_get_args();
1188         // date (ou nombre d'evenements qu'on pourrait alors afficher)
1189         $nb = array_shift($args);
1190         $evt = array_shift($args);
1191         $type = array_shift($args);
1192         if ($nb) {
1193                 $agenda = agenda_memo(0);
1194                 $evt = array();
1195                 foreach (($args ? $args : array_keys($agenda)) as $k) {
1196                         if (is_array($agenda[$k]))
1197                                 foreach($agenda[$k] as $d => $v) {
1198                                         $evt[$d] = $evt[$d] ? (array_merge($evt[$d], $v)) : $v;
1199                                 }
1200                 }
1201         }
1202         return agenda_periode($type, $nb, $evt);
1203 }
1204
1205 function agenda_periode($type, $nb, $avec, $sans='')
1206 {
1207         include_spip('inc/agenda');
1208         $start = agenda_controle();
1209         if ($start<0) $start = time();
1210         $mindate = date("Ymd", $start);
1211
1212         if ($type != 'periode')
1213                 $evt = array($sans, $avec);
1214         else {
1215                 $min = substr($mindate,6,2);
1216                 $max = !(is_array($avec) AND $avec) ? time() : strtotime(max(array_keys($avec)));
1217                 $max = $min + (($max - $start) / (3600 * 24));
1218                 if ($max < 31) $max = 0;
1219                 $evt = array($sans, $avec, $min, $max);
1220                 $type = 'mois';
1221         }
1222         $ancre = _request('ancre');
1223         $s =  self('&') . (preg_match('/^[\w-]+$/', $ancre) ? "#$ancre" : '');
1224         return http_calendrier_init($start, $type,  _request('echelle'), _request('partie_cal'), $s, $evt);
1225 }
1226
1227
1228 // Controle la coherence des 3 nombres d'une date et retourne le temps Unix,
1229 // sinon retourne un code d'erreur, toujours negatif
1230 function agenda_controle($date='date', $jour='jour', $mois='mois', $annee='annee')
1231 {
1232         $jour = _request($jour);
1233         $mois = _request($mois);
1234         $annee = _request($annee);
1235
1236         if (!($jour||$mois||$anne)) {
1237                 if ($date = recup_date(_request($date))) {
1238                         list($annee, $mois, $jour ) = $date;
1239                 } else  return -1;
1240         }
1241         if (!$d = mktime(0,0,0, $mois, $jour, $annee)) return -2;
1242         if ($jour != date("d", $d)) return -3;
1243         if ($mois != date("m", $d)) return -4;
1244         if ($annee != date("Y", $d)) return -5;
1245         return $d;
1246 }
1247
1248 //
1249 // Recuperation de donnees dans le champ extra
1250 // Ce filtre n'a de sens qu'avec la balise #EXTRA
1251 //
1252 // http://doc.spip.org/@extra
1253 function extra($letexte, $champ) {
1254         $champs = unserialize($letexte);
1255         return $champs[$champ];
1256 }
1257
1258 // postautobr : transforme les sauts de ligne en _
1259 // http://doc.spip.org/@post_autobr
1260 function post_autobr($texte, $delim="\n_ ") {
1261         $texte = str_replace("\r\n", "\r", $texte);
1262         $texte = str_replace("\r", "\n", $texte);
1263
1264         if (preg_match(",\n+$,", $texte, $fin))
1265                 $texte = substr($texte, 0, -strlen($fin = $fin[0]));
1266         else
1267                 $fin = '';
1268
1269         $texte = echappe_html($texte, '', true);
1270
1271
1272         $debut = '';
1273         $suite = $texte;
1274         while ($t = strpos('-'.$suite, "\n", 1)) {
1275                 $debut .= substr($suite, 0, $t-1);
1276                 $suite = substr($suite, $t);
1277                 $car = substr($suite, 0, 1);
1278                 if (($car<>'-') AND ($car<>'_') AND ($car<>"\n") AND ($car<>"|") AND ($car<>"}")
1279                 AND !preg_match(',^\s*(\n|</?(quote|div)|$),S',($suite))
1280                 AND !preg_match(',</?(quote|div)> *$,iS', $debut)) {
1281                         $debut .= $delim;
1282                 } else
1283                         $debut .= "\n";
1284                 if (preg_match(",^\n+,", $suite, $regs)) {
1285                         $debut.=$regs[0];
1286                         $suite = substr($suite, strlen($regs[0]));
1287                 }
1288         }
1289         $texte = $debut.$suite;
1290
1291         $texte = echappe_retour($texte);
1292         return $texte.$fin;
1293 }
1294
1295
1296 //
1297 // Gestion des blocs multilingues
1298 //
1299
1300 define('_EXTRAIRE_MULTI', "@<multi>(.*?)</multi>@sS");
1301 // Extraire et transformer les blocs multi ; on indique la langue courante
1302 // pour ne pas mettre de span@lang=fr si on est deja en fr
1303 // http://doc.spip.org/@extraire_multi
1304 function extraire_multi($letexte, $lang=null, $echappe_span=false) {
1305         if (strpos($letexte, '<multi>') === false) return $letexte; // perf
1306         if (preg_match_all(_EXTRAIRE_MULTI, $letexte, $regs, PREG_SET_ORDER)) {
1307                 if (!$lang) $lang = $GLOBALS['spip_lang'];
1308
1309                 foreach ($regs as $reg) {
1310                         // chercher la version de la langue courante
1311                         $trads = extraire_trads($reg[1]);
1312                         if ($l = approcher_langue($trads, $lang)) {
1313                                 $trad = $trads[$l];
1314                         } else {
1315                                 include_spip('inc/texte');
1316                                 // langue absente, prendre la premiere dispo
1317                                 // mais typographier le texte selon les regles de celle-ci
1318                                 // Attention aux blocs multi sur plusieurs lignes
1319                                 $l = key($trads);
1320                                 $trad = $trads[$l];
1321                                 $typographie = charger_fonction(lang_typo($l), 'typographie');
1322                                 $trad = traiter_retours_chariots($typographie($trad));
1323                                 $trad = explode("\n", $trad);
1324                                 foreach($trad as $i => $ligne) {
1325                                         if (strlen($ligne)) {
1326                                                 $ligne = code_echappement($ligne, 'multi');
1327                                                 $ligne = str_replace("'", '"', inserer_attribut($ligne, 'lang', $l));
1328                                                 if (lang_dir($l) !== lang_dir($lang))
1329                                                         $ligne = str_replace("'", '"', inserer_attribut($ligne, 'dir', lang_dir($l)));
1330                                                 $trad[$i] = $ligne;
1331                                         }
1332                                 }
1333                                 $trad = join("\n", $trad);
1334                                 if (!$echappe_span)
1335                                         $trad = echappe_retour($trad, 'multi');
1336                         }
1337                         $letexte = str_replace($reg[0], $trad, $letexte);
1338                 }
1339         }
1340
1341         return $letexte;
1342 }
1343
1344
1345
1346 //
1347 // Selection dans un tableau dont les index sont des noms de langues
1348 // de la valeur associee a la langue en cours
1349 // si absente, retourne le premier
1350 // remarque : on pourrait aussi appeler un service de traduction externe
1351 // ou permettre de choisir une langue "plus proche",
1352 // par exemple le francais pour l'espagnol, l'anglais pour l'allemand, etc.
1353
1354
1355 function multi_trad ($trads, $lang='') {
1356         $k = multi_trads($trads, $lang);
1357         return $k ? $trads[$k] : array_shift($trads);
1358 }
1359
1360 // idem, mais retourne l'index
1361
1362 function multi_trads ($trads, $lang='') {
1363
1364                 if (!$lang) $lang = $GLOBALS['spip_lang'];
1365
1366         if (isset($trads[$lang])) {
1367                 return $lang;
1368
1369         }       // cas des langues xx_yy
1370         else if (preg_match(',^([a-z]+)_,', $lang, $regs) AND isset($trads[$regs[1]])) {
1371                 return $regs[1];
1372                                         }
1373         else  return '';
1374                                 }
1375
1376 // convertit le contenu d'une balise multi en un tableau
1377 // http://doc.spip.org/@extraire_trad
1378 function extraire_trads($bloc) {
1379         $lang = '';
1380 // ce reg fait planter l'analyse multi s'il y a de l'{italique} dans le champ
1381 //      while (preg_match("/^(.*?)[{\[]([a-z_]+)[}\]]/siS", $bloc, $regs)) {
1382         while (preg_match("/^(.*?)[\[]([a-z_]+)[\]]/siS", $bloc, $regs)) {
1383                 $texte = trim($regs[1]);
1384                 if ($texte OR $lang)
1385                         $trads[$lang] = $texte;
1386                 $bloc = substr($bloc, strlen($regs[0]));
1387                 $lang = $regs[2];
1388                         }
1389         $trads[$lang] = $bloc;
1390
1391         return $trads;
1392                 }
1393
1394 //
1395 // Ce filtre retourne la donnee si c'est la premiere fois qu'il la voit ;
1396 // possibilite de gerer differentes "familles" de donnees |unique{famille}
1397 # |unique{famille,1} affiche le nombre d'elements affiches (preferer toutefois #TOTAL_UNIQUE)
1398 # ameliorations possibles :
1399 # 1) si la donnee est grosse, mettre son md5 comme cle
1400 # 2) purger $mem quand on change de squelette (sinon bug inclusions)
1401 //
1402 // http://www.spip.net/@unique
1403 // http://doc.spip.org/@unique
1404 function unique($donnee, $famille='', $cpt = false) {
1405         static $mem;
1406         // permettre de vider la pile et de la restaurer
1407         // pour le calcul de introduction...
1408         if ($famille=='_spip_raz_'){
1409                 $tmp = $mem;
1410                 $mem = array();
1411                 return $tmp;
1412         } elseif ($famille=='_spip_set_'){
1413                 $mem = $donnee;
1414                 return;
1415         }
1416
1417         if ($cpt)
1418                 return count($mem[$famille]);
1419         if (!($mem[$famille][$donnee]++))
1420                 return $donnee;
1421 }
1422
1423 //
1424 // Filtre |alterner
1425 //
1426 // Exemple [(#COMPTEUR_BOUCLE|alterner{'bleu','vert','rouge'})]
1427 //
1428 // http://doc.spip.org/@alterner
1429 function alterner($i) {
1430         // recuperer les arguments (attention fonctions un peu space)
1431         $num = func_num_args();
1432         $args = func_get_args();
1433
1434         if($num == 2 && is_array($args[1])) {
1435     $args = $args[1];
1436     array_unshift($args,'');
1437     $num = count($args);
1438   }
1439
1440         // renvoyer le i-ieme argument, modulo le nombre d'arguments
1441         return $args[(intval($i)-1)%($num-1)+1];
1442 }
1443
1444 // recuperer un attribut d'une balise html
1445 // ($complet demande de retourner $r)
1446 // la regexp est mortelle : cf. tests/filtres/extraire_attribut.php
1447 // Si on a passe un tableau de balises, renvoyer un tableau de resultats
1448 // (dans ce cas l'option $complet n'est pas disponible)
1449 // http://doc.spip.org/@extraire_attribut
1450 function extraire_attribut($balise, $attribut, $complet = false) {
1451         if (is_array($balise)) {
1452                 array_walk($balise,
1453                         create_function('&$a,$key,$t',
1454                                 '$a = extraire_attribut($a,$t);'
1455                         ),
1456                         $attribut);
1457                 return $balise;
1458         }
1459         if (preg_match(
1460         ',(^.*?<(?:(?>\s*)(?>[\w:.-]+)(?>(?:=(?:"[^"]*"|\'[^\']*\'|[^\'"]\S*))?))*?)(\s+'
1461         .$attribut
1462         .'(?:=\s*("[^"]*"|\'[^\']*\'|[^\'"]\S*))?)()([^>]*>.*),isS',
1463
1464         $balise, $r)) {
1465                 if ($r[3][0] == '"' || $r[3][0] == "'") {
1466                         $r[4] = substr($r[3], 1, -1);
1467                         $r[3] = $r[3][0];
1468                 } elseif ($r[3]!=='') {
1469                         $r[4] = $r[3];
1470                         $r[3] = '';
1471                 } else {
1472                         $r[4] = trim($r[2]);
1473                 }
1474                 $att = filtrer_entites(str_replace("&#39;", "'", $r[4]));
1475         }
1476         else
1477                 $att = NULL;
1478
1479         if ($complet)
1480                 return array($att, $r);
1481         else
1482                 return $att;
1483 }
1484
1485 // modifier (ou inserer) un attribut html dans une balise
1486 // http://doc.spip.org/@inserer_attribut
1487 function inserer_attribut($balise, $attribut, $val, $proteger=true, $vider=false) {
1488         // preparer l'attribut
1489         // supprimer les &nbsp; etc mais pas les balises html
1490         // qui ont un sens dans un attribut value d'un input
1491         if ($proteger) $val = attribut_html($val,false);
1492
1493         // echapper les ' pour eviter tout bug
1494         $val = str_replace("'", "&#39;", $val);
1495         if ($vider AND strlen($val)==0)
1496                 $insert = '';
1497         else
1498                 $insert = " $attribut='$val'";
1499
1500         list($old, $r) = extraire_attribut($balise, $attribut, true);
1501
1502         if ($old !== NULL) {
1503                 // Remplacer l'ancien attribut du meme nom
1504                 $balise = $r[1].$insert.$r[5];
1505         }
1506         else {
1507                 // preferer une balise " />" (comme <img />)
1508                 if (preg_match(',/>,', $balise))
1509                         $balise = preg_replace(",\s?/>,S", $insert." />", $balise, 1);
1510                 // sinon une balise <a ...> ... </a>
1511                 else
1512                         $balise = preg_replace(",\s?>,S", $insert.">", $balise, 1);
1513         }
1514
1515         return $balise;
1516 }
1517
1518 // http://doc.spip.org/@vider_attribut
1519 function vider_attribut ($balise, $attribut) {
1520         return inserer_attribut($balise, $attribut, '', false, true);
1521 }
1522
1523
1524 // Un filtre pour determiner le nom du mode des librement inscrits,
1525 // a l'aide de la liste globale des statuts (tableau mode => nom du mode)
1526 // Utile pour le formulaire d'inscription.
1527 // Si un mode est fourni, verifier que la configuration l'accepte.
1528 // Si mode inconnu laisser faire, c'est une extension non std
1529 // mais verifier que la syntaxe est compatible avec SQL
1530
1531 // http://doc.spip.org/@tester_config
1532 function tester_config($id, $mode='') {
1533
1534         $s = array_search($mode, $GLOBALS['liste_des_statuts']);
1535         switch ($s) {
1536
1537         case 'info_redacteurs' :
1538           return (($GLOBALS['meta']['accepter_inscriptions'] == 'oui') ? $mode : '');
1539
1540         case 'info_visiteurs' :
1541           return (($GLOBALS['meta']['accepter_visiteurs'] == 'oui' OR $GLOBALS['meta']['forums_publics'] == 'abo') ? $mode : '');
1542
1543         default:
1544           if ($mode AND $mode == addslashes($mode))
1545             return $mode;
1546           if ($GLOBALS['meta']["accepter_inscriptions"] == "oui")
1547             return $GLOBALS['liste_des_statuts']['info_redacteurs'];
1548           if ($GLOBALS['meta']["accepter_visiteurs"] == "oui")
1549             return $GLOBALS['liste_des_statuts']['info_visiteurs'];
1550           return '';
1551         }
1552 }
1553
1554 //
1555 // Un filtre qui, etant donne un #PARAMETRES_FORUM, retourne un URL de suivi rss
1556 // dudit forum
1557 // Attention applique a un #PARAMETRES_FORUM complexe (id_article=x&id_forum=y)
1558 // ca retourne un url de suivi du thread y (que le thread existe ou non)
1559 // http://doc.spip.org/@url_rss_forum
1560 function url_rss_forum($param) {
1561         if (!preg_match(',.*(id_(\w*?))=([0-9]+),S', $param, $regs)) return '';
1562         list(,$k,$t,$v) = $regs;
1563         if ($t == 'forum') $k = 'id_' . ($t = 'thread');
1564         return generer_url_public("rss_forum_$t", array($k => $v));
1565 }
1566
1567 //
1568 // Un filtre applique a #PARAMETRES_FORUM, qui donne l'adresse de la page
1569 // de reponse
1570 //
1571 // http://doc.spip.org/@url_reponse_forum
1572 function url_reponse_forum($parametres) {
1573         if (!$parametres) return '';
1574         return generer_url_public('forum', $parametres);
1575 }
1576
1577 //
1578 // Quelques fonctions de calcul arithmetique
1579 //
1580 // http://doc.spip.org/@plus
1581 function plus($a,$b) {
1582         return $a+$b;
1583 }
1584 // http://doc.spip.org/@moins
1585 function moins($a,$b) {
1586         return $a-$b;
1587 }
1588 // http://doc.spip.org/@mult
1589 function mult($a,$b) {
1590         return $a*$b;
1591 }
1592 // http://doc.spip.org/@div
1593 function div($a,$b) {
1594         return $b?$a/$b:0;
1595 }
1596 // http://doc.spip.org/@modulo
1597 function modulo($nb, $mod, $add=0) {
1598         return ($mod?$nb%$mod:0)+$add;
1599 }
1600
1601
1602 // Verifier la conformite d'une ou plusieurs adresses email
1603 //  retourne false ou la  normalisation de la derniere adresse donnee
1604 // http://doc.spip.org/@email_valide
1605 function email_valide($adresses) {
1606         // eviter d'injecter n'importe quoi dans preg_match
1607         if (!is_string($adresses))
1608                 return false;
1609
1610         // Si c'est un spammeur autant arreter tout de suite
1611         if (preg_match(",[\n\r].*(MIME|multipart|Content-),i", $adresses)) {
1612                 spip_log("Tentative d'injection de mail : $adresses");
1613                 return false;
1614         }
1615
1616         foreach (explode(',', $adresses) as $v) {
1617                 // nettoyer certains formats
1618                 // "Marie Toto <Marie@toto.com>"
1619                 $adresse = trim(preg_replace(",^[^<>\"]*<([^<>\"]+)>$,i", "\\1", $v));
1620                 // RFC 822
1621                 if (!preg_match('#^[^()<>@,;:\\"/[:space:]]+(@([-_0-9a-z]+\.)*[-_0-9a-z]+)$#i', $adresse))
1622                         return false;
1623         }
1624         return $adresse;
1625 }
1626
1627 // http://doc.spip.org/@afficher_enclosures
1628 function afficher_enclosures($tags) {
1629         $s = array();
1630         foreach (extraire_balises($tags, 'a') as $tag) {
1631                 if (extraire_attribut($tag, 'rel') == 'enclosure'
1632                 AND $t = extraire_attribut($tag, 'href')) {
1633                         $s[] = preg_replace(',>[^<]+</a>,S',
1634                                 '>'
1635                                 .http_img_pack('attachment.gif', $t,
1636                                         'height="15" width="15" title="'.attribut_html($t).'"')
1637                                 .'</a>', $tag);
1638                 }
1639         }
1640         return join('&nbsp;', $s);
1641 }
1642 // http://doc.spip.org/@afficher_tags
1643 function afficher_tags($tags, $rels='tag,directory') {
1644         $s = array();
1645         foreach (extraire_balises($tags, 'a') as $tag) {
1646                 $rel = extraire_attribut($tag, 'rel');
1647                 if (strstr(",$rels,", ",$rel,"))
1648                         $s[] = $tag;
1649         }
1650         return join(', ', $s);
1651 }
1652
1653 // Passe un <enclosure url="fichier" length="5588242" type="audio/mpeg"/>
1654 // au format microformat <a rel="enclosure" href="fichier" ...>fichier</a>
1655 // attention length="zz" devient title="zz", pour rester conforme
1656 // http://doc.spip.org/@enclosure2microformat
1657 function enclosure2microformat($e) {
1658         if (!$url = filtrer_entites(extraire_attribut($e, 'url')))
1659                 $url = filtrer_entites(extraire_attribut($e, 'href'));
1660         $type = extraire_attribut($e, 'type');
1661         $length = extraire_attribut($e, 'length');
1662         $fichier = basename($url);
1663         return '<a rel="enclosure"'
1664                 . ($url? ' href="'.htmlspecialchars($url).'"' : '')
1665                 . ($type? ' type="'.htmlspecialchars($type).'"' : '')
1666                 . ($length? ' title="'.htmlspecialchars($length).'"' : '')
1667                 . '>'.$fichier.'</a>';
1668 }
1669 // La fonction inverse
1670 // http://doc.spip.org/@microformat2enclosure
1671 function microformat2enclosure($tags) {
1672         $enclosures = array();
1673         foreach (extraire_balises($tags, 'a') as $e)
1674         if (extraire_attribut($e, 'rel') == 'enclosure') {
1675                 $url = filtrer_entites(extraire_attribut($e, 'href'));
1676                 $type = extraire_attribut($e, 'type');
1677                 if (!$length = intval(extraire_attribut($e, 'title')))
1678                         $length = intval(extraire_attribut($e, 'length')); # vieux data
1679                 $fichier = basename($url);
1680                 $enclosures[] = '<enclosure'
1681                         . ($url? ' url="'.htmlspecialchars($url).'"' : '')
1682                         . ($type? ' type="'.htmlspecialchars($type).'"' : '')
1683                         . ($length? ' length="'.$length.'"' : '')
1684                         . ' />';
1685         }
1686         return join("\n", $enclosures);
1687 }
1688 // Creer les elements ATOM <dc:subject> a partir des tags
1689 // http://doc.spip.org/@tags2dcsubject
1690 function tags2dcsubject($tags) {
1691         $subjects = '';
1692         foreach (extraire_balises($tags, 'a') as $e) {
1693                 if (extraire_attribut($e, rel) == 'tag') {
1694                         $subjects .= '<dc:subject>'
1695                                 . texte_backend(textebrut($e))
1696                                 . '</dc:subject>'."\n";
1697                 }
1698         }
1699         return $subjects;
1700 }
1701 // fabrique un bouton de type $t de Name $n, de Value $v et autres attributs $a
1702 // http://doc.spip.org/@boutonne
1703 function boutonne($t, $n, $v, $a='') {
1704         return "\n<input type='$t'"
1705         . (!$n ? '' : " name='$n'")
1706         . " value=\"$v\" $a />";
1707 }
1708
1709 // retourne la premiere balise du type demande
1710 // ex: [(#DESCRIPTIF|extraire_balise{img})]
1711 // Si on a passe un tableau de textes, renvoyer un tableau de resultats
1712 // http://doc.spip.org/@extraire_balise
1713 function extraire_balise($texte, $tag='a') {
1714         if (is_array($texte)) {
1715                 array_walk($texte,
1716                         create_function('&$a,$key,$t', '$a = extraire_balise($a,$t);'),
1717                         $tag);
1718                 return $texte;
1719         }
1720
1721         if (preg_match(
1722         ",<$tag\b[^>]*(/>|>.*</$tag\b[^>]*>|>),UimsS",
1723         $texte, $regs))
1724                 return $regs[0];
1725 }
1726
1727 // extraire toutes les balises du type demande, sous forme de tableau
1728 // Si on a passe un tableau de textes, renvoyer un tableau de resultats
1729 // http://doc.spip.org/@extraire_balises
1730 function extraire_balises($texte, $tag='a') {
1731         if (is_array($texte)) {
1732                 array_walk($texte,
1733                         create_function('&$a,$key,$t', '$a = extraire_balises($a,$t);'),
1734                         $tag);
1735                 return $texte;
1736         }
1737
1738         if (preg_match_all(
1739         ",<${tag}\b[^>]*(/>|>.*</${tag}\b[^>]*>|>),UimsS",
1740         $texte, $regs, PREG_PATTERN_ORDER))
1741                 return $regs[0];
1742         else
1743                 return array();
1744 }
1745
1746 // comme in_array mais renvoie son 3e arg si le 2er arg n'est pas un tableau
1747 // prend ' ' comme representant de vrai et '' de faux
1748
1749 // http://doc.spip.org/@in_any
1750 function in_any($val, $vals, $def='') {
1751   return (!is_array($vals) ? $def : (in_array($val, $vals) ? ' ' : ''));
1752 }
1753
1754 // valeur_numerique("3*2") => 6
1755 // n'accepte que les *, + et - (a ameliorer si on l'utilise vraiment)
1756 // http://doc.spip.org/@valeur_numerique
1757 function valeur_numerique($expr) {
1758         if (preg_match(',^[0-9]+(\s*[+*-]\s*[0-9]+)*$,S', trim($expr)))
1759                 eval("\$a = $expr;");
1760         return intval($a);
1761 }
1762
1763 // http://doc.spip.org/@regledetrois
1764 function regledetrois($a,$b,$c)
1765 {
1766   return round($a*$b/$c);
1767 }
1768 // Fournit la suite de Input-Hidden correspondant aux parametres de
1769 // l'URL donnee en argument, compatible avec les types_urls depuis [14447].
1770 // cf. tests/filtres/form_hidden.html
1771 // http://doc.spip.org/@form_hidden
1772 function form_hidden($action) {
1773
1774         $fond = ''; // inutilise mais necessaire
1775         $contexte = array();
1776         if (
1777                         ($renommer = generer_url_entite() OR $renommer = charger_fonction('page','urls'))
1778         AND $p = $renommer($action, $fond, $contexte)
1779         AND $p[3]) {
1780                 $contexte = $p[0];
1781                 $contexte['page'] = $p[3];
1782                 $action = preg_replace('/([?]'.$p[3].'[^&=]*[0-9]+)(&|$)/', '?&', $action);
1783         }
1784
1785         // on va remplir un tableau de valeurs en prenant bien soin de ne pas
1786         // ecraser les elements de la forme mots[]=1&mots[]=2
1787         $values = array();
1788
1789         // d'abord avec celles de l'url
1790         if (false !== ($p = strpos($action, '?'))) {
1791                 foreach(preg_split('/&(amp;)?/S',substr($action,$p+1)) as $c){
1792                         list($var,$val) = explode('=', $c, 2);
1793                         if ($var) {
1794                                 $val =  rawurldecode($val);
1795                                 $var =  rawurldecode($var); // decoder les [] eventuels
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                 }
1802         }
1803
1804         // ensuite avec celles du contexte, sans doublonner !
1805         foreach($contexte as $var=>$val)
1806                 if (preg_match(',\[\]$,S', $var))
1807                         $values[] = array($var, $val);
1808                 else if (!isset($values[$var]))
1809                         $values[$var] = array($var, $val);
1810
1811         // puis on rassemble le tout
1812         $hidden = array();
1813         foreach($values as $value) {
1814                 list($var,$val) = $value;
1815                 $hidden[] = '<input name="'
1816                         . entites_html($var)
1817                         .'"'
1818                         . (is_null($val)
1819                                 ? ''
1820                                 : ' value="'.str_replace("'","&#39;",entites_html($val)).'"'
1821                                 )
1822                         . ' type="hidden" />';
1823         }
1824         return join("\n", $hidden);
1825 }
1826
1827
1828 // http://doc.spip.org/@filtre_bornes_pagination_dist
1829 function filtre_bornes_pagination_dist($courante, $nombre, $max = 10) {
1830         if($max<=0 OR $max>=$nombre)
1831                 return array(1, $nombre);
1832
1833         $premiere = max(1, $courante-floor(($max-1)/2));
1834         $derniere = min($nombre, $premiere+$max-2);
1835         $premiere = $derniere == $nombre ? $derniere-$max+1 : $premiere;
1836         return array($premiere, $derniere);
1837 }
1838
1839
1840 // Ces trois fonctions permettent de simuler les filtres |reset et |end
1841 // pour extraire la premiere ou la derniere valeur d'un tableau ; utile
1842 // pour la pagination (mais peut-etre a refaire plus simplement)
1843 // http://doc.spip.org/@filtre_valeur_tableau
1844 function filtre_valeur_tableau($array, $index) {
1845         if (!is_array($array)
1846         OR !isset($array[$index]))
1847                 return null;
1848         return $array[$index];
1849 }
1850 // http://doc.spip.org/@filtre_reset
1851 function filtre_reset($array) {
1852         return !is_array($array) ? null : reset($array);
1853 }
1854 // http://doc.spip.org/@filtre_end
1855 function filtre_end($array) {
1856         return !is_array($array) ? null : end($array);
1857 }
1858
1859 // http://doc.spip.org/@filtre_push
1860 function filtre_push($array, $val) {
1861         if($array == '' OR !array_push($array, $val)) return '';
1862         return $array;
1863 }
1864
1865 // http://doc.spip.org/@filtre_find
1866 function filtre_find($array, $val) {
1867         return (is_array($array) AND in_array($val, $array));
1868 }
1869
1870
1871 //
1872 // fonction standard de calcul de la balise #PAGINATION
1873 // on peut la surcharger en definissant filtre_pagination dans mes_fonctions
1874 //
1875
1876 // http://doc.spip.org/@filtre_pagination_dist
1877 function filtre_pagination_dist($total, $nom, $position, $pas, $liste = true, $modele='', $connect='', $env=array()) {
1878         static $ancres = array();
1879         if ($pas<1) return '';
1880         $ancre = 'pagination'.$nom; // #pagination_articles
1881         $debut = 'debut'.$nom; // 'debut_articles'
1882
1883         // n'afficher l'ancre qu'une fois
1884         if (!isset($ancres[$ancre]))
1885                 $bloc_ancre = $ancres[$ancre] = "<a name='$ancre' id='$ancre'></a>";
1886         else $bloc_ancre = '';
1887         // liste = false : on ne veut que l'ancre
1888         if (!$liste)
1889                 return $ancres[$ancre];
1890
1891         $position = min($position,$total);
1892         $pagination = array(
1893                 'debut' => $debut,
1894                 'url' => parametre_url(self(),'fragment',''), // nettoyer l'id ahah eventuel
1895                 'total' => $total,
1896                 'position' => intval($position),
1897                 'pas' => $pas,
1898                 'nombre_pages' => floor(($total-1)/$pas)+1,
1899                 'page_courante' => floor(intval($position)/$pas)+1,
1900                 'ancre' => $ancre,
1901                 'bloc_ancre' => $bloc_ancre
1902         );
1903         if (is_array($env))
1904                 $pagination = array_merge($env,$pagination);
1905
1906         // Pas de pagination
1907         if ($pagination['nombre_pages']<=1)
1908                 return '';
1909
1910         if ($modele) $modele = '_'.$modele;
1911
1912         return recuperer_fond("modeles/pagination$modele", $pagination, array('trim'=>true), $connect);
1913 }
1914
1915 // passer les url relatives a la css d'origine en url absolues
1916 // http://doc.spip.org/@urls_absolues_css
1917 function urls_absolues_css($contenu, $source) {
1918         $path = suivre_lien(url_absolue($source),'./');
1919
1920         $contenu = preg_replace_callback(
1921                 ",url\s*\(\s*['\"]?([^'\"/][^:]*)['\"]?\s*\),Uims",
1922                 create_function('$x',
1923                         'return "url(\"".suivre_lien("'.$path.'",$x[1])."\")";'
1924                 ), $contenu);
1925
1926   // les directives filter ... progid:DXImageTransform.Microsoft.AlphaImageLoader(src=...,..)
1927         // de IEx prennent des urls relatives a la page, et non a la css
1928         // ne pas y toucher.
1929         /*
1930         $contenu = preg_replace_callback(
1931                 ";\(\s*src=['\"]?([^'\"/][^:]*)['\"]?\s*(,|\));Uims",
1932                 create_function('$x',
1933                         'return "(src=\"".suivre_lien("'.$path.'",$x[1])."\"".$x[2];'
1934                 ), $contenu);
1935          */
1936         return $contenu;
1937 }
1938
1939 // recuperere le chemin d'une css existante et :
1940 // 1. regarde si une css inversee droite-gauche existe dans le meme repertoire
1941 // 2. sinon la cree (ou la recree) dans _DIR_VAR/cache_css/
1942 // SI on lui donne a manger une feuille nommee _rtl.css il va faire l'inverse
1943 // http://doc.spip.org/@direction_css
1944 function direction_css ($css, $voulue='') {
1945         if (!preg_match(',(_rtl)?\.css$,i', $css, $r)) return $css;
1946
1947         // si on a precise le sens voulu en argument, le prendre en compte
1948         if ($voulue = strtolower($voulue)) {
1949                 if ($voulue != 'rtl' AND $voulue != 'ltr')
1950                         $voulue = lang_dir($voulue);
1951         }
1952         else
1953                 $voulue =  lang_dir();
1954
1955         $r = count($r) > 1;
1956         $right = $r ? 'left' : 'right'; // 'right' de la css lue en entree
1957         $dir = $r ? 'rtl' : 'ltr';
1958         $ndir = $r ? 'ltr' : 'rtl';
1959
1960         if ($voulue == $dir)
1961                 return $css;
1962
1963         if (
1964                 // url absolue
1965                 preg_match(",^http:,i",$css)
1966                 // ou qui contient un ?
1967                 OR (($p=strpos($css,'?'))!==FALSE)) {
1968                 $distant = true;
1969                 $cssf = parse_url($css);
1970                 $cssf = $cssf['path'].($cssf['query']?"?".$cssf['query']:"");
1971                 $cssf = preg_replace(',[\W],', "_", $cssf);
1972         }
1973         else {
1974                 $distant = false;
1975                 $cssf = $css;
1976                 // 1. regarder d'abord si un fichier avec la bonne direction n'est pas aussi
1977                 //propose (rien a faire dans ce cas)
1978                 $f = preg_replace(',(_rtl)?\.css$,i', '_'.$ndir.'.css', $css);
1979                 if (@file_exists($f))
1980                         return $f;
1981         }
1982
1983         // 2.
1984         $dir_var = sous_repertoire (_DIR_VAR, 'cache-css');
1985         $f = $dir_var
1986                 . preg_replace(',.*/(.*?)(_rtl)?\.css,', '\1', $cssf)
1987                 . '.' . substr(md5($cssf), 0,4) . '_' . $ndir . '.css';
1988
1989         // la css peut etre distante (url absolue !)
1990         if ($distant){
1991                 include_spip('inc/distant');
1992                 $contenu = recuperer_page($css);
1993                 if (!$contenu) return $css;
1994         }
1995         else {
1996                 if ((@filemtime($f) > @filemtime($css))
1997                         AND ($GLOBALS['var_mode'] != 'recalcul'))
1998                         return $f;
1999                 if (!lire_fichier($css, $contenu))
2000                         return $css;
2001         }
2002
2003         $contenu = str_replace(
2004                 array('right', 'left', '@@@@L E F T@@@@'),
2005                 array('@@@@L E F T@@@@', 'right', 'left'),
2006                 $contenu);
2007
2008         // reperer les @import auxquels il faut propager le direction_css
2009         preg_match_all(",\@import\s*url\s*\(\s*['\"]?([^'\"/][^:]*)['\"]?\s*\),Uims",$contenu,$regs);
2010         $src = array();$src_direction_css = array();$src_faux_abs=array();
2011         $d = dirname($css);
2012         foreach($regs[1] as $k=>$import_css){
2013                 $css_direction = direction_css("$d/$import_css",$voulue);
2014                 // si la css_direction est dans le meme path que la css d'origine, on tronque le path, elle sera passee en absolue
2015                 if (substr($css_direction,0,strlen($d)+1)=="$d/") $css_direction = substr($css_direction,strlen($d)+1);
2016                 // si la css_direction commence par $dir_var on la fait passer pour une absolue
2017                 elseif (substr($css_direction,0,strlen($dir_var))==$dir_var) {
2018                         $css_direction = substr($css_direction,strlen($dir_var));
2019                         $src_faux_abs["/@@@@@@/".$css_direction] = $css_direction;
2020                         $css_direction = "/@@@@@@/".$css_direction;
2021                 }
2022                 $src[] = $regs[0][$k];
2023                 $src_direction_css[] = str_replace($import_css,$css_direction,$regs[0][$k]);
2024         }
2025         $contenu = str_replace($src,$src_direction_css,$contenu);
2026
2027         $contenu = urls_absolues_css($contenu, $css);
2028
2029         // virer les fausses url absolues que l'on a mis dans les import
2030         if (count($src_faux_abs))
2031                 $contenu = str_replace(array_keys($src_faux_abs),$src_faux_abs,$contenu);
2032
2033         if (!ecrire_fichier($f, $contenu))
2034                 return $css;
2035
2036         return $f;
2037 }
2038
2039 // recuperere le chemin d'une css existante et :
2040 // cree (ou recree) dans _DIR_VAR/cache_css/ une css dont les url relatives sont passees en url absolues
2041 // http://doc.spip.org/@url_absolue_css
2042 function url_absolue_css ($css) {
2043         if (!preg_match(',\.css$,i', $css, $r)) return $css;
2044
2045         $url_absolue_css = url_absolue($css);
2046
2047         $f = basename($css,'.css');
2048         $f = sous_repertoire (_DIR_VAR, 'cache-css')
2049                 . preg_replace(",(.*?)(_rtl|_ltr)?$,","\\1-urlabs-" . substr(md5("$css-urlabs"), 0,4) . "\\2",$f)
2050                 . '.css';
2051
2052         if ((@filemtime($f) > @filemtime($css))
2053         AND ($GLOBALS['var_mode'] != 'recalcul'))
2054                 return $f;
2055
2056         if ($url_absolue_css==$css){
2057                 if (strncmp($GLOBALS['meta']['adresse_site'],$css,$l=strlen($GLOBALS['meta']['adresse_site']))!=0
2058                  OR !lire_fichier(_DIR_RACINE . substr($css,$l), $contenu)){
2059                                 include_spip('inc/distant');
2060                                 if (!$contenu = recuperer_page($css))
2061                                         return $css;
2062                 }
2063         }
2064         elseif (!lire_fichier($css, $contenu))
2065                 return $css;
2066
2067         // passer les url relatives a la css d'origine en url absolues
2068         $contenu = urls_absolues_css($contenu, $css);
2069
2070         // ecrire la css
2071         if (!ecrire_fichier($f, $contenu))
2072                 return $css;
2073
2074         return $f;
2075 }
2076
2077
2078 // filtre table_valeur
2079 // permet de recuperer la valeur d'un tableau pour une cle donnee
2080 // prend en entree un tableau serialise ou non (ce qui permet d'enchainer le filtre)
2081 // http://doc.spip.org/@table_valeur
2082 function table_valeur($table,$cle,$defaut=''){
2083         $table= is_string($table)?unserialize($table):$table;
2084         $table= is_array($table)?$table:array();
2085         return isset($table[$cle])?$table[$cle]:$defaut;
2086 }
2087
2088 // filtre match pour faire des tests avec expression reguliere
2089 // [(#TEXTE|match{^ceci$,Uims})]
2090 // retourne le fragment de chaine qui "matche"
2091 // il est possible de passer en 3eme argument optionnel le numero de parenthese capturante
2092 // accepte egalement la syntaxe #TRUC|match{truc(...)$,1} ou le modificateur n'est pas passe en second argument
2093 // http://doc.spip.org/@match
2094 function match($texte, $expression, $modif="UimsS",$capte=0) {
2095         if (intval($modif) AND $capte==0){
2096                 $capte = $modif;
2097                 $modif = "UimsS";
2098         }
2099         $expression=str_replace("\/","/",$expression);
2100         $expression=str_replace("/","\/",$expression);
2101
2102         if (preg_match('/' . $expression . '/' . $modif,$texte, $r)) {
2103                 if (isset($r[$capte]))
2104                         return $r[$capte];
2105                 else
2106                         return true;
2107         }
2108         return false;
2109 }
2110
2111 // filtre replace pour faire des operations avec expression reguliere
2112 // [(#TEXTE|replace{^ceci$,cela,UimsS})]
2113 // http://doc.spip.org/@replace
2114 function replace($texte, $expression, $replace='', $modif="UimsS") {
2115         $expression=str_replace("\/","/", $expression);
2116         $expression=str_replace("/","\/",$expression);
2117         return preg_replace('/' . $expression . '/' . $modif, $replace, $texte);
2118 }
2119
2120
2121 // cherche les documents numerotes dans un texte traite par propre()
2122 // et affecte les doublons['documents']
2123 // http://doc.spip.org/@traiter_doublons_documents
2124 // http://doc.spip.org/@traiter_doublons_documents
2125 function traiter_doublons_documents(&$doublons, $letexte) {
2126
2127         // Verifier dans le texte & les notes (pas beau, helas)
2128         $t = $letexte.$GLOBALS['les_notes'];
2129
2130         if (strstr($t, 'spip_document_') // evite le preg_match_all si inutile
2131         AND preg_match_all(
2132         ',<[^>]+\sclass=["\']spip_document_([0-9]+)[\s"\'],imsS',
2133         $t, $matches, PREG_PATTERN_ORDER))
2134                 $doublons['documents'] .= "," . join(',', $matches[1]);
2135
2136         return $letexte;
2137 }
2138
2139 // filtre vide qui ne renvoie rien
2140 // http://doc.spip.org/@vide
2141 function vide($texte){
2142         return "";
2143 }
2144
2145 //
2146 // Filtres pour le modele/emb (embed document)
2147 //
2148
2149 // A partir d'un #ENV, retourne des <param ...>
2150 // http://doc.spip.org/@env_to_params
2151 function env_to_params ($texte, $ignore_params=array()) {
2152         $ignore_params = array_merge (
2153                 array('id', 'lang', 'id_document', 'date', 'date_redac', 'align', 'fond', '', 'recurs', 'emb', 'dir_racine'),
2154         $ignore_params);
2155         $tableau = unserialize($texte);
2156         $texte = "";
2157         foreach ($tableau as $i => $j)
2158                 if (is_string($j) AND !in_array($i,$ignore_params))
2159                         $texte .= "<param name='".$i."'\n\tvalue='".$j."' />";
2160         return $texte;
2161 }
2162 // A partir d'un #ENV, retourne des attributs
2163 // http://doc.spip.org/@env_to_attributs
2164 function env_to_attributs ($texte, $ignore_params=array()) {
2165         $ignore_params = array_merge (
2166                 array('id', 'lang', 'id_document', 'date', 'date_redac', 'align', 'fond', '', 'recurs', 'emb', 'dir_racine'),
2167         $ignore_params);
2168         $tableau = unserialize($texte);
2169         $texte = "";
2170         foreach ($tableau as $i => $j)
2171                 if (is_string($j) AND !in_array($i,$ignore_params))
2172                         $texte .= $i."='".$j."' ";
2173         return $texte;
2174 }
2175
2176 // Inserer jQuery
2177 // et au passage verifier qu'on ne doublonne pas #INSERT_HEAD
2178 // http://doc.spip.org/@f_jQuery
2179 function f_jQuery ($texte) {
2180         static $doublon=0;
2181         if ($doublon++) {
2182                 erreur_squelette(array('double_occurrence', array('balise' => "INSERT_HEAD")));
2183         } else {
2184                 $x = '';
2185                 foreach (array_unique(pipeline('jquery_plugins',
2186                 array(
2187                         'javascript/jquery.js',
2188                         'javascript/jquery.form.js',
2189                         'javascript/ajaxCallback.js',
2190                         'javascript/jquery.cookie.js'
2191                 ))) as $script)
2192                         if ($script = find_in_path($script))
2193                                 $x .= "\n<script src=\"$script\" type=\"text/javascript\"></script>\n";
2194                 $texte = $x.$texte;
2195         }
2196         return $texte;
2197 }
2198
2199 /**
2200  * fonction appelee par #INSERT_HEAD_CSS et #INSERT_HEAD pour la compatibilite
2201  * @staticvar <type> $done
2202  * @return <type>
2203  */
2204 function insert_head_css(){
2205         static $done = false;
2206         if ($done) return '';
2207         $done = true;
2208         return pipeline('insert_head_css','');
2209 }
2210
2211
2212 // Concatener des chaines
2213 // #TEXTE|concat{texte1,texte2,...}
2214 // http://doc.spip.org/@concat
2215 function concat(){
2216         $args = func_get_args();
2217         return join('', $args);
2218 }
2219
2220
2221 // http://doc.spip.org/@charge_scripts
2222 function charge_scripts($scripts) {
2223   $flux = "";
2224   $args = is_array($scripts)?$scripts:explode("|",$scripts);
2225   foreach($args as $script) {
2226     if(preg_match(",^\w+$,",$script)) {
2227       $path = find_in_path("javascript/$script.js");
2228       if($path) $flux .= spip_file_get_contents($path);
2229     }
2230   }
2231   return $flux;
2232 }
2233
2234
2235
2236
2237 // produit une balise img avec un champ alt d'office si vide
2238 // attention le htmlentities et la traduction doivent etre appliques avant.
2239
2240 // http://doc.spip.org/@http_wrapper
2241 function http_wrapper($img){
2242         if (strpos($img,'/')===FALSE) // on ne prefixe par _NOM_IMG_PACK que si c'est un nom de fichier sans chemin
2243                 $f = chemin_image($img);
2244         else { // sinon, le path a ete fourni
2245                 $f = $img;
2246         }
2247         return $f;
2248 }
2249
2250 // http://doc.spip.org/@http_img_pack
2251 function http_img_pack($img, $alt, $atts='', $title='') {
2252
2253         $img = http_wrapper($img);
2254         if (strpos($atts, 'width')===FALSE){
2255                 // utiliser directement l'info de taille presente dans le nom
2256                 if (preg_match(',-([0-9]+)[.](png|gif)$,',$img,$regs)){
2257                                 $size = array(intval($regs[1]),intval($regs[1]));
2258                 }
2259                 else
2260                         $size = @getimagesize($img);
2261                 $atts.=" width='".$size[0]."' height='".$size[1]."'";
2262         }
2263         return  "<img src='" . $img
2264           . ("'\nalt=\"" .
2265              str_replace('"','', textebrut($alt ? $alt : ($title ? $title : '')))
2266              . '" ')
2267           . ($title ? "title=\"$title\" " : '')
2268           . $atts
2269           . " />";
2270 }
2271
2272 // http://doc.spip.org/@http_style_background
2273 function http_style_background($img, $att='')
2274 {
2275   return " style='background: url(\"".http_wrapper($img)."\")" .
2276             ($att ? (' ' . $att) : '') . ";'";
2277 }
2278
2279 //[(#ENV*|unserialize|foreach)]
2280 // http://doc.spip.org/@filtre_foreach_dist
2281 function filtre_foreach_dist($balise_deserializee, $modele = 'foreach') {
2282         $texte = '';
2283         if(is_array($balise_deserializee))
2284                 foreach($balise_deserializee as $k => $v) {
2285                         $res = recuperer_fond('modeles/'.$modele,
2286                                 array_merge(array('cle' => $k), (is_array($v) ? $v : array('valeur' => $v)))
2287                         );
2288                         $texte .= $res;
2289                 }
2290         return $texte;
2291 }
2292
2293 // renvoie la liste des plugins actifs du site
2294 // si le premier parametre est un prefix de cette liste, renvoie vrai, faux sinon
2295 // la valeur du second parametre si celui-ci renvoie a une information connue
2296 // cf liste_plugin_actifs() pour connaitre les informations affichables
2297 // appelee par la balise #PLUGIN
2298 // http://doc.spip.org/@filtre_info_plugin_dist
2299 function filtre_info_plugin_dist($plugin, $type_info) {
2300         include_spip('inc/plugin');
2301         $plugin = strtoupper($plugin);
2302         $plugins_actifs = liste_plugin_actifs();
2303
2304         if (!$plugin)
2305                 return serialize(array_keys($plugins_actifs));
2306         elseif (empty($plugins_actifs[$plugin]))
2307                 return '';
2308         elseif ($type_info == 'est_actif')
2309                 return $plugins_actifs[$plugin] ? 1 : 0;
2310         elseif (isset($plugins_actifs[$plugin][$type_info]))
2311                 return $plugins_actifs[$plugin][$type_info];
2312         else {
2313                 $get_infos = charger_fonction('get_infos','plugins');
2314                 // On prend en compte les extensions
2315                 if (!is_dir($plugins_actifs[$plugin]['dir_type']))
2316                         $dir_plugins = constant($plugins_actifs[$plugin]['dir_type']);
2317                 else
2318                         $dir_plugins = $plugins_actifs[$plugin]['dir_type'];
2319                 if (!$infos = $get_infos($plugins_actifs[$plugin]['dir'], false, $dir_plugins))
2320                         return '';
2321                 if ($type_info == 'tout')
2322                         return $infos;
2323                 else
2324                         return strval($infos[$type_info]);
2325         }
2326 }
2327
2328
2329 // http://doc.spip.org/@chercher_rubrique
2330 function chercher_rubrique($msg,$id, $id_parent, $type, $id_secteur, $restreint,$actionable = false, $retour_sans_cadre=false){
2331         global $spip_lang_right;
2332         include_spip('inc/autoriser');
2333         if (intval($id) && !autoriser('modifier', $type, $id))
2334                 return "";
2335         if (!sql_countsel('spip_rubriques'))
2336                 return "";
2337         $chercher_rubrique = charger_fonction('chercher_rubrique', 'inc');
2338         $form = $chercher_rubrique($id_parent, $type, $restreint, ($type=='rubrique')?$id:0);
2339
2340         if ($id_parent == 0) $logo = "racine-site-24.gif";
2341         elseif ($id_secteur == $id_parent) $logo = "secteur-24.gif";
2342         else $logo = "rubrique-24.gif";
2343
2344         $confirm = "";
2345         if ($type=='rubrique') {
2346                 // si c'est une rubrique-secteur contenant des breves, demander la
2347                 // confirmation du deplacement
2348                 $contient_breves = sql_countsel('spip_breves', "id_rubrique=$id");
2349
2350                 if ($contient_breves > 0) {
2351                         $scb = ($contient_breves>1? 's':'');
2352                         $scb = _T('avis_deplacement_rubrique',
2353                                 array('contient_breves' => $contient_breves,
2354                                       'scb' => $scb));
2355                         $confirm .= "\n<div class='confirmer_deplacement verdana2'><div class='choix'><input type='checkbox' name='confirme_deplace' value='oui' id='confirme-deplace' /><label for='confirme-deplace'>" . $scb . "</label></div></div>\n";
2356                 } else
2357                         $confirm .= "<input type='hidden' name='confirme_deplace' value='oui' />\n";
2358         }
2359         $form .= $confirm;
2360         if ($actionable){
2361                 if (strpos($form,'<select')!==false) {
2362                         $form .= "<div style='text-align: $spip_lang_right;'>"
2363                                 . '<input type="submit" value="'._T('bouton_choisir').'"/>'
2364                                 . "</div>";
2365                 }
2366                 $form = "<input type='hidden' name='editer_$type' value='oui' />\n" . $form;
2367                 $form = generer_action_auteur("editer_$type", $id, self(), $form, " method='post' class='submit_plongeur'");
2368         }
2369
2370         if ($retour_sans_cadre)
2371                 return $form;
2372
2373         include_spip('inc/presentation');
2374         return debut_cadre_couleur($logo, true, "", $msg) . $form .fin_cadre_couleur(true);
2375
2376 }
2377
2378
2379 // http://doc.spip.org/@puce_changement_statut
2380 function puce_changement_statut($id_objet, $statut, $id_rubrique, $type, $ajax=false){
2381         $puce_statut = charger_fonction('puce_statut','inc');
2382         return $puce_statut($id_objet, $statut, $id_rubrique, $type, $ajax=false);
2383 }
2384
2385 // Encoder un contexte pour l'ajax, le signer avec une cle, le crypter
2386 // avec le secret du site, le gziper si possible...
2387 // l'entree peut etre serialisee (le #ENV** des fonds ajax et ajax_stat)
2388 // http://doc.spip.org/@encoder_contexte_ajax
2389 function encoder_contexte_ajax($c,$form='', $emboite=NULL) {
2390         if (is_string($c)
2391         AND !is_null(@unserialize($c)))
2392                 $c = unserialize($c);
2393
2394         // supprimer les parametres debut_x
2395         // pour que la pagination ajax ne soit pas plantee
2396         // si on charge la page &debut_x=1 : car alors en cliquant sur l'item 0,
2397         // le debut_x=0 n'existe pas, et on resterait sur 1
2398         foreach ($c as $k => $v)
2399                 if (strpos($k,'debut_') === 0)
2400                         unset($c[$k]);
2401
2402         include_spip("inc/securiser_action");
2403         $cle = calculer_cle_action($form.(is_array($c)?serialize($c):$c));
2404         $c = serialize(array($c,$cle));
2405
2406         if ((defined('_CACHE_CONTEXTES_AJAX') AND _CACHE_CONTEXTES_AJAX)
2407                 AND $dir = sous_repertoire(_DIR_CACHE, 'contextes')) {
2408                 // stocker les contextes sur disque et ne passer qu'un hash dans l'url
2409                 $md5 = md5($c);
2410                 ecrire_fichier("$dir/c$md5",$c);
2411                 $c = $md5;
2412         } else {
2413                 if (function_exists('gzdeflate') && function_exists('gzinflate'))
2414                         $c = gzdeflate($c);
2415                 $c = _xor($c);
2416                 $c = base64_encode($c);
2417         }
2418
2419         if ($emboite === NULL) return $c;
2420         return !trim($emboite) ? '' :
2421         "<div class='ajaxbloc env-$c'>\n$emboite</div><!-- ajaxbloc -->\n";
2422 }
2423
2424 // la procedure inverse de encoder_contexte_ajax()
2425 // http://doc.spip.org/@decoder_contexte_ajax
2426 function decoder_contexte_ajax($c,$form='') {
2427         include_spip("inc/securiser_action");
2428         if (( (defined('_CACHE_CONTEXTES_AJAX') AND _CACHE_CONTEXTES_AJAX) OR strlen($c)==32)
2429                 AND $dir = sous_repertoire(_DIR_CACHE, 'contextes')
2430                 AND lire_fichier("$dir/c$c",$contexte)) {
2431                         $c = $contexte;
2432         } else {
2433                 $c = @base64_decode($c);
2434                 $c = _xor($c);
2435                 if (function_exists('gzdeflate') && function_exists('gzinflate'))
2436                         $c = @gzinflate($c);
2437         }
2438         list($env, $cle) = @unserialize($c);
2439
2440         if ($cle == calculer_cle_action($form.(is_array($env)?serialize($env):$env)))
2441                 return $env;
2442         return false;
2443 }
2444
2445 // encrypter/decrypter un message
2446 // http://www.php.net/manual/fr/language.operators.bitwise.php#81358
2447 // http://doc.spip.org/@_xor
2448 function _xor($message, $key=null){
2449         if (is_null($key)) {
2450                 include_spip("inc/securiser_action");
2451                 $key = pack("H*", calculer_cle_action('_xor'));
2452         }
2453
2454         $keylen = strlen($key);
2455         $messagelen = strlen($message);
2456         for($i=0; $i<$messagelen; $i++)
2457                 $message[$i] = ~($message[$i]^$key[$i%$keylen]);
2458
2459         return $message;
2460 }
2461
2462
2463
2464 /**
2465  * une fonction pour generer des menus avec liens
2466  * ou un <strong class='on'> non clicable lorsque l'item est selectionne
2467  *
2468  * @param string $url
2469  * @param string $libelle
2470  *   le texte du lien
2471  * @param bool $on
2472  *   etat expose (genere un strong) ou non (genere un lien)
2473  * @param string $class
2474  * @param string $title
2475  * @param string $rel
2476  * @param string $evt
2477  *   complement a la balise a pour gerer un evenement javascript, de la forme " onclick='...'"
2478  * @return string
2479  */
2480 function lien_ou_expose($url,$libelle,$on=false,$class="",$title="",$rel="", $evt=''){
2481         if ($on) {
2482                 $bal = "strong";
2483                 $att = "class='on'";
2484         } else {
2485                 $bal = 'a';
2486                 $att = "href='$url'"
2487                 .($title?" title='".attribut_html($title)."'":'')
2488                 .($class?" class='".attribut_html($class)."'":'')
2489                 .($rel?" rel='".attribut_html($rel)."'":'')
2490                 .$evt;
2491         }
2492
2493         return "<$bal $att>$libelle</$bal>";
2494 }
2495
2496
2497 /**
2498  * une fonction pour generer une balise img a partir d'un nom de fichier
2499  *
2500  * @param string $img
2501  * @param string $alt
2502  * @param string $class
2503  * @return string
2504  */
2505 function filtre_balise_img_dist($img,$alt="",$class=""){
2506         $taille = taille_image($img);
2507         list($hauteur,$largeur) = $taille;
2508         if (!$hauteur OR !$largeur)
2509                 return "";
2510         return
2511         "<img src='$img' width='$largeur' height='$hauteur'"
2512           ." alt='".attribut_html($alt)."'"
2513           .($class?" class='".attribut_html($class)."'":'')
2514           .' />';
2515 }
2516
2517
2518 /**
2519  * Afficher un message "un truc"/"N trucs"
2520  *
2521  * @param int $nb
2522  * @return string
2523  */
2524 function singulier_ou_pluriel($nb,$chaine_un,$chaine_plusieurs,$var='nb'){
2525         if (!$nb=intval($nb)) return "";
2526         if ($nb>1) return _T($chaine_plusieurs, array($var => $nb));
2527         else return _T($chaine_un);
2528 }
2529
2530
2531 /**
2532  * un filtre icone mappe sur icone_inline, qui cree une icone a gauche par defaut
2533  * le code de icone_inline est grandement reproduit ici car les liens ajax portent simplement une class ajax
2534  * lorsque les interfaces sont en squelette, alors que l'implementation d'ajax de des scripts php
2535  * est plus complexe
2536  *
2537  * @param string $lien
2538  * @param string $texte
2539  * @param string $fond
2540  * @param string $align
2541  * @param string $fonction
2542  * @return string
2543  */
2544 function filtre_icone_dist($lien, $texte, $fond, $align="", $fonction="", $class="",$javascript=""){
2545         if ($icone_renommer = charger_fonction('icone_renommer','inc',true))
2546                 list($fond,$fonction) = $icone_renommer($fond,$fonction);
2547
2548         $align = $align?$align:$GLOBALS['spip_lang_left'];
2549         global $spip_display;
2550
2551         if ($fonction == "del") {
2552                 $style = 'icone36 danger';
2553         } else {
2554                 $style = 'icone36';
2555                 if (strlen($fonction) < 3) $fonction = "rien.gif";
2556         }
2557         $style .= " " . substr(basename($fond),0,-4);
2558
2559         if ($spip_display == 1){
2560                 $hauteur = 20;
2561                 $largeur = 100;
2562                 $title = $alt = "";
2563         }
2564         else if ($spip_display == 3){
2565                 $hauteur = 30;
2566                 $largeur = 30;
2567                 $title = "\ntitle=\"$texte\"";
2568                 $alt = $texte;
2569         }
2570         else {
2571                 $hauteur = 70;
2572                 $largeur = 100;
2573                 $title = '';
2574                 $alt = $texte;
2575         }
2576
2577         $size = 24;
2578         if (preg_match("/-([0-9]{1,3})[.](gif|png)$/i",$fond,$match))
2579                 $size = $match[1];
2580         if ($spip_display != 1 AND $spip_display != 4){
2581                 if ($fonction != "rien.gif"){
2582                   $icone = http_img_pack($fonction, $alt, "$title width='$size' height='$size'\n" .
2583                                           http_style_background($fond, "no-repeat center center"));
2584                 }
2585                 else {
2586                         $icone = http_img_pack($fond, $alt, "$title width='$size' height='$size'");
2587                 }
2588         } else $icone = '';
2589
2590         // cas d'ajax_action_auteur: faut defaire le boulot
2591         // (il faudrait fusionner avec le cas $javascript)
2592         if (preg_match(",^<a\shref='([^']*)'([^>]*)>(.*)</a>$,i",$lien,$r))
2593                 list($x,$lien,$atts,$texte)= $r;
2594         else $atts = '';
2595
2596         if ($align && $align!='center') $align = "float: $align; ";
2597
2598         $icone = "<a style='$align' class='$style $class'"
2599         . $atts
2600         . $javascript
2601         . "\nhref='"
2602         . $lien
2603         . "'>"
2604         . $icone
2605         . (($spip_display == 3) ? '' : "<span>$texte</span>")
2606           . "</a>\n";
2607
2608         if ($align <> 'center') return $icone;
2609         $style = " style='text-align:center;'";
2610         return "<div$style>$icone</div>";
2611 }
2612
2613
2614 /**
2615  * filtre explode pour les squelettes permettant d'ecrire
2616  * #GET{truc}|explode{-}
2617  *
2618  * @param strong $a
2619  * @param string $b
2620  * @return array
2621  */
2622 function filtre_explode_dist($a,$b){return explode($b,$a);}
2623
2624 /**
2625  * filtre implode pour les squelettes permettant d'ecrire
2626  * #GET{truc}|implode{-}
2627  *
2628  * @param array $a
2629  * @param string $b
2630  * @return string
2631  */
2632 function filtre_implode_dist($a,$b){return is_array($a)?implode($b,$a):$a;}
2633
2634 /*
2635  * Deux verrues pour que le pipeline de revisions soit correct
2636  * elles vont sauter quand ca passera en plugin
2637  */
2638 function premiere_revision($x) {
2639         include_spip('inc/revisions');
2640         return enregistrer_premiere_revision($x);
2641         }
2642 function nouvelle_revision($x) {
2643         include_spip('inc/revisions');
2644         return enregistrer_nouvelle_revision($x);
2645 }
2646
2647 /**
2648  * Generer un bouton_action
2649  * utilise par #BOUTON_ACTION
2650  *
2651  * @param string $libelle
2652  * @param string $url
2653  * @param string $class
2654  * @param string $confirm
2655  * @param string $title
2656  * @return string
2657  */
2658 function bouton_action($libelle, $url, $class="", $confirm="", $title=""){
2659         $onclick = $confirm?" onclick='return confirm(\"" . attribut_html($confirm) . "\");'":"";
2660         $title = $title ? " title='$title'" : "";
2661
2662         return "<form class='bouton_action_post $class' method='post' action='$url'><div>".form_hidden($url)
2663                 ."<button type='submit' class='submit'$title$onclick>$libelle</button></div></form>";
2664 }
2665
2666
2667 ?>