www/ecrire/public/balises.php

   1 <?php
   2
   3 /***************************************************************************\
   4  *  SPIP, Systeme de publication pour l'internet                           *
   5  *                                                                         *
   6  *  Copyright (c) 2001-2014                                                *
   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 // Ce fichier regroupe la quasi totalite des definitions de #BALISES de spip
  14 // Pour chaque balise, il est possible de surcharger, dans mes_fonctions,
  15 // la fonction balise_TOTO_dist par une fonction balise_TOTO() respectant la
  16 // meme API :
  17 // elle recoit en entree un objet de classe CHAMP, le modifie et le retourne.
  18 // Cette classe est definie dans public/interfaces
  19
  20 if (!defined('_ECRIRE_INC_VERSION')) return;
  21
  22 // http://doc.spip.org/@interprete_argument_balise
  23 function interprete_argument_balise($n,$p) {
  24         if (($p->param) && (!$p->param[0][0]) && (count($p->param[0])>$n))
  25                 return calculer_liste($p->param[0][$n],
  26                         $p->descr,
  27                         $p->boucles,
  28                         $p->id_boucle);
  29         else
  30                 return NULL;
  31 }
  32 //
  33 // Definition des balises
  34 //
  35 // http://doc.spip.org/@balise_NOM_SITE_SPIP_dist
  36 function balise_NOM_SITE_SPIP_dist($p) {
  37         $p->code = "\$GLOBALS['meta']['nom_site']";
  38         #$p->interdire_scripts = true;
  39         return $p;
  40 }
  41
  42 // http://doc.spip.org/@balise_EMAIL_WEBMASTER_dist
  43 function balise_EMAIL_WEBMASTER_dist($p) {
  44         $p->code = "\$GLOBALS['meta']['email_webmaster']";
  45         #$p->interdire_scripts = true;
  46         return $p;
  47 }
  48
  49 // http://doc.spip.org/@balise_DESCRIPTIF_SITE_SPIP_dist
  50 function balise_DESCRIPTIF_SITE_SPIP_dist($p) {
  51         $p->code = "\$GLOBALS['meta']['descriptif_site']";
  52         #$p->interdire_scripts = true;
  53         return $p;
  54 }
  55
  56 // http://doc.spip.org/@balise_CHARSET_dist
  57 function balise_CHARSET_dist($p) {
  58         $p->code = "\$GLOBALS['meta']['charset']";
  59         #$p->interdire_scripts = true;
  60         return $p;
  61 }
  62
  63 // http://doc.spip.org/@balise_LANG_LEFT_dist
  64 function balise_LANG_LEFT_dist($p) {
  65         $_lang = champ_sql('lang', $p);
  66         $p->code = "lang_dir($_lang, 'left','right')";
  67         $p->interdire_scripts = false;
  68         return $p;
  69 }
  70
  71 // http://doc.spip.org/@balise_LANG_RIGHT_dist
  72 function balise_LANG_RIGHT_dist($p) {
  73         $_lang = champ_sql('lang', $p);
  74         $p->code = "lang_dir($_lang, 'right','left')";
  75         $p->interdire_scripts = false;
  76         return $p;
  77 }
  78
  79 // http://doc.spip.org/@balise_LANG_DIR_dist
  80 function balise_LANG_DIR_dist($p) {
  81         $_lang = champ_sql('lang', $p);
  82         $p->code = "lang_dir($_lang, 'ltr','rtl')";
  83         $p->interdire_scripts = false;
  84         return $p;
  85 }
  86
  87 // http://doc.spip.org/@balise_PUCE_dist
  88 function balise_PUCE_dist($p) {
  89         $p->code = "definir_puce()";
  90         $p->interdire_scripts = false;
  91         return $p;
  92 }
  93
  94 // #DATE
  95 // Cette fonction sait aller chercher dans le contexte general
  96 // quand #DATE est en dehors des boucles
  97 // http://www.spip.net/fr_article1971.html
  98 // http://doc.spip.org/@balise_DATE_dist
  99 function balise_DATE_dist ($p) {
 100         $d = champ_sql('date', $p);
 101 #       if ($d === "@\$Pile[0]['date']")
 102 #               $d = "isset(\$Pile[0]['date']) ? $d : time()";
 103         $p->code = $d;
 104         return $p;
 105 }
 106
 107 // #DATE_REDAC
 108 // http://www.spip.net/fr_article1971.html
 109 // http://doc.spip.org/@balise_DATE_REDAC_dist
 110 function balise_DATE_REDAC_dist ($p) {
 111         $d = champ_sql('date_redac', $p);
 112 #       if ($d === "@\$Pile[0]['date_redac']")
 113 #               $d = "isset(\$Pile[0]['date_redac']) ? $d : time()";
 114         $p->code = $d;
 115         $p->interdire_scripts = false;
 116         return $p;
 117 }
 118
 119 // #DATE_MODIF
 120 // http://www.spip.net/fr_article1971.html
 121 // http://doc.spip.org/@balise_DATE_MODIF_dist
 122 function balise_DATE_MODIF_dist ($p) {
 123         $p->code = champ_sql('date_modif', $p);
 124         $p->interdire_scripts = false;
 125         return $p;
 126 }
 127
 128 // #DATE_NOUVEAUTES
 129 // http://www.spip.net/fr_article1971.html
 130 // http://doc.spip.org/@balise_DATE_NOUVEAUTES_dist
 131 function balise_DATE_NOUVEAUTES_dist($p) {
 132         $p->code = "((\$GLOBALS['meta']['quoi_de_neuf'] == 'oui'
 133         AND isset(\$GLOBALS['meta']['dernier_envoi_neuf'])) ?
 134         \$GLOBALS['meta']['dernier_envoi_neuf'] :
 135         \"'0000-00-00'\")";
 136         $p->interdire_scripts = false;
 137         return $p;
 138 }
 139
 140 // http://doc.spip.org/@balise_DOSSIER_SQUELETTE_dist
 141 function balise_DOSSIER_SQUELETTE_dist($p) {
 142         $code = substr(addslashes(dirname($p->descr['sourcefile'])), strlen(_DIR_RACINE));
 143         $p->code = "_DIR_RACINE . '$code'" .
 144         $p->interdire_scripts = false;
 145         return $p;
 146 }
 147
 148 // http://doc.spip.org/@balise_SQUELETTE_dist
 149 function balise_SQUELETTE_dist($p) {
 150         $code = addslashes($p->descr['sourcefile']);
 151         $p->code = "'$code'" .
 152         $p->interdire_scripts = false;
 153         return $p;
 154 }
 155
 156 // http://doc.spip.org/@balise_SPIP_VERSION_dist
 157 function balise_SPIP_VERSION_dist($p) {
 158         $p->code = "spip_version()";
 159         $p->interdire_scripts = false;
 160         return $p;
 161 }
 162
 163
 164
 165 /**
 166  * Affiche le nom du site.
 167  *
 168  * Affiche le nom du site ou sinon l'URL ou le titre de l'objet
 169  * Utiliser #NOM_SITE* pour avoir le nom du site ou rien.
 170  *
 171  * Cette balise interroge les colonnes 'nom_site' ou 'url_site'
 172  * dans la boucle la plus proche.
 173  *
 174  * @example
 175  *              <code>
 176  *                      <a href="#URL_SITE">#NOM_SITE</a>
 177  *              </code>
 178  *
 179  * @param Champ $p
 180  *              Pile au niveau de la balise
 181  * @return Champ
 182  *              Pile complétée par le code à générer
 183 **/
 184 function balise_NOM_SITE_dist($p) {
 185         if (!$p->etoile) {
 186                 $p->code = "supprimer_numero(calculer_url(" .
 187                 champ_sql('url_site',$p) ."," .
 188                 champ_sql('nom_site',$p) .
 189                 ", 'titre', \$connect, false))";
 190         } else
 191                 $p->code = champ_sql('nom_site',$p);
 192
 193         $p->interdire_scripts = true;
 194         return $p;
 195 }
 196
 197 // http://doc.spip.org/@balise_NOTES_dist
 198 function balise_NOTES_dist($p) {
 199         // Recuperer les notes
 200         $p->code = 'calculer_notes()';
 201         #$p->interdire_scripts = true;
 202         return $p;
 203 }
 204
 205 // http://doc.spip.org/@balise_RECHERCHE_dist
 206 function balise_RECHERCHE_dist($p) {
 207         $p->code = 'entites_html(_request("recherche"))';
 208         $p->interdire_scripts = false;
 209         return $p;
 210 }
 211
 212 // http://doc.spip.org/@balise_COMPTEUR_BOUCLE_dist
 213 function balise_COMPTEUR_BOUCLE_dist($p) {
 214         $b = $p->nom_boucle ? $p->nom_boucle : $p->descr['id_mere'];
 215         if ($b === '') {
 216                 $msg = array('zbug_champ_hors_boucle',
 217                                 array('champ' => '#COMPTEUR_BOUCLE')
 218                           );
 219                 erreur_squelette($msg, $p);
 220         } else {
 221                 $p->code = "\$Numrows['$b']['compteur_boucle']";
 222                 $p->boucles[$b]->cptrows = true;
 223                 $p->interdire_scripts = false;
 224                 return $p;
 225         }
 226 }
 227
 228 // http://doc.spip.org/@balise_TOTAL_BOUCLE_dist
 229 function balise_TOTAL_BOUCLE_dist($p) {
 230         $b = $p->nom_boucle ? $p->nom_boucle : $p->descr['id_mere'];
 231         if ($b === '' || !isset($p->boucles[$b])) {
 232                 $msg = array('zbug_champ_hors_boucle',
 233                                 array('champ' => "#$b" . 'TOTAL_BOUCLE')
 234                           );
 235                 erreur_squelette($msg, $p);
 236         } else {
 237                 $p->code = "\$Numrows['$b']['total']";
 238                 $p->boucles[$b]->numrows = true;
 239                 $p->interdire_scripts = false;
 240         }
 241         return $p;
 242 }
 243
 244 // Si on est hors d'une boucle {recherche}, ne pas "prendre" cette balise
 245 // http://doc.spip.org/@balise_POINTS_dist
 246 function balise_POINTS_dist($p) {
 247         return rindex_pile($p, 'points', 'recherche');
 248 }
 249
 250 // http://doc.spip.org/@balise_POPULARITE_ABSOLUE_dist
 251 function balise_POPULARITE_ABSOLUE_dist($p) {
 252         $p->code = 'ceil(' .
 253         champ_sql('popularite', $p) .
 254         ')';
 255         $p->interdire_scripts = false;
 256         return $p;
 257 }
 258
 259 // http://doc.spip.org/@balise_POPULARITE_SITE_dist
 260 function balise_POPULARITE_SITE_dist($p) {
 261         $p->code = 'ceil($GLOBALS["meta"][\'popularite_total\'])';
 262         $p->interdire_scripts = false;
 263         return $p;
 264 }
 265
 266 // http://doc.spip.org/@balise_POPULARITE_MAX_dist
 267 function balise_POPULARITE_MAX_dist($p) {
 268         $p->code = 'ceil($GLOBALS["meta"][\'popularite_max\'])';
 269         $p->interdire_scripts = false;
 270         return $p;
 271 }
 272
 273 // http://doc.spip.org/@balise_EXPOSE_dist
 274 function balise_EXPOSE_dist($p) {
 275         $on = "'on'";
 276         $off= "''";
 277         if (($v = interprete_argument_balise(1,$p))!==NULL){
 278                 $on = $v;
 279                 if (($v = interprete_argument_balise(2,$p))!==NULL)
 280                         $off = $v;
 281
 282         }
 283         return calculer_balise_expose($p, $on, $off);
 284 }
 285
 286 // #VALEUR renvoie le champ valeur
 287 // #VALEUR{x} renvoie #VALEUR|table_valeur{x}
 288 // #VALEUR{a/b} renvoie #VALEUR|table_valeur{a/b}
 289 // http://doc.spip.org/@balise_VALEUR_dist
 290 function balise_VALEUR_dist($p) {
 291         $b = $p->nom_boucle ? $p->nom_boucle : $p->id_boucle;
 292         $p->code = index_pile($p->id_boucle, 'valeur', $p->boucles, $b);;
 293         if (($v = interprete_argument_balise(1,$p))!==NULL){
 294                 $p->code = 'table_valeur('.$p->code.', '.$v.')';
 295         }
 296         $p->interdire_scripts = true;
 297         return $p;
 298 }
 299
 300 // http://doc.spip.org/@calculer_balise_expose
 301 function calculer_balise_expose($p, $on, $off)
 302 {
 303         $b = $p->nom_boucle ? $p->nom_boucle : $p->id_boucle;
 304         $key = $p->boucles[$b]->primary;
 305         $type = $p->boucles[$p->id_boucle]->primary;
 306         $desc = $p->boucles[$b]->show;
 307         $connect = sql_quote($p->boucles[$b]->sql_serveur);
 308
 309         if (!$key) {
 310                 $msg = array('zbug_champ_hors_boucle', array('champ' => '#EXPOSER'));
 311                 erreur_squelette($msg, $p);
 312         }
 313
 314         // Ne pas utiliser champ_sql, on jongle avec le nom boucle explicite
 315         $c = index_pile($p->id_boucle, $type, $p->boucles);
 316
 317         if (isset($desc['field']['id_parent'])) {
 318                 $parent = 0; // pour if (!$parent) dans calculer_expose
 319         } elseif (isset($desc['field']['id_rubrique'])) {
 320                 $parent = index_pile($p->id_boucle, 'id_rubrique', $p->boucles, $b);
 321         } elseif  (isset($desc['field']['id_groupe'])) {
 322                 $parent = index_pile($p->id_boucle, 'id_groupe', $p->boucles, $b);
 323         } else $parent = "''";
 324
 325         $p->code = "(calcul_exposer($c, '$type', \$Pile[0], $parent, '$key', $connect) ? $on : $off)";
 326
 327         $p->interdire_scripts = false;
 328         return $p;
 329 }
 330
 331
 332 // Debut et fin de surlignage auto des mots de la recherche
 333 // on insere une balise Span avec une classe sans spec:
 334 // c'est transparent s'il n'y a pas de recherche,
 335 // sinon elles seront remplacees par les fontions de inc_surligne
 336
 337 // http://doc.spip.org/@balise_DEBUT_SURLIGNE_dist
 338 function balise_DEBUT_SURLIGNE_dist($p) {
 339         include_spip('inc/surligne');
 340         $p->code = "'<!-- " . MARQUEUR_SURLIGNE . " -->'";
 341         return $p;
 342 }
 343 // http://doc.spip.org/@balise_FIN_SURLIGNE_dist
 344 function balise_FIN_SURLIGNE_dist($p) {
 345         include_spip('inc/surligne');
 346         $p->code = "'<!-- " . MARQUEUR_FSURLIGNE . "-->'";
 347         return $p;
 348 }
 349
 350
 351 // #INTRODUCTION
 352 // #INTRODUCTION{longueur}
 353 // http://www.spip.net/@introduction
 354 // http://doc.spip.org/@balise_INTRODUCTION_dist
 355 function balise_INTRODUCTION_dist($p) {
 356
 357         $type = $p->type_requete;
 358
 359         $_texte = champ_sql('texte', $p);
 360         $_descriptif = ($type == 'articles' OR $type == 'rubriques') ? champ_sql('descriptif', $p) : "''";
 361
 362         if ($type == 'articles') {
 363                 $_chapo = champ_sql('chapo', $p);
 364                 $_texte = "(strlen($_descriptif))
 365                 ? ''
 366                 : $_chapo . \"\\n\\n\" . $_texte";
 367         }
 368
 369         // longueur en parametre, ou valeur par defaut
 370         if (($v = interprete_argument_balise(1,$p))!==NULL) {
 371                 $longueur = 'intval('.$v.')';
 372         } else {
 373                 switch ($type) {
 374                         case 'articles':
 375                                 $longueur = '500';
 376                                 break;
 377                         case 'breves':
 378                                 $longueur = '300';
 379                                 break;
 380                         case 'rubriques':
 381                         default:
 382                                 $longueur = '600';
 383                                 break;
 384                 }
 385         }
 386
 387         $f = chercher_filtre('introduction');
 388         $p->code = "$f($_descriptif, $_texte, $longueur, \$connect)";
 389
 390         #$p->interdire_scripts = true;
 391         $p->etoile = '*'; // propre est deja fait dans le calcul de l'intro
 392         return $p;
 393 }
 394
 395
 396 // #LANG
 397 // affiche la langue de l'objet (ou superieure), et a defaut la langue courante
 398 // (celle du site ou celle qui a ete passee dans l'URL par le visiteur)
 399 // #LANG* n'affiche rien si aucune langue n'est trouvee dans le sql/le contexte
 400 // http://doc.spip.org/@balise_LANG_dist
 401 function balise_LANG_dist ($p) {
 402         $_lang = champ_sql('lang', $p);
 403         if (!$p->etoile)
 404                 $p->code = "spip_htmlentities($_lang ? $_lang : \$GLOBALS['spip_lang'])";
 405         else
 406                 $p->code = "spip_htmlentities($_lang)";
 407         $p->interdire_scripts = false;
 408         return $p;
 409 }
 410
 411 // #LESAUTEURS
 412 // les auteurs d'un objet
 413 // http://www.spip.net/fr_article902.html
 414 // http://www.spip.net/fr_article911.html
 415 // http://doc.spip.org/@balise_LESAUTEURS_dist
 416 function balise_LESAUTEURS_dist ($p) {
 417         // Cherche le champ 'lesauteurs' dans la pile
 418         $_lesauteurs = champ_sql('lesauteurs', $p, false);
 419
 420         // Si le champ n'existe pas (cas de spip_articles), on applique
 421         // le modele lesauteurs.html en passant id_article dans le contexte;
 422         // dans le cas contraire on prend le champ 'lesauteurs'
 423         // (cf extension sites/)
 424         if ($_lesauteurs
 425         AND $_lesauteurs != '@$Pile[0][\'lesauteurs\']') {
 426                 $p->code = "safehtml($_lesauteurs)";
 427                 // $p->interdire_scripts = true;
 428         } else {
 429                 if(!$p->id_boucle){
 430                         $connect = '';
 431                         $objet = 'article';
 432                         $id_table_objet = 'id_article';
 433                 }
 434                 else{
 435                         $b = $p->nom_boucle ? $p->nom_boucle : $p->id_boucle;
 436                         $connect = $p->boucles[$b]->sql_serveur;
 437                         $type_boucle = $p->boucles[$b]->type_requete;
 438                         $objet = objet_type($type_boucle);
 439                         $id_table_objet = id_table_objet($type_boucle);
 440                 }
 441                 $c = memoriser_contexte_compil($p);
 442
 443                 $p->code = sprintf(CODE_RECUPERER_FOND, "'modeles/lesauteurs'",
 444                                    "array('objet'=>'".$objet.
 445                                            "','id_objet' => ".champ_sql($id_table_objet, $p) .
 446                                            ",'$id_table_objet' => ".champ_sql($id_table_objet, $p) .
 447                                            ($objet=='article'?"":",'id_article' => ".champ_sql('id_article', $p)).
 448                                            ")",
 449                                    "'trim'=>true, 'compil'=>array($c)",
 450                                    _q($connect));
 451                 $p->interdire_scripts = false; // securite apposee par recuperer_fond()
 452         }
 453
 454         return $p;
 455 }
 456
 457
 458 /**
 459  * #RANG
 460  * affiche le "numero de l'objet" quand on l'a titre '1. Premier article';
 461  * ceci est transitoire afin de preparer une migration vers un vrai systeme de
 462  * tri des articles dans une rubrique (et plus si affinites)
 463  * la balise permet d'extraire le numero masque par |supprimer_numero
 464  * la balise recupere le champ declare dans la globale table_titre
 465  * ou a defaut le champ 'titre'
 466  *
 467  * si un champ rang existe, il est pris en priorite
 468  *
 469  * http://doc.spip.org/@balise_RANG_dist
 470  *
 471  * @param object $p
 472  * @return object
 473  */
 474 function balise_RANG_dist($p) {
 475         $b = index_boucle($p);
 476         if ($b === '') {
 477                 $msg = array('zbug_champ_hors_boucle',
 478                                 array('champ' => '#RANG')
 479                           );
 480                 erreur_squelette($msg, $p);
 481         }
 482         else {
 483                 // chercher d'abord un champ sql rang (mais pas dans le env : defaut '' si on trouve pas de champ sql)
 484                 // dans la boucle immediatement englobante uniquement
 485                 // sinon on compose le champ calcule
 486                 $_rang = champ_sql('rang', $p, '', false);
 487
 488                 // si pas trouve de champ sql rang :
 489                 if (!$_rang){
 490                         $boucle = &$p->boucles[$b];
 491                         $trouver_table = charger_fonction('trouver_table','base');
 492                         $desc = $trouver_table($boucle->id_table);
 493                         $_titre = ''; # champ dont on extrait le numero
 494                         if (isset($desc['titre'])){
 495                                 $t=$desc['titre'];
 496                           if (preg_match(';(^|,)([^,]*titre)(,|$);',$t,$m)){
 497                                   $m = preg_replace(",as\s+titre$,i","",$m[2]);
 498                                   $m = trim($m);
 499                                   if ($m!="''"){
 500                                           if (!preg_match(",\W,",$m))
 501                                                   $m = $boucle->id_table . ".$m";
 502                                           $m .= " AS titre_rang";
 503
 504                                           $boucle->select[] = $m;
 505                                           $_titre = '$Pile[$SP][\'titre_rang\']';
 506                                   }
 507                           }
 508                         }
 509                         if (!$_titre)
 510                                 $_titre = champ_sql('titre', $p);
 511                         $_rang = "recuperer_numero($_titre)";
 512                 }
 513                 $p->code = $_rang;
 514                 $p->interdire_scripts = false;
 515         }
 516         return $p;
 517 }
 518
 519
 520 // #POPULARITE
 521 // http://www.spip.net/fr_article1846.html
 522 // http://doc.spip.org/@balise_POPULARITE_dist
 523 function balise_POPULARITE_dist ($p) {
 524         $_popularite = champ_sql('popularite', $p);
 525         $p->code = "(ceil(min(100, 100 * $_popularite
 526         / max(1 , 0 + \$GLOBALS['meta']['popularite_max']))))";
 527         $p->interdire_scripts = false;
 528         return $p;
 529 }
 530
 531 // #PAGINATION
 532 // Le code produit est trompeur, car les modeles ne fournissent pas Pile[0].
 533 // On produit un appel a _request si on ne l'a pas, mais c'est inexact:
 534 // l'absence peut etre due a une faute de frappe dans le contexte inclus.
 535
 536 define('CODE_PAGINATION',
 537         '%s($Numrows["%s"]["grand_total"],
 538                 %s,
 539                 isset($Pile[0][%4$s])?$Pile[0][%4$s]:intval(_request(%4$s)),
 540                 %5$s, %6$s, %7$s, %8$s, array(%9$s))');
 541
 542 // http://www.spip.net/fr_article3367.html
 543 // http://doc.spip.org/@balise_PAGINATION_dist
 544 function balise_PAGINATION_dist($p, $liste='true') {
 545         $b = $p->nom_boucle ? $p->nom_boucle : $p->descr['id_mere'];
 546
 547         // s'il n'y a pas de nom de boucle, on ne peut pas paginer
 548         if ($b === '') {
 549                 $msg = array('zbug_champ_hors_boucle',
 550                         array('champ' => $liste ? 'PAGINATION' : 'ANCRE_PAGINATION')
 551                           );
 552                 erreur_squelette($msg, $p);
 553                 return $p;
 554         }
 555
 556         // s'il n'y a pas de mode_partie, c'est qu'on se trouve
 557         // dans un boucle recursive ou qu'on a oublie le critere {pagination}
 558         if (!$p->boucles[$b]->mode_partie) {
 559                 if (!$p->boucles[$b]->table_optionnelle) {
 560                         $msg = array('zbug_pagination_sans_critere',
 561                                         array('champ' => '#PAGINATION')
 562                                   );
 563                         erreur_squelette($msg, $p);
 564                 }
 565                 return $p;
 566         }
 567
 568         // a priori true
 569         // si false, le compilo va bloquer sur des syntaxes avec un filtre sans argument qui suit la balise
 570         // si true, les arguments simples (sans truc=chose) vont degager
 571         $_contexte = argumenter_inclure($p->param, true, $p, $p->boucles, $p->id_boucle, false, false);
 572         if (count($_contexte)){
 573                 list($key,$val) = each($_contexte);
 574                 if (is_numeric($key)){
 575                         array_shift($_contexte);
 576                         $__modele = interprete_argument_balise(1,$p);
 577                 }
 578         }
 579
 580         if (count($_contexte)){
 581                 $code_contexte = implode(',',$_contexte);
 582         }
 583         else
 584                 $code_contexte = '';
 585
 586         $connect = $p->boucles[$b]->sql_serveur;
 587         $pas = $p->boucles[$b]->total_parties;
 588         $f_pagination = chercher_filtre('pagination');
 589         $type = $p->boucles[$b]->modificateur['debut_nom'];
 590         $modif = ($type[0]!=="'") ? "'debut'.$type"
 591           : ("'debut" .substr($type,1));
 592
 593         $p->code = sprintf(CODE_PAGINATION, $f_pagination, $b, $type, $modif, $pas, $liste, ((isset($__modele) and $__modele) ? $__modele : "''"), _q($connect), $code_contexte);
 594
 595         $p->boucles[$b]->numrows = true;
 596         $p->interdire_scripts = false;
 597         return $p;
 598 }
 599
 600
 601 // N'afficher que l'ancre de la pagination (au-dessus, par exemple, alors
 602 // qu'on mettra les liens en-dessous de la liste paginee)
 603 // http://doc.spip.org/@balise_ANCRE_PAGINATION_dist
 604 function balise_ANCRE_PAGINATION_dist($p) {
 605         if ($f = charger_fonction('PAGINATION', 'balise', true))
 606                 return $f($p, $liste='false');
 607         else return NULL; // ou une erreur ?
 608 }
 609
 610 // equivalent a #TOTAL_BOUCLE sauf pour les boucles paginees, ou elle
 611 // indique le nombre total d'articles repondant aux criteres hors pagination
 612 // http://doc.spip.org/@balise_GRAND_TOTAL_dist
 613 function balise_GRAND_TOTAL_dist($p) {
 614         $b = $p->nom_boucle ? $p->nom_boucle : $p->descr['id_mere'];
 615         if ($b === '' || !isset($p->boucles[$b])) {
 616                 $msg = array('zbug_champ_hors_boucle',
 617                                 array('champ' => "#$b" . 'TOTAL_BOUCLE')
 618                            );
 619                 erreur_squelette($msg, $p);
 620         } else {
 621                 $p->code = "(isset(\$Numrows['$b']['grand_total'])
 622                         ? \$Numrows['$b']['grand_total'] : \$Numrows['$b']['total'])";
 623                 $p->boucles[$b]->numrows = true;
 624                 $p->interdire_scripts = false;
 625         }
 626         return $p;
 627 }
 628
 629 // Reference a l'URL de la page courante
 630 // Attention dans un INCLURE() ou une balise dynamique on n'a pas le droit de
 631 // mettre en cache #SELF car il peut correspondre a une autre page (attaque XSS)
 632 // (Dans ce cas faire <INCLURE{self=#SELF}> pour differencier les caches.)
 633 // http://www.spip.net/@self
 634 // http://doc.spip.org/@balise_SELF_dist
 635 function balise_SELF_dist($p) {
 636         $p->code = 'self()';
 637         $p->interdire_scripts = false;
 638         return $p;
 639 }
 640
 641 //
 642 // #CHEMIN{fichier} -> find_in_path(fichier)
 643 //
 644 // http://doc.spip.org/@balise_CHEMIN_dist
 645 function balise_CHEMIN_dist($p) {
 646         $arg = interprete_argument_balise(1,$p);
 647         if (!$arg) {
 648                 $msg = array('zbug_balise_sans_argument',       array('balise' => ' CHEMIN'));
 649                 erreur_squelette($msg, $p);
 650         } else
 651           $p->code = 'find_in_path(' . $arg .')';
 652
 653         #$p->interdire_scripts = true;
 654         return $p;
 655 }
 656
 657 function balise_CHEMIN_IMAGE_dist($p) {
 658         $arg = interprete_argument_balise(1,$p);
 659         if (!$arg) {
 660                 $msg = array('zbug_balise_sans_argument', array('balise' => ' CHEMIN_IMAGE'));
 661                 erreur_squelette($msg, $p);
 662         } else $p->code = 'chemin_image(' . $arg .')';
 663
 664         #$p->interdire_scripts = true;
 665         return $p;
 666 }
 667
 668
 669 /**
 670  * La balise #ENV permet de recuperer
 671  * le contexte d'environnement transmis au calcul d'un squelette,
 672  * par exemple #ENV{id_rubrique}
 673  *
 674  * La syntaxe #ENV{toto, valeur par defaut}
 675  * renverra 'valeur par defaut' si $toto est vide
 676  *
 677  * La recherche de la cle s'appuyant sur la fonction table_valeur
 678  * il est possible de demander un sous element d'un tableau
 679  * #ENV{toto/sous/element, valeur par defaut} retournera l'equivalent de
 680  * #ENV{toto}|table_valeur{sous/element} c'est a dire en quelque sorte
 681  * $env['toto']['sous']['element'] s'il existe, sinon la valeur par defaut.
 682  *
 683  * Si le tableau est vide on renvoie '' (utile pour #SESSION)
 684  *
 685  * Enfin, la balise utilisee seule #ENV retourne le tableau complet
 686  * de l'environnement. A noter que ce tableau est retourne serialise.
 687  *
 688  *
 689  * En standard est applique |entites_html, mais si l'etoile est
 690  * utilisee pour desactiver les filtres par defaut, par exemple avec
 691  * [(#ENV*{toto})] , il *faut* s'assurer de la securite
 692  * anti-javascript, par exemple en filtrant avec |safehtml : [(#ENV*{toto}|safehtml)]
 693  *
 694  *
 695  * @param Champ $p
 696  *              Pile ; arbre de syntaxe abstrait positionne au niveau de la balise.
 697  *
 698  * @param array $src
 699  *              Tableau dans lequel chercher la cle demandee en parametre de la balise.
 700  *              Par defaut prend dans le contexte du squelette.
 701  *
 702  * @return Champ $p
 703  *              Pile completee du code PHP d'execution de la balise
 704 **/
 705 function balise_ENV_dist($p, $src = NULL) {
 706
 707         // cle du tableau desiree
 708         $_nom = interprete_argument_balise(1,$p);
 709         // valeur par defaut
 710         $_sinon = interprete_argument_balise(2,$p);
 711
 712         // $src est un tableau de donnees sources eventuellement transmis
 713         // en absence, on utilise l'environnement du squelette $Pile[0]
 714
 715         if (!$_nom) {
 716                 // cas de #ENV sans argument : on retourne le serialize() du tableau
 717                 // une belle fonction [(#ENV|affiche_env)] serait pratique
 718                 if ($src) {
 719                         $p->code = '(is_array($a = ('.$src.')) ? serialize($a) : "")';
 720                 } else {
 721                         $p->code = '@serialize($Pile[0])';
 722                 }
 723         } else {
 724                 if (!$src) {
 725                         $src = '@$Pile[0]';
 726                 }
 727                 if ($_sinon) {
 728                         $p->code = "sinon(table_valeur($src, (string)$_nom, null), $_sinon)";
 729                 } else {
 730                         $p->code = "table_valeur($src, (string)$_nom, null)";
 731                 }
 732         }
 733         #$p->interdire_scripts = true;
 734
 735         return $p;
 736 }
 737
 738 /**
 739  * #CONFIG retourne lire_config()
 740  * les reglages du site
 741  *
 742  * Par exemple #CONFIG{gerer_trad} donne 'oui' ou 'non' selon le reglage
 743  * Le 3eme argument permet de controler la serialisation du resultat
 744  * (mais ne sert que pour le depot 'meta') qui doit parfois deserialiser
 745  *
 746  * ex: |in_array{#CONFIG{toto,#ARRAY,1}}.
 747  *
 748  * Ceci n'affecte pas d'autres depots et |in_array{#CONFIG{toto/,#ARRAY}} sera equivalent
 749  * #CONFIG{/tablemeta/champ,defaut} lit la valeur de 'champ' dans la table des meta 'tablemeta'
 750  *
 751  * @param  Object $p  Arbre syntaxique du compilo
 752  * @return Object
 753  */
 754 function balise_CONFIG_dist($p) {
 755         if (!$arg = interprete_argument_balise(1,$p)) {
 756                 $arg = "''";
 757         }
 758         $_sinon = interprete_argument_balise(2,$p);
 759         $_unserialize = sinon(interprete_argument_balise(3,$p),"false");
 760
 761         $p->code = '(include_spip(\'inc/config\')?lire_config(' . $arg . ',' .
 762                 ($_sinon && $_sinon != "''" ? $_sinon : 'null') . ',' . $_unserialize . "):'')";
 763
 764         return $p;
 765 }
 766
 767
 768 // http://doc.spip.org/@balise_CONNECT_dist
 769 function balise_CONNECT_dist($p) {
 770         $p->code = '($connect ? $connect : NULL)';
 771         $p->interdire_scripts = false;
 772         return $p;
 773 }
 774
 775 //
 776 // #SESSION
 777 // Cette balise est un tableau des donnees du visiteur (nom, email etc)
 778 // Si elle est invoquee, elle leve un drapeau dans le fichier cache, qui
 779 // permet a public/cacher d'invalider le cache si le visiteur suivant n'a
 780 // pas la meme session
 781 // http://doc.spip.org/@balise_SESSION_dist
 782 function balise_SESSION_dist($p) {
 783         $p->descr['session'] = true;
 784
 785         $f = function_exists('balise_ENV')
 786                 ? 'balise_ENV'
 787                 : 'balise_ENV_dist';
 788
 789         $p = $f($p, '$GLOBALS["visiteur_session"]');
 790         return $p;
 791 }
 792
 793 //
 794 // #SESSION_SET{x,y}
 795 // Ajoute x=y dans la session du visiteur
 796 // http://doc.spip.org/@balise_SESSION_SET_dist
 797 function balise_SESSION_SET_dist($p) {
 798         $_nom = interprete_argument_balise(1,$p);
 799         $_val = interprete_argument_balise(2,$p);
 800         if (!$_nom OR !$_val) {
 801                 $err_b_s_a = array('zbug_balise_sans_argument', array('balise' => 'SESSION_SET'));
 802                 erreur_squelette($err_b_s_a, $p);
 803         } else  $p->code = '(include_spip("inc/session") AND session_set('.$_nom.','.$_val.'))';
 804
 805         $p->interdire_scripts = false;
 806
 807         return $p;
 808 }
 809
 810
 811
 812
 813 //
 814 // #EVAL{...}
 815 // evalue un code php ; a utiliser avec precaution :-)
 816 //
 817 // rq: #EVAL{code} produit eval('return code;')
 818 // mais si le code est une expression sans balise, on se dispense
 819 // de passer par une construction si compliquee, et le code est
 820 // passe tel quel (entre parentheses, et protege par interdire_scripts)
 821 // Exemples : #EVAL**{6+9} #EVAL**{_DIR_IMG_PACK} #EVAL{'date("Y-m-d")'}
 822 // #EVAL{'str_replace("r","z", "roger")'}  (attention les "'" sont interdits)
 823 // http://doc.spip.org/@balise_EVAL_dist
 824 function balise_EVAL_dist($p) {
 825         $php = interprete_argument_balise(1,$p);
 826         if ($php) {
 827                 # optimisation sur les #EVAL{une expression sans #BALISE}
 828                 # attention au commentaire "// x signes" qui precede
 829                 if (preg_match(",^([[:space:]]*//[^\n]*\n)'([^']+)'$,ms",
 830                 $php,$r))
 831                         $p->code = /* $r[1]. */'('.$r[2].')';
 832                 else
 833                         $p->code = "eval('return '.$php.';')";
 834         } else {
 835                 $msg = array('zbug_balise_sans_argument', array('balise' => ' EVAL'));
 836                 erreur_squelette($msg, $p);
 837         }
 838
 839         #$p->interdire_scripts = true;
 840
 841         return $p;
 842 }
 843
 844 // #CHAMP_SQL{x} renvoie la valeur du champ sql 'x'
 845 // permet de recuperer par exemple un champ notes dans une table sql externe
 846 // (impossible via #NOTES qui est une balise calculee)
 847 // ne permet pas de passer une expression pour x qui ne peut etre qu'un texte statique !
 848 // http://doc.spip.org/@balise_CHAMP_SQL_dist
 849 function balise_CHAMP_SQL_dist($p){
 850
 851         if ($p->param
 852         AND isset($p->param[0][1][0])
 853         AND $champ = ($p->param[0][1][0]->texte))
 854                 $p->code = champ_sql($champ, $p);
 855         else {
 856                 $err_b_s_a = array('zbug_balise_sans_argument', array('balise' => ' URL_'));
 857                 erreur_squelette($err_b_s_a, $p);
 858         }
 859         #$p->interdire_scripts = true;
 860         return $p;
 861 }
 862
 863 // #VAL{x} renvoie 'x' (permet d'appliquer un filtre a une chaine)
 864 // Attention #VAL{1,2} renvoie '1', indiquer #VAL{'1,2'}
 865 // http://doc.spip.org/@balise_VAL_dist
 866 function balise_VAL_dist($p){
 867         $p->code = interprete_argument_balise(1,$p);
 868         if (!strlen($p->code))
 869                 $p->code = "''";
 870         $p->interdire_scripts = false;
 871         return $p;
 872 }
 873 // #NOOP est un alias pour regler #948, ne pas documenter
 874 // http://doc.spip.org/@balise_NOOP_dist
 875 function balise_NOOP_dist($p) { return balise_VAL_dist($p); }
 876
 877 //
 878 // #REM
 879 // pour les remarques : renvoie toujours ''
 880 //
 881 // http://doc.spip.org/@balise_REM_dist
 882 function balise_REM_dist($p) {
 883         $p->code="''";
 884         $p->interdire_scripts = false;
 885         return $p;
 886 }
 887
 888
 889 //
 890 // #HTTP_HEADER
 891 // pour les entetes de retour http
 892 // Ne fonctionne pas sur les INCLURE !
 893 // #HTTP_HEADER{Content-Type: text/css}
 894 //
 895 // http://doc.spip.org/@balise_HTTP_HEADER_dist
 896 function balise_HTTP_HEADER_dist($p) {
 897
 898         $header = interprete_argument_balise(1,$p);
 899         if (!$header) {
 900                 $err_b_s_a = array('zbug_balise_sans_argument', array('balise' => 'HTTP_HEADER'));
 901                 erreur_squelette($err_b_s_a, $p);
 902         } else  $p->code = "'<'.'?php header(\"' . "
 903                 . $header
 904                 . " . '\"); ?'.'>'";
 905         $p->interdire_scripts = false;
 906         return $p;
 907 }
 908
 909 // Filtre a appliquer a l'ensemble de la page une fois calculee
 910 // (filtrage fait au niveau du squelette, et sans s'appliquer aux <INCLURE>)
 911 // http://doc.spip.org/@balise_FILTRE_dist
 912 function balise_FILTRE_dist($p) {
 913         if ($p->param) {
 914                 $args = array();
 915                 foreach ($p->param as $i => $ignore)
 916                         $args[] = interprete_argument_balise($i+1,$p);
 917                 $p->code = "'<' . '"
 918                         .'?php header("X-Spip-Filtre: \'.'
 919                                 .join('.\'|\'.', $args)
 920                         . " . '\"); ?'.'>'";
 921
 922                 $p->interdire_scripts = false;
 923                 return $p;
 924         }
 925 }
 926
 927 //
 928 // #CACHE
 929 // definit la duree de vie ($delais) du squelette
 930 // #CACHE{24*3600}
 931 // parametre(s) supplementaire(s) :
 932 // #CACHE{24*3600, cache-client} autorise gestion du IF_MODIFIED_SINCE
 933 // #CACHE{24*3600, statique} ne respecte pas l'invalidation par modif de la base
 934 //  (mais s'invalide tout de meme a l'expiration du delai)
 935 //  par defaut cache-client => statique
 936 //  cf. ecrire/public/cacher.php
 937 // http://doc.spip.org/@balise_CACHE_dist
 938 function balise_CACHE_dist($p) {
 939
 940         if ($p->param) {
 941                 $duree = valeur_numerique($p->param[0][1][0]->texte);
 942
 943                 // noter la duree du cache dans un entete proprietaire
 944
 945                 $code = '\'<'.'?php header("X-Spip-Cache: '
 946                 . $duree
 947                 . '"); ?'.'>\'';
 948
 949                 // Remplir le header Cache-Control
 950                 // cas #CACHE{0}
 951                 if ($duree == 0)
 952                         $code .= '.\'<'
 953                         .'?php header("Cache-Control: no-cache, must-revalidate"); ?'
 954                         .'><'
 955                         .'?php header("Pragma: no-cache"); ?'
 956                         .'>\'';
 957
 958                 // recuperer les parametres suivants
 959                 $i = 1;
 960                 while (isset($p->param[0][++$i])) {
 961                         $pa = ($p->param[0][$i][0]->texte);
 962
 963                         if ($pa == 'cache-client'
 964                         AND $duree > 0) {
 965                                 $code .= '.\'<'.'?php header("Cache-Control: max-age='
 966                                 . $duree
 967                                 . '"); ?'.'>\'';
 968                         // il semble logique, si on cache-client, de ne pas invalider
 969                                 $pa = 'statique';
 970                         }
 971
 972                         if ($pa == 'statique'
 973                         AND $duree > 0)
 974                                 $code .= '.\'<'.'?php header("X-Spip-Statique: oui"); ?'.'>\'';
 975                 }
 976         } else $code = "''";
 977         $p->code = $code;
 978         $p->interdire_scripts = false;
 979         return $p;
 980 }
 981
 982
 983 /**
 984  * #INSERT_HEAD
 985  * pour permettre aux plugins d'inserer des styles, js ou autre
 986  * dans l'entete sans modification du squelette
 987  * les css doivent etre inserees de preference par #INSERT_HEAD_CSS
 988  * pour en faciliter la surcharge
 989  *
 990  * on insere ici aussi un morceau de PHP qui verifiera a l'execution que le pipeline insert_head_css a bien ete vu
 991  * et dans le cas contraire l'appelera. Permet de ne pas oublier les css de #INSERT_HEAD_CSS meme si cette balise
 992  * n'est pas presente.
 993  * Il faut mettre ce php avant le insert_head car le compresseur y mets ensuite un php du meme type pour collecter
 994  * CSS et JS, et on ne veut pas qu'il rate les css inserees en fallback par insert_head_css_conditionnel
 995  *
 996  * http://doc.spip.org/@balise_INSERT_HEAD_dist
 997  *
 998  * @param object $p
 999  * @return object
1000  */
1001 function balise_INSERT_HEAD_dist($p) {
1002         $p->code = '\'<'
1003                 .'?php header("X-Spip-Filtre: \'.'
1004                         .'\'insert_head_css_conditionnel\''
1005                 . " . '\"); ?'.'>'";
1006         $p->code .= ". pipeline('insert_head','<!-- insert_head -->')";
1007         $p->interdire_scripts = false;
1008         return $p;
1009 }
1010
1011 /**
1012  * homologue de #INSERT_HEAD pour les CSS
1013  * (et par extension pour le js inline qui doit preferentiellement etre insere avant les CSS car bloquant sinon)
1014  *
1015  * http://doc.spip.org/@balise_INSERT_HEAD_CSS_dist
1016  *
1017  * @param object $p
1018  * @return object
1019  */
1020 function balise_INSERT_HEAD_CSS_dist($p) {
1021         $p->code = "pipeline('insert_head_css','<!-- insert_head_css -->')";
1022         $p->interdire_scripts = false;
1023         return $p;
1024 }
1025 //
1026 // #INCLURE statique
1027 // l'inclusion est realisee au calcul du squelette, pas au service
1028 // ainsi le produit du squelette peut etre utilise en entree de filtres a suivre
1029 // on peut faire un #INCLURE{fichier} sans squelette
1030 // (Incompatible avec les balises dynamiques)
1031 // http://doc.spip.org/@balise_INCLUDE_dist
1032 function balise_INCLUDE_dist($p) {
1033         if(function_exists('balise_INCLURE'))
1034                 return balise_INCLURE($p);
1035         else
1036                 return balise_INCLURE_dist($p);
1037 }
1038 // http://doc.spip.org/@balise_INCLURE_dist
1039 function balise_INCLURE_dist($p) {
1040         $id_boucle = $p->id_boucle;
1041         // la lang n'est pas passe de facon automatique par argumenter
1042         // mais le sera pas recuperer_fond, sauf si etoile=>true est passe
1043         // en option
1044
1045         $_contexte = argumenter_inclure($p->param, true, $p, $p->boucles, $id_boucle, false, false);
1046
1047         // erreur de syntaxe = fond absent
1048         // (2 messages d'erreur SPIP pour le prix d'un, mais pas d'erreur PHP
1049         if (!$_contexte) $contexte = array();
1050
1051         if (isset($_contexte['fond'])) {
1052
1053                 $f = $_contexte['fond'];
1054                 // toujours vrai :
1055                 if (preg_match('/^.fond.\s*=>(.*)$/s', $f, $r)) {
1056                         $f = $r[1];
1057                         unset($_contexte['fond']);
1058                 } else spip_log("compilation de #INCLURE a revoir");
1059
1060                 // #INCLURE{doublons}
1061                 if (isset($_contexte['doublons'])) {
1062                         $_contexte['doublons'] = "'doublons' => \$doublons";
1063                 }
1064
1065                 // Critere d'inclusion {env} (et {self} pour compatibilite ascendante)
1066                 if (isset($_contexte['env'])
1067                 || isset($_contexte['self'])
1068                 ) {
1069                         $flag_env = true;
1070                         unset($_contexte['env']);
1071                 } else $flag_env = false;
1072
1073                 $_options = array();
1074                 if (isset($_contexte['ajax'])) {
1075                         $_options[] = preg_replace(",=>(.*)$,ims",'=> ($v=(\\1))?$v:true',$_contexte['ajax']);
1076                         unset($_contexte['ajax']);
1077                 }
1078                 if ($p->etoile) $_options[] = "'etoile'=>true";
1079                 $_options[] = "'compil'=>array(" . memoriser_contexte_compil($p) .")";
1080
1081                 $_l = 'array(' . join(",\n\t", $_contexte) .')';
1082                 if ($flag_env) $_l = "array_merge(\$Pile[0],$_l)";
1083
1084                 $p->code = sprintf(CODE_RECUPERER_FOND, $f, $_l, join(',',$_options),"''");
1085
1086         } elseif (!isset($_contexte[1])) {
1087                         $msg = array('zbug_balise_sans_argument', array('balise' => ' INCLURE'));
1088                         erreur_squelette($msg, $p);
1089         } else          $p->code = 'charge_scripts(' . $_contexte[1] . ',false)';
1090
1091         $p->interdire_scripts = false; // la securite est assuree par recuperer_fond
1092         return $p;
1093 }
1094
1095 // Inclure un modele : #MODELE{modele, params}
1096 // http://doc.spip.org/@balise_MODELE_dist
1097 function balise_MODELE_dist($p) {
1098
1099         $_contexte = argumenter_inclure($p->param, true, $p, $p->boucles, $p->id_boucle, false);
1100
1101         // erreur de syntaxe = fond absent
1102         // (2 messages d'erreur SPIP pour le prix d'un, mais pas d'erreur PHP
1103         if (!$_contexte) $contexte = array();
1104
1105         if (!isset($_contexte[1])) {
1106                 $msg = array('zbug_balise_sans_argument', array('balise' => ' MODELE'));
1107                 erreur_squelette($msg, $p);
1108         } else {
1109                 $nom = $_contexte[1];
1110                 unset($_contexte[1]);
1111
1112                 if (preg_match("/^\s*'[^']*'/s", $nom))
1113                         $nom = "'modeles/" . substr($nom,1);
1114                 else $nom = "'modeles/' . $nom";
1115
1116                 // Incoherence dans la syntaxe du contexte. A revoir.
1117                 // Reserver la cle primaire de la boucle courante si elle existe
1118                 if (isset($p->boucles[$p->id_boucle]->primary)) {
1119                         $primary = $p->boucles[$p->id_boucle]->primary;
1120                         if (!strpos($primary,',')) {
1121                                 $id = champ_sql($primary, $p);
1122                                 $_contexte[] = "'$primary'=>".$id;
1123                                 $_contexte[] = "'id'=>".$id;
1124                         }
1125                 }
1126                 $_contexte[] = "'recurs'=>(++\$recurs)";
1127                 $connect = '';
1128                 if (isset($p->boucles[$p->id_boucle]))
1129                         $connect = $p->boucles[$p->id_boucle]->sql_serveur;
1130
1131                 $_options = memoriser_contexte_compil($p);
1132                 $_options = "'compil'=>array($_options), 'trim'=>true";
1133           if (isset($_contexte['ajax'])){
1134                   $_options .= ", ".preg_replace(",=>(.*)$,ims",'=> ($v=(\\1))?$v:true',$_contexte['ajax']);
1135                         unset($_contexte['ajax']);
1136           }
1137
1138                 $page = sprintf(CODE_RECUPERER_FOND, $nom, 'array(' . join(',', $_contexte) .')', $_options, _q($connect));
1139
1140                 $p->code = "\n\t(((\$recurs=(isset(\$Pile[0]['recurs'])?\$Pile[0]['recurs']:0))>=5)? '' :\n\t$page)\n";
1141
1142                 $p->interdire_scripts = false; // securite assuree par le squelette
1143         }
1144
1145         return $p;
1146 }
1147
1148 //
1149 // #SET
1150 // Affecte une variable locale au squelette
1151 // #SET{nom,valeur}
1152 // la balise renvoie la valeur
1153 // http://doc.spip.org/@balise_SET_dist
1154 function balise_SET_dist($p){
1155         $_nom = interprete_argument_balise(1,$p);
1156         $_val = interprete_argument_balise(2,$p);
1157
1158         if (!$_nom OR !$_val) {
1159                 $err_b_s_a = array('zbug_balise_sans_argument', array('balise' => 'SET'));
1160                 erreur_squelette($err_b_s_a, $p);
1161         }
1162         // affectation $_zzz inutile, mais permet de contourner un bug OpCode cache sous PHP 5.5.4
1163         // cf https://bugs.php.net/bug.php?id=65845
1164         else  $p->code = "vide(\$Pile['vars'][\$_zzz=(string)$_nom] = $_val)";
1165
1166         $p->interdire_scripts = false; // la balise ne renvoie rien
1167         return $p;
1168 }
1169
1170 //
1171 // #GET
1172 // Recupere une variable locale au squelette
1173 // #GET{nom,defaut} renvoie defaut si la variable nom n'a pas ete affectee
1174 //
1175 // http://doc.spip.org/@balise_GET_dist
1176 function balise_GET_dist($p) {
1177         $p->interdire_scripts = false; // le contenu vient de #SET, donc il est de confiance
1178         if (function_exists('balise_ENV'))
1179                 return balise_ENV($p, '$Pile["vars"]');
1180         else
1181                 return balise_ENV_dist($p, '$Pile["vars"]');
1182 }
1183
1184
1185 /**
1186  * Compile la balise #DOUBLONS
1187  *
1188  * #DOUBLONS{mots} ou #DOUBLONS{mots,famille}
1189  * donne l'etat des doublons (MOTS) a cet endroit
1190  * sous forme de tableau d'id_mot  array(1,2,3,...)
1191  * #DOUBLONS tout seul donne la liste brute de tous les doublons
1192  * #DOUBLONS*{mots} donne la chaine brute ",1,2,3,..."
1193  * (changera si la gestion des doublons evolue)
1194  *
1195  * @param Champ $p
1196  *              Pile au niveau de la balise
1197  * @return Champ
1198  *              Pile complétée par le code à générer
1199 **/
1200 function balise_DOUBLONS_dist($p) {
1201         if ($type = interprete_argument_balise(1,$p)) {
1202                 if ($famille = interprete_argument_balise(2,$p))
1203                         $type .= '.' . $famille;
1204                 $p->code = '$doublons['.$type.']';
1205                 if (!$p->etoile)
1206                         $p->code = 'array_filter(array_map("intval",explode(",",'
1207                                 . $p->code . ')))';
1208         }
1209         else
1210                 $p->code = '$doublons';
1211
1212         $p->interdire_scripts = false;
1213
1214         return $p;
1215 }
1216
1217
1218 //
1219 // #PIPELINE
1220 // pour permettre aux plugins d'inserer des sorties de pipeline dans un squelette
1221 // #PIPELINE{insert_body}
1222 // #PIPELINE{insert_body,flux}
1223 //
1224 // http://doc.spip.org/@balise_PIPELINE_dist
1225 function balise_PIPELINE_dist($p) {
1226         $_pipe = interprete_argument_balise(1,$p);
1227         if (!$_pipe) {
1228                 $err_b_s_a = array('zbug_balise_sans_argument', array('balise' => 'PIPELINE'));
1229                 erreur_squelette($err_b_s_a, $p);
1230         } else {
1231                 $_flux = interprete_argument_balise(2,$p);
1232                 $_flux = $_flux?$_flux:"''";
1233                 $p->code = "pipeline( $_pipe , $_flux )";
1234                 $p->interdire_scripts = false;
1235         }
1236         return $p;
1237 }
1238
1239 //
1240 // #EDIT
1241 // une balise qui ne fait rien, pour surcharge par le plugin widgets
1242 //
1243 // http://doc.spip.org/@balise_EDIT_dist
1244 function balise_EDIT_dist($p) {
1245         $p->code = "''";
1246         $p->interdire_scripts = false;
1247         return $p;
1248 }
1249
1250
1251 //
1252 // #TOTAL_UNIQUE
1253 // pour recuperer le nombre d'elements affiches par l'intermediaire du filtre
1254 // |unique
1255 // usage:
1256 // #TOTAL_UNIQUE afiche le nombre de #BALISE|unique
1257 // #TOTAL_UNIQUE{famille} afiche le nombre de #BALISE|unique{famille}
1258 //
1259 // http://doc.spip.org/@balise_TOTAL_UNIQUE_dist
1260 function balise_TOTAL_UNIQUE_dist($p) {
1261         $_famille = interprete_argument_balise(1,$p);
1262         $_famille = $_famille ? $_famille : "''";
1263         $p->code = "unique('', $_famille, true)";
1264         return $p;
1265 }
1266
1267 //
1268 // #ARRAY
1269 // pour creer un array php a partir d'arguments calcules
1270 // #ARRAY{key1,val1,key2,val2 ...} retourne array(key1=>val1,...)
1271 //
1272 // http://doc.spip.org/@balise_ARRAY_dist
1273 function balise_ARRAY_dist($p) {
1274         $_code = array();
1275         $n=1;
1276         do {
1277                 $_key = interprete_argument_balise($n++,$p);
1278                 $_val = interprete_argument_balise($n++,$p);
1279                 if ($_key AND $_val) $_code[] = "$_key => $_val";
1280         } while ($_key && $_val);
1281         $p->code = 'array(' . join(', ',$_code).')';
1282         $p->interdire_scripts = false;
1283         return $p;
1284 }
1285
1286 /**
1287  * #LISTE{a,b,c,d,e} cree un array avec les valeurs, sans preciser les cles
1288  *
1289  * @param <type> $p
1290  * @return <type>
1291  */
1292 function balise_LISTE_dist($p) {
1293         $_code = array();
1294         $n=1;
1295         while ($_val = interprete_argument_balise($n++,$p))
1296                 $_code[] = $_val;
1297         $p->code = 'array(' . join(', ',$_code).')';
1298         $p->interdire_scripts = false;
1299         return $p;
1300 }
1301
1302 // Appelle la fonction autoriser et renvoie ' ' si OK, '' si niet
1303 // A noter : la priorite des operateurs exige && plutot que AND
1304 // Cette balise cree un cache par session
1305 // http://doc.spip.org/@balise_AUTORISER_dist
1306 function balise_AUTORISER_dist($p) {
1307         $_code = array();
1308         $p->descr['session'] = true; // faire un cache par session
1309
1310         $n=1;
1311         while ($_v = interprete_argument_balise($n++,$p))
1312                 $_code[] = $_v;
1313
1314         $p->code = '((function_exists("autoriser")||include_spip("inc/autoriser"))&&autoriser(' . join(', ',$_code).')?" ":"")';
1315         $p->interdire_scripts = false;
1316         return $p;
1317 }
1318
1319 // Appelle la fonction info_plugin
1320 // Afficher des informations sur les plugins dans le site public
1321 // http://doc.spip.org/@balise_PLUGIN_dist
1322 function balise_PLUGIN_dist($p) {
1323         $plugin = interprete_argument_balise(1,$p);
1324         $plugin = isset($plugin) ? str_replace('\'', '"', $plugin) : '""';
1325         $type_info = interprete_argument_balise(2,$p);
1326         $type_info = isset($type_info) ? str_replace('\'', '"', $type_info) : '"est_actif"';
1327
1328         $f = chercher_filtre('info_plugin');
1329         $p->code = $f.'('.$plugin.', '.$type_info.')';
1330         return $p;
1331 }
1332
1333 // Appelle la fonction inc_aider_dist
1334 // http://doc.spip.org/@balise_AIDER_dist
1335 function balise_AIDER_dist($p) {
1336         $_motif = interprete_argument_balise(1,$p);
1337         $s = "'" . addslashes($p->descr['sourcefile']) . "'";
1338         $aider = charger_fonction('aider','inc');
1339         $p->code = "((\$aider=charger_fonction('aider','inc'))?\$aider($_motif,$s, \$Pile[0]):'')";
1340         return $p;
1341 }
1342
1343 // Insertion du contexte des formulaires charger/verifier/traiter
1344 // avec les hidden de l'url d'action
1345 // http://doc.spip.org/@balise_ACTION_FORMULAIRE
1346 function balise_ACTION_FORMULAIRE($p){
1347         if (!$_url = interprete_argument_balise(1,$p))
1348                 $_url = "@\$Pile[0]['action']";
1349         if (!$_form = interprete_argument_balise(2,$p))
1350                 $_form = "@\$Pile[0]['form']";
1351
1352         // envoyer le nom du formulaire que l'on traite
1353         // transmettre les eventuels args de la balise formulaire
1354         $p->code = "    '<div>' .
1355         form_hidden($_url) .
1356         '<input name=\'formulaire_action\' type=\'hidden\'
1357                 value=\'' . $_form . '\' />' .
1358         '<input name=\'formulaire_action_args\' type=\'hidden\'
1359                 value=\'' . @\$Pile[0]['formulaire_args']. '\' />' .
1360         (@\$Pile[0]['_hidden']?@\$Pile[0]['_hidden']:'') .
1361         '</div>'";
1362
1363         $p->interdire_scripts = false;
1364         return $p;
1365 }
1366
1367
1368 /**
1369  * Generer un bouton d'action en post, ajaxable
1370  * a utiliser a la place des liens action_auteur, sous la forme
1371  * #BOUTON_ACTION{libelle,url}
1372  * ou
1373  * #BOUTON_ACTION{libelle,url,ajax} pour que l'action soit ajax comme un lien class='ajax'
1374  * ou
1375  * #BOUTON_ACTION{libelle,url,ajax,message_confirmation} pour utiliser un message de confirmation
1376  *
1377  * #BOUTON_ACTION{libelle[,url[,ajax[,message_confirmation[,title[,callback]]]]]}
1378  *
1379  * @param unknown_type $p
1380  * @return unknown
1381  */
1382 function balise_BOUTON_ACTION_dist($p){
1383
1384         $args = array();
1385         for ($k=1;$k<=6;$k++){
1386                 $_a = interprete_argument_balise($k,$p);
1387                 if (!$_a) $_a="''";
1388           $args[] = $_a;
1389         }
1390         // supprimer les args vides
1391         while(end($args)=="''" AND count($args)>2)
1392                 array_pop($args);
1393         $args = implode(",",$args);
1394
1395         $bouton_action = chercher_filtre("bouton_action");
1396         $p->code = "$bouton_action($args)";
1397         $p->interdire_scripts = false;
1398         return $p;
1399 }
1400
1401
1402
1403 function balise_SLOGAN_SITE_SPIP_dist($p) {
1404         $p->code = "\$GLOBALS['meta']['slogan_site']";
1405         #$p->interdire_scripts = true;
1406         return $p;
1407 }
1408
1409 // #HTML5
1410 // Renvoie ' ' si le webmestre souhaite que SPIP genere du code (X)HTML5 sur
1411 // le site public, et '' si le code doit etre strictement compatible HTML4
1412 // http://doc.spip.org/@balise_HTML5_dist
1413 function balise_HTML5_dist($p) {
1414         $p->code = html5_permis() ? "' '" : "''";
1415         $p->interdire_scripts = false;
1416         return $p;
1417 }
1418
1419
1420
1421 /**
1422  * #TRI{champ[,libelle]}
1423  * champ prend > ou < pour afficher le lien de changement de sens
1424  * croissant ou decroissant (> < indiquent un sens par une fleche)
1425  *
1426  * @param unknown_type $p
1427  * @param unknown_type $liste
1428  * @return unknown
1429  */
1430 function balise_TRI_dist($p, $liste='true') {
1431         $b = $p->nom_boucle ? $p->nom_boucle : $p->descr['id_mere'];
1432
1433         // s'il n'y a pas de nom de boucle, on ne peut pas trier
1434         if ($b === '') {
1435                 erreur_squelette(
1436                         _T('zbug_champ_hors_boucle',
1437                                 array('champ' => '#TRI')
1438                         ), $p->id_boucle);
1439                 $p->code = "''";
1440                 return $p;
1441         }
1442         $boucle = $p->boucles[$b];
1443
1444         // s'il n'y a pas de tri_champ, c'est qu'on se trouve
1445         // dans un boucle recursive ou qu'on a oublie le critere {tri}
1446         if (!isset($boucle->modificateur['tri_champ'])) {
1447                 erreur_squelette(
1448                         _T('zbug_tri_sans_critere',
1449                                 array('champ' => '#TRI')
1450                         ), $p->id_boucle);
1451                 $p->code = "''";
1452                 return $p;
1453         }
1454
1455         $_champ = interprete_argument_balise(1,$p);
1456         // si pas de champ, renvoyer le critere de tri utilise
1457         if (!$_champ){
1458                 $p->code = $boucle->modificateur['tri_champ'];
1459                 return $p;
1460         }
1461         // forcer la jointure si besoin, et si le champ est statique
1462         if (preg_match(",^'([\w.]+)'$,i",$_champ,$m)){
1463                 index_pile($b, $m[1], $p->boucles);
1464         }
1465
1466         $_libelle = interprete_argument_balise(2,$p);
1467         $_libelle = $_libelle?$_libelle:$_champ;
1468
1469         $_class = interprete_argument_balise(3,$p);
1470         // si champ = ">" c'est un lien vers le tri croissant : de gauche a droite ==> 1
1471         // si champ = "<" c'est un lien vers le tri decroissant : (sens inverse) == -1
1472         $_issens = "in_array($_champ,array('>','<'))";
1473         $_sens = "(strpos('< >',$_champ)-1)";
1474
1475         $_variable = "((\$s=$_issens)?'sens':'tri').".$boucle->modificateur['tri_nom'];
1476         $_url = "parametre_url(self(),$_variable,\$s?$_sens:$_champ)";
1477         $_on = "\$s?(".$boucle->modificateur['tri_sens']."==$_sens".'):('.$boucle->modificateur['tri_champ']."==$_champ)";
1478
1479         $p->code = "lien_ou_expose($_url,$_libelle,$_on".($_class?",$_class":"").")";
1480         //$p->code = "''";
1481         $p->interdire_scripts = false;
1482         return $p;
1483 }
1484
1485
1486 /**
1487  * #SAUTER{n} permet de sauter en avant n resultats dans une boucle
1488  * La balise modifie le compteur courant de la boucle, mais pas les autres
1489  * champs qui restent les valeurs de la boucle avant le saut. Il est donc
1490  * preferable d'utiliser la balise juste avant la fermeture </BOUCLE>
1491  *
1492  * L'argument n doit etre superieur a zero sinon la balise ne fait rien
1493  *
1494  * @param <type> $p
1495  * @return <type>
1496  */
1497 function balise_SAUTER_dist($p){
1498         $id_boucle = $p->id_boucle;
1499         $boucle = $p->boucles[$id_boucle];
1500
1501         if (!$boucle) {
1502                 $msg = array('zbug_champ_hors_boucle', array('champ' => '#SAUTER'));
1503                 erreur_squelette($msg, $p);
1504         }
1505         else {
1506                 $_saut = interprete_argument_balise(1,$p);
1507                 $_compteur = "\$Numrows['$id_boucle']['compteur_boucle']";
1508                 $_total = "\$Numrows['$id_boucle']['total']";
1509
1510                 $p->code = "vide($_compteur=\$iter->skip($_saut,$_total))";
1511         }
1512         $p->interdire_scripts = false;
1513         return $p;
1514 }
1515
1516
1517 /**
1518  * Savoir si on objet est publie ou non
1519  *
1520  * @param <type> $p
1521  * @return <type>
1522  */
1523 function balise_PUBLIE_dist($p) {
1524         if (!$_type = interprete_argument_balise(1,$p)){
1525                 $_type = _q($p->type_requete);
1526                 $_id = champ_sql($p->boucles[$p->id_boucle]->primary,$p);
1527         }
1528         else
1529                 $_id = interprete_argument_balise(2,$p);
1530
1531         $connect = $p->boucles[$p->id_boucle]->sql_serveur;
1532
1533         $p->code = "(objet_test_si_publie(".$_type.",intval(".$_id."),"._q($connect).")?' ':'')";
1534         $p->interdire_scripts = false;
1535         return $p;
1536 }
1537
1538 /**
1539  * #PRODUIRE
1540  * generer un fichier statique a partir d'un squelette SPIP
1541  *
1542  * Le format du fichier sera extrait de la preextension du squelette (typo.css.html, messcripts.js.html)
1543  * ou par l'argument format=css ou format=js passe en argument.
1544  *
1545  * Si pas de format detectable, on utilise .html, comme pour les squelettes
1546  *
1547  * <link rel="stylesheet" type="text/css" href="#PRODUIRE{fond=css/macss.css,couleur=ffffff}" />
1548  * la syntaxe de la balise est la meme que celle de #INCLURE
1549  *
1550  * @param object $p
1551  * @return object
1552  */
1553 function balise_PRODUIRE_dist($p){
1554         $balise_inclure = charger_fonction('INCLURE','balise');
1555         $p = $balise_inclure($p);
1556
1557         $p->code = str_replace('recuperer_fond(','produire_fond_statique(',$p->code);
1558
1559         return $p;
1560 }
1561
1562 /**
1563  * Definir la largeur d'ecran dans l'espace prive
1564  * #LARGEUR_ECRAN{pleine_largeur}
1565  *
1566  * @param  $p
1567  * @return
1568  */
1569 function balise_LARGEUR_ECRAN_dist($p){
1570         $_class = interprete_argument_balise(1,$p);
1571         if (!$_class) $_class='null';
1572         $p->code = "(is_string($_class)?vide(\$GLOBALS['largeur_ecran']=$_class):(isset(\$GLOBALS['largeur_ecran'])?\$GLOBALS['largeur_ecran']:''))";
1573         return $p;
1574 }
1575 ?>