ecrire/public/criteres.php

   1 <?php
   2
   3 /***************************************************************************\
   4  *  SPIP, Systeme de publication pour l'internet                           *
   5  *                                                                         *
   6  *  Copyright (c) 2001-2007                                                *
   7  *  Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James  *
   8  *                                                                         *
   9  *  Ce programme est un logiciel libre distribue sous licence GNU/GPL.     *
  10  *  Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne.   *
  11 \***************************************************************************/
  12
  13
  14 //
  15 // Definition des {criteres} d'une boucle
  16 //
  17
  18 if (!defined("_ECRIRE_INC_VERSION")) return;
  19
  20 // {racine}
  21 // http://www.spip.net/@racine
  22 // http://doc.spip.org/@critere_racine_dist
  23 function critere_racine_dist($idb, &$boucles, $crit) {
  24         $not = $crit->not;
  25         $boucle = &$boucles[$idb];
  26
  27         if ($not)
  28                 erreur_squelette(_T('zbug_info_erreur_squelette'), $crit->op);
  29
  30         $boucle->where[]= array("'='", "'$boucle->id_table." . "id_parent'", 0);
  31 }
  32
  33 // {exclus}
  34 // http://www.spip.net/@exclus
  35 // http://doc.spip.org/@critere_exclus_dist
  36 function critere_exclus_dist($idb, &$boucles, $crit) {
  37         $param = $crit->op;
  38         $not = $crit->not;
  39         $boucle = &$boucles[$idb];
  40         $id = $boucle->primary;
  41
  42         if ($not OR !$id)
  43                 erreur_squelette(_T('zbug_info_erreur_squelette'), $param);
  44
  45         $arg = kwote(calculer_argument_precedent($idb, $id, $boucles));
  46         $boucle->where[]= array("'!='", "'$boucle->id_table." . "$id'", $arg);
  47 }
  48
  49 // {doublons} ou {unique}
  50 // http://www.spip.net/@doublons
  51 // attention: boucle->doublons designe une variable qu'on affecte
  52 // http://doc.spip.org/@critere_doublons_dist
  53 function critere_doublons_dist($idb, &$boucles, $crit) {
  54         $boucle = &$boucles[$idb];
  55         if (!$boucle->primary)
  56                 erreur_squelette(_T('zbug_doublon_table_sans_index'), "BOUCLE$idb");
  57         $nom = !isset($crit->param[0]) ? "''" : calculer_liste($crit->param[0], array(), $boucles, $boucles[$idb]->id_parent);
  58         // mettre un tableau pour que ce ne soit pas vu comme une constante
  59         $boucle->where[]= array("calcul_mysql_in('".$boucle->id_table . '.' . $boucle->primary .
  60           "', " .
  61           '"0".$doublons[' .
  62           ($crit->not ? '' : ($boucle->doublons . "[]= ")) .
  63           "('" .
  64           $boucle->type_requete .
  65           "'" .
  66           ($nom == "''" ? '' : " . $nom") .
  67           ')], \'' .
  68           ($crit->not ? '' : 'NOT') .
  69                                 "')");
  70 # la ligne suivante avait l'intention d'eviter une collecte deja faite
  71 # mais elle fait planter une boucle a 2 critere doublons:
  72 # {!doublons A}{doublons B}
  73 # (de http://article.gmane.org/gmane.comp.web.spip.devel/31034)
  74 #       if ($crit->not) $boucle->doublons = "";
  75 }
  76
  77 // {lang_select}
  78 // http://www.spip.net/@lang_select
  79 // http://doc.spip.org/@critere_lang_select_dist
  80 function critere_lang_select_dist($idb, &$boucles, $crit) {
  81         if (!($param = $crit->param[1][0]->texte)) $param = 'oui';
  82         if ($crit->not) $param = ($param=='oui') ? 'non' : 'oui';
  83         $boucle = &$boucles[$idb];
  84         $boucle->lang_select = $param;
  85 }
  86
  87 // {debut_xxx}
  88 // http://www.spip.net/@debut_
  89 // http://doc.spip.org/@critere_debut_dist
  90 function critere_debut_dist($idb, &$boucles, $crit) {
  91         $boucle = &$boucles[$idb];
  92         $boucle->limit = 'intval($GLOBALS["debut' .
  93           $crit->param[0][0]->texte .
  94           '"]) . ",' .
  95           $crit->param[1][0]->texte .
  96           '"' ;
  97 }
  98 // {pagination}
  99 // {pagination 20}
 100 // {pagination #ENV{pages,5}} etc
 101 // {pagination 20 #ENV{truc,chose}} pour utiliser la variable debut_#ENV{truc,chose}
 102 // http://www.spip.net/@pagination
 103 // http://doc.spip.org/@critere_pagination_dist
 104 function critere_pagination_dist($idb, &$boucles, $crit) {
 105
 106         // definition de la taille de la page
 107         $pas = !isset($crit->param[0][0]) ? "''" : calculer_liste(array($crit->param[0][0]), array(), $boucles, $boucles[$idb]->id_parent);
 108         $debut = !isset($crit->param[0][1]) ? "'$idb'" : calculer_liste(array($crit->param[0][1]), array(), $boucles, $boucles[$idb]->id_parent);
 109         $pas = ($pas== "''") ? '10' : "((\$a = intval($pas)) ? \$a : 10)";
 110
 111         $boucle = &$boucles[$idb];
 112         $boucle->mode_partie = 'p+';
 113         $boucle->partie = 'intval(_request("debut".'.$debut.'))';
 114         $boucle->modificateur['debut_nom'] = $debut;
 115         $boucle->total_parties = $pas;
 116         if (!isset($boucle->modificateur['fragment']))
 117                 $boucle->modificateur['fragment'] = 'fragment_'.$boucle->descr['nom'].$idb;
 118 }
 119
 120 // {fragment}
 121 // http://www.spip.net/@fragment
 122 // http://doc.spip.org/@critere_fragment_dist
 123 function critere_fragment_dist($idb, &$boucles, $crit) {
 124         if (!($param = $crit->param[0][0]->texte))
 125                 $param = 'fragment_'.$boucle->descr['nom'].$idb;
 126         if ($crit->not)
 127                 $param = false;
 128         $boucle = &$boucles[$idb];
 129         $boucle->modificateur['fragment'] = $param;
 130 }
 131
 132
 133 // {recherche}
 134 // http://www.spip.net/@recherche
 135 // http://doc.spip.org/@critere_recherche_dist
 136 function critere_recherche_dist($idb, &$boucles, $crit) {
 137         global $table_des_tables;
 138         $boucle = &$boucles[$idb];
 139         $t = $boucle->id_table;
 140         if (in_array($t,$table_des_tables))
 141                 $t = "spip_$t";
 142
 143         // Ne pas executer la requete en cas de hash vide
 144         $boucle->hash = '
 145         // RECHERCHE
 146         list($rech_select, $rech_where) = prepare_recherche($GLOBALS["recherche"], "'.$boucle->primary.'", "'.$boucle->id_table.'", "'.$t.'", "'.$crit->cond.'");
 147         ';
 148
 149         // Sauf si le critere est conditionnel {recherche ?}
 150         if (!$crit->cond)
 151                 $boucle->hash .= '
 152         if ($rech_where) ';
 153
 154         $t = $boucle->id_table . '.' . $boucle->primary;
 155         if (!in_array($t, $boucles[$idb]->select))
 156           $boucle->select[]= $t; # pour postgres, neuneu ici
 157         $boucle->select[]= '$rech_select as points';
 158
 159         // et la recherche trouve
 160         $boucle->where[]= '$rech_where';
 161 }
 162
 163 // {traduction}
 164 // http://www.spip.net/@traduction
 165 //   (id_trad>0 AND id_trad=id_trad(precedent))
 166 //    OR id_article=id_article(precedent)
 167 // http://doc.spip.org/@critere_traduction_dist
 168 function critere_traduction_dist($idb, &$boucles, $crit) {
 169         $boucle = &$boucles[$idb];
 170         $prim = $boucle->primary;
 171         $table = $boucle->id_table;
 172         $arg = kwote(calculer_argument_precedent($idb, 'id_trad', $boucles));
 173         $dprim = kwote(calculer_argument_precedent($idb, $prim, $boucles));
 174         $boucle->where[]=
 175                 array("'OR'",
 176                         array("'AND'",
 177                                 array("'='", "'$table.id_trad'", 0),
 178                                 array("'='", "'$table.$prim'", $dprim)
 179                         ),
 180                         array("'AND'",
 181                                 array("'>'", "'$table.id_trad'", 0),
 182                                 array("'='", "'$table.id_trad'", $arg)
 183                         )
 184                 );
 185 }
 186
 187 // {origine_traduction}
 188 //   (id_trad>0 AND id_article=id_trad) OR (id_trad=0)
 189 // http://www.spip.net/@origine_traduction
 190 // http://doc.spip.org/@critere_origine_traduction_dist
 191 function critere_origine_traduction_dist($idb, &$boucles, $crit) {
 192         $boucle = &$boucles[$idb];
 193         $prim = $boucle->primary;
 194         $table = $boucle->id_table;
 195
 196         $c =
 197         array("'OR'",
 198                 array("'='", "'$table." . "id_trad'", "'$table.$prim'"),
 199                 array("'='", "'$table.id_trad'", "'0'")
 200         );
 201         $boucle->where[]= ($crit->not ? array("'NOT'", $c) : $c);
 202 }
 203
 204 // {meme_parent}
 205 // http://www.spip.net/@meme_parent
 206 // http://doc.spip.org/@critere_meme_parent_dist
 207 function critere_meme_parent_dist($idb, &$boucles, $crit) {
 208         $boucle = &$boucles[$idb];
 209         $arg = kwote(calculer_argument_precedent($idb, 'id_parent', $boucles));
 210         $mparent = $boucle->id_table . '.id_parent';
 211
 212         if ($boucle->type_requete == 'rubriques') {
 213                 $boucle->where[]= array("'='", "'$mparent'", $arg);
 214
 215         } else if ($boucle->type_requete == 'forums') {
 216                         $boucle->where[]= array("'='", "'$mparent'", $arg);
 217                         $boucle->where[]= array("'>'", "'$mparent'", 0);
 218                         $boucle->modificateur['plat'] = true;
 219         } else erreur_squelette(_T('zbug_info_erreur_squelette'), "{meme_parent} BOUCLE$idb");
 220 }
 221
 222 // {branche ?}
 223 // http://www.spip.net/@branche
 224 // http://doc.spip.org/@critere_branche_dist
 225 function critere_branche_dist($idb, &$boucles, $crit) {
 226         $not = $crit->not;
 227         $boucle = &$boucles[$idb];
 228
 229         $arg = calculer_argument_precedent($idb, 'id_rubrique', $boucles);
 230
 231         $c = "calcul_mysql_in('" .
 232           $boucle->id_table .
 233           ".id_rubrique', calcul_branche($arg), '')";
 234         if ($crit->cond) $c = "($arg ? $c : 1)";
 235
 236         if ($not)
 237                 $boucle->where[]= array("'NOT'", $c);
 238         else
 239                 $boucle->where[]= $c;
 240 }
 241
 242 // {logo} liste les objets qui ont un logo
 243 // http://doc.spip.org/@critere_logo_dist
 244 function critere_logo_dist($idb, &$boucles, $crit) {
 245         $not = $crit->not;
 246         $boucle = &$boucles[$idb];
 247
 248         $c = "calcul_mysql_in('" .
 249           $boucle->id_table . '.' . $boucle->primary
 250           . "', lister_objets_avec_logos(". $boucle->type_requete ."), '')";
 251         if ($crit->cond) $c = "($arg ? $c : 1)";
 252
 253         if ($not)
 254                 $boucle->where[]= array("'NOT'", $c);
 255         else
 256                 $boucle->where[]= $c;
 257 }
 258
 259 // c'est la commande SQL "GROUP BY"
 260 // par exemple <boucle(articles){fusion lang}>
 261 // http://doc.spip.org/@critere_fusion_dist
 262 function critere_fusion_dist($idb,&$boucles, $crit) {
 263         if (isset($crit->param[0])) {
 264                 $x = $crit->param[0];
 265                 if ($x[0]->type == 'texte')
 266                         $boucles[$idb]->group[] = $x[0]->texte;
 267                 else    $boucles[$idb]->group[] = '".' . calculer_critere_arg_dynamique($idb, $boucles, $x) . '."';
 268         } else
 269                 erreur_squelette(_T('zbug_info_erreur_squelette'),
 270                         "{groupby ?} BOUCLE$idb");
 271 }
 272
 273 // http://doc.spip.org/@calculer_critere_arg_dynamique
 274 function calculer_critere_arg_dynamique($idb, &$boucles, $crit, $suffix='')
 275 {
 276         global $table_des_tables, $tables_des_serveurs_sql;
 277
 278         $boucle = $boucles[$idb];
 279
 280         $arg = calculer_liste($crit, array(), $boucles, $boucle->id_parent);
 281         $r = $boucle->type_requete;
 282         $s = $boucles[$idb]->sql_serveur;
 283         if (!$s) $s = 'localhost';
 284         $t = $table_des_tables[$r];
 285         // pour les tables non Spip
 286         if (!$t) $t = $r; else $t = "spip_$t";
 287         $desc = $tables_des_serveurs_sql[$s][$t];
 288
 289         if (is_array($desc['field'])){
 290                 $liste_field = implode(',',array_map('_q',array_keys($desc['field'])));
 291                 return  "((\$x = preg_replace(\"/\\W/\",'',$arg)) ? ( in_array(\$x,array($liste_field))  ? ('$boucle->id_table.' . \$x$suffix):(\$x$suffix) ) : '')";
 292         } else {
 293                 return "((\$x = preg_replace(\"/\\W/\",'',$arg)) ? ('$boucle->id_table.' . \$x$suffix) : '')";
 294         }
 295 }
 296 // Tri : {par xxxx}
 297 // http://www.spip.net/@par
 298 // http://doc.spip.org/@critere_par_dist
 299 function critere_par_dist($idb, &$boucles, $crit) {
 300         critere_parinverse($idb, $boucles, $crit, '') ;
 301 }
 302
 303 // http://doc.spip.org/@critere_parinverse
 304 function critere_parinverse($idb, &$boucles, $crit, $sens) {
 305         global $table_des_tables, $tables_des_serveurs_sql,  $exceptions_des_jointures;
 306         $boucle = &$boucles[$idb];
 307         if ($crit->not) $sens = $sens ? "" : " . ' DESC'";
 308
 309         foreach ($crit->param as $tri) {
 310
 311           $fct = ""; // en cas de fonction SQL
 312         // tris specifies dynamiquement
 313           if ($tri[0]->type != 'texte') {
 314             // on sait pas faire pour les serveurs externes. A revoir.
 315                 if (!$boucles[$idb]->sql_serveur) {
 316                 // calculer le order dynamique qui verifie les champs
 317                         $order = calculer_critere_arg_dynamique($idb, $boucles, $tri, $sens);
 318             // et ajouter un champ hasard dans le select pour supporter 'hasard' comme tri dynamique
 319                         if (spip_abstract_select(array("RAND()")))
 320                                 $par = "RAND()";
 321                         else
 322                                 $par = "MOD(".$boucle->id_table.'.'.$boucle->primary
 323                           ." * UNIX_TIMESTAMP(),32767) & UNIX_TIMESTAMP()";
 324                         $boucle->select[]= $par . " AS hasard";
 325                 }
 326           } else {
 327               $par = array_shift($tri);
 328               $par = $par->texte;
 329     // par multi champ
 330               if (ereg("^multi[[:space:]]*(.*)$",$par, $m)) {
 331                   $texte = $boucle->id_table . '.' . trim($m[1]);
 332                   $boucle->select[] =  " \".creer_objet_multi('".$texte."', \$GLOBALS['spip_lang']).\"" ;
 333                   $order = "multi";
 334         // par num champ(, suite)
 335               } else if (ereg("^num[[:space:]]*(.*)$",$par, $m)) {
 336                   $texte = '0+' . $boucle->id_table . '.' . trim($m[1]);
 337                   $suite = calculer_liste($tri, array(), $boucles, $boucle->id_parent);
 338                   if ($suite !== "''")
 339                     $texte = "\" . ((\$x = $suite) ? ('$texte' . \$x) : '0')" . " . \"";
 340                   $as = 'num' .($boucle->order ? count($boucle->order) : "");
 341                   $boucle->select[] = $texte . " AS $as";
 342                   $order = "'$as'";
 343               } else {
 344               if (!preg_match(",^" . CHAMP_SQL_PLUS_FONC . '$,is', $par, $match))
 345                 erreur_squelette(_T('zbug_info_erreur_squelette'), "{par $par} BOUCLE$idb");
 346               else {
 347                 if ($match[2]) { $par = substr($match[2],1,-1); $fct = $match[1]; }
 348         // par hasard
 349                 if ($par == 'hasard') {
 350                 // tester si cette version de MySQL accepte la commande RAND()
 351                 // sinon faire un gloubi-boulga maison avec de la mayonnaise.
 352                   if (spip_abstract_select(array("RAND()")))
 353                         $par = "RAND()";
 354                   else
 355                         $par = "MOD(".$boucle->id_table.'.'.$boucle->primary
 356                           ." * UNIX_TIMESTAMP(),32767) & UNIX_TIMESTAMP()";
 357                   $boucle->select[]= $par . " AS alea";
 358                   $order = "'alea'";
 359                 }
 360         // par date_thread
 361         // (date la plus recente d'un message dans un fil de discussion)
 362                 else if ($par == 'date_thread') {
 363                         if ($boucle->type_requete == 'forums') {
 364                           $t = 'forum';
 365                         } else {
 366                           $t = critere_par_jointure($boucle, array('spip_forum','id_thread'));
 367                           $t = substr($t, 1, strpos($t,'.')-1);
 368                         }
 369                         $boucle->select[] = "MAX($t" . ".".
 370                                 $GLOBALS['table_date']['forums']
 371                                 .") AS date_thread";
 372                         $boucle->group[] = $t . ".id_thread";
 373                         $order = "'date_thread'";
 374                         $boucle->modificateur['plat'] = true;
 375                 }
 376         // par titre_mot ou type_mot voire d'autres
 377                 else if (isset($exceptions_des_jointures[$par])) {
 378                         $order = critere_par_jointure($boucle, $exceptions_des_jointures[$par]);
 379                          }
 380                 else if ($par == 'date'
 381                 AND isset($GLOBALS['table_date'][$boucle->type_requete])) {
 382                         $m = $GLOBALS['table_date'][$boucle->type_requete];
 383                         $order = "'".$boucle->id_table ."." . $m . "'";
 384                 }
 385                 // par champ. Verifier qu'ils sont presents.
 386                 else {
 387                   $r = $boucle->type_requete;
 388                   $s = $boucles[$idb]->sql_serveur;
 389                   if (!$s) $s = 'localhost';
 390                   $t = $table_des_tables[$r];
 391                   // pour les tables non Spip
 392                   if (!$t) $t = $r; else $t = "spip_$t";
 393                   $desc = $tables_des_serveurs_sql[$s][$t];
 394                   if ($desc['field'][$par])
 395                     $par = $boucle->id_table.".".$par;
 396                   // sinon tant pis, ca doit etre un champ synthetise (cf points)
 397                   $order = "'$par'";
 398                 }
 399               }
 400               }
 401           }
 402           if ($order)
 403             $boucle->order[] = ($fct ? "'$fct(' . $order . ')'" : $order) .
 404               (($order[0]=="'") ? $sens : "");
 405         }
 406 }
 407
 408 // http://doc.spip.org/@critere_par_jointure
 409 function critere_par_jointure(&$boucle, $join)
 410 {
 411   global $table_des_tables;
 412   list($table, $champ) = $join;
 413   $t = array_search($table, $boucle->from);
 414   if (!$t) {
 415     $type = $boucle->type_requete;
 416     $nom = $table_des_tables[$type];
 417     list($nom, $desc) = trouver_def_table($nom ? $nom : $type, $boucle);
 418
 419     $cle = trouver_champ_exterieur($champ, $boucle->jointures, $boucle);
 420     if ($cle)
 421       $cle = calculer_jointure($boucle, array($boucle->id_table, $desc), $cle, false);
 422     if ($cle) $t = "L$cle";
 423     else  erreur_squelette(_T('zbug_info_erreur_squelette'),  "{par ?} BOUCLE$idb");
 424
 425   }
 426   return "'" . $t . '.' . $champ . "'";
 427 }
 428
 429 // {inverse}
 430 // http://www.spip.net/@inverse
 431
 432 // http://doc.spip.org/@critere_inverse_dist
 433 function critere_inverse_dist($idb, &$boucles, $crit) {
 434
 435         $boucle = &$boucles[$idb];
 436         // Classement par ordre inverse
 437         if ($crit->not)
 438                 critere_parinverse($idb, $boucles, $crit, " . ' DESC'");
 439         else
 440           {
 441                 $order = "' DESC'";
 442         // Classement par ordre inverse fonction eventuelle de #ENV{...}
 443                 if (isset($crit->param[0])){
 444                         $critere = calculer_liste($crit->param[0], array(), $boucles, $boucles[$idb]->id_parent);
 445                         $order = "(($critere)?' DESC':'')";
 446                 }
 447
 448             $n = count($boucle->order);
 449             if ($n)
 450               $boucle->order[$n-1] .= " . $order";
 451             else
 452               $boucle->default_order[] =  ' DESC';
 453           }
 454 }
 455
 456 // http://doc.spip.org/@critere_agenda_dist
 457 function critere_agenda_dist($idb, &$boucles, $crit)
 458 {
 459         $params = $crit->param;
 460
 461         if (count($params) < 1)
 462               erreur_squelette(_T('zbug_info_erreur_squelette'),
 463                                "{agenda ?} BOUCLE$idb");
 464
 465         $parent = $boucles[$idb]->id_parent;
 466
 467         // les valeurs $date et $type doivent etre connus a la compilation
 468         // autrement dit ne pas etre des champs
 469
 470         $date = array_shift($params);
 471         $date = $date[0]->texte;
 472
 473         $type = array_shift($params);
 474         $type = $type[0]->texte;
 475
 476         $annee = $params ? array_shift($params) : "";
 477         $annee = "\n" . 'sprintf("%04d", ($x = ' .
 478                 calculer_liste($annee, array(), $boucles, $parent) .
 479                 ') ? $x : date("Y"))';
 480
 481         $mois =  $params ? array_shift($params) : "";
 482         $mois = "\n" . 'sprintf("%02d", ($x = ' .
 483                 calculer_liste($mois, array(), $boucles, $parent) .
 484                 ') ? $x : date("m"))';
 485
 486         $jour =  $params ? array_shift($params) : "";
 487         $jour = "\n" . 'sprintf("%02d", ($x = ' .
 488                 calculer_liste($jour, array(), $boucles, $parent) .
 489                 ') ? $x : date("d"))';
 490
 491         $annee2 = $params ? array_shift($params) : "";
 492         $annee2 = "\n" . 'sprintf("%04d", ($x = ' .
 493                 calculer_liste($annee2, array(), $boucles, $parent) .
 494                 ') ? $x : date("Y"))';
 495
 496         $mois2 =  $params ? array_shift($params) : "";
 497         $mois2 = "\n" . 'sprintf("%02d", ($x = ' .
 498                 calculer_liste($mois2, array(), $boucles, $parent) .
 499                 ') ? $x : date("m"))';
 500
 501         $jour2 =  $params ? array_shift($params) : "";
 502         $jour2 = "\n" .  'sprintf("%02d", ($x = ' .
 503                 calculer_liste($jour2, array(), $boucles, $parent) .
 504                 ') ? $x : date("d"))';
 505
 506         $boucle = &$boucles[$idb];
 507         $date = $boucle->id_table . ".$date";
 508
 509         if ($type == 'jour')
 510                 $boucle->where[]= array("'='", "'DATE_FORMAT($date, \'%Y%m%d\')'",
 511                                         ("$annee . $mois . $jour"));
 512         elseif ($type == 'mois')
 513                 $boucle->where[]= array("'='", "'DATE_FORMAT($date, \'%Y%m\')'",
 514                                         ("$annee . $mois"));
 515         elseif ($type == 'semaine')
 516                 $boucle->where[]= array("'AND'",
 517                                         array("'>='",
 518                                              "'DATE_FORMAT($date, \'%Y%m%d\')'",
 519                                               ("date_debut_semaine($annee, $mois, $jour)")),
 520                                         array("'<='",
 521                                               "'DATE_FORMAT($date, \'%Y%m%d\')'",
 522                                               ("date_fin_semaine($annee, $mois, $jour)")));
 523         elseif (count($crit->param) > 2)
 524                 $boucle->where[]= array("'AND'",
 525                                         array("'>='",
 526                                               "'DATE_FORMAT($date, \'%Y%m%d\')'",
 527                                               ("$annee . $mois . $jour")),
 528                                         array("'<='", "'DATE_FORMAT($date, \'%Y%m%d\')'", ("$annee2 . $mois2 . $jour2")));
 529         // sinon on prend tout
 530 }
 531
 532 // http://doc.spip.org/@calculer_critere_parties
 533 function calculer_critere_parties($idb, &$boucles, $crit) {
 534         $boucle = &$boucles[$idb];
 535         $a1 = $crit->param[0];
 536         $a2 = $crit->param[1];
 537         $op = $crit->op;
 538         list($a11,$a12) = calculer_critere_parties_aux($idb, $boucles, $a1);
 539         list($a21,$a22) = calculer_critere_parties_aux($idb, $boucles, $a2);
 540         if (($op== ',')&&(is_numeric($a11) && (is_numeric($a21))))
 541             $boucle->limit = $a11 .',' . $a21;
 542         else {
 543                 $boucle->partie = ($a11 != 'n') ? $a11 : $a12;
 544                 $boucle->total_parties =  ($a21 != 'n') ? $a21 : $a22;
 545                 $boucle->mode_partie = (($op == '/') ? '/' :
 546                         (($a11=='n') ? '-' : '+').(($a21=='n') ? '-' : '+'));
 547         }
 548 }
 549
 550 // http://doc.spip.org/@calculer_critere_parties_aux
 551 function calculer_critere_parties_aux($idb, &$boucles, $param) {
 552         if ($param[0]->type != 'texte')
 553           {
 554             $a1 = calculer_liste(array($param[0]), array('id_mere' => $idb), $boucles, $boucles[$idb]->id_parent);
 555           ereg('^ *(-([0-9]+))? *$', $param[1]->texte, $m);
 556           return array("intval($a1)", ($m[2] ? $m[2] : 0));
 557           } else {
 558             ereg('^ *(([0-9]+)|n) *(- *([0-9]+)? *)?$', $param[0]->texte, $m);
 559             $a1 = $m[1];
 560             if (!$m[3])
 561               return array($a1, 0);
 562             elseif ($m[4])
 563               return array($a1, $m[4]);
 564             else return array($a1,
 565                               calculer_liste(array($param[1]), array(), $boucles[$idb]->id_parent, $boucles));
 566         }
 567 }
 568
 569 //
 570 // La fonction d'aiguillage sur le nom du critere
 571 //
 572
 573 // http://doc.spip.org/@calculer_criteres
 574 function calculer_criteres ($idb, &$boucles) {
 575
 576         foreach($boucles[$idb]->criteres as $crit) {
 577                 $critere = $crit->op;
 578                 // critere personnalise ?
 579                 $f = "critere_".$critere;
 580                 if (!function_exists($f))
 581                         $f .= '_dist';
 582
 583                 // fonction critere standard ?
 584                 if (!function_exists($f)) {
 585                   // double cas particulier repere a l'analyse lexicale
 586                   if (($critere == ",") OR ($critere == '/'))
 587                     $f = 'calculer_critere_parties';
 588                   else  $f = 'calculer_critere_DEFAUT';
 589                 }
 590                 // Applique le critere
 591                 $res = $f($idb, $boucles, $crit);
 592
 593                 // Gestion d'erreur
 594                 if (is_array($res)) erreur_squelette($res);
 595         }
 596 }
 597
 598 // Madeleine de Proust, revision MIT-1958 sqq, revision CERN-1989
 599 // hum, c'est kwoi cette fonxion ?
 600 // http://doc.spip.org/@kwote
 601 function kwote($lisp)
 602 {
 603         if (preg_match(",^(\n//[^\n]*\n)? *'(.*)' *$,", $lisp, $r))
 604                 return $r[1] . "\"" . _q(str_replace(array("\\'","\\\\"),array("'","\\"),$r[2])) . "\"" ;
 605         else
 606                 return "_q($lisp)";
 607 }
 608
 609 // Si on a une liste de valeurs dans #ENV{x}, utiliser la double etoile
 610 // pour faire par exemple {id_article IN #ENV**{liste_articles}}
 611 // http://doc.spip.org/@critere_IN_dist
 612 function critere_IN_dist ($idb, &$boucles, $crit)
 613 {
 614         static $cpt = 0;
 615         list($arg, $op, $val, $col)= calculer_critere_infixe($idb, $boucles, $crit);
 616
 617         $var = '$in' . $cpt++;
 618         $x= "\n\t$var = array();";
 619         foreach ($val as $k => $v) {
 620                 if (preg_match(",^(\n//.*\n)?'(.*)'$,", $v, $r)) {
 621                   // optimiser le traitement des constantes
 622                         if (is_numeric($r[2]))
 623                                 $x .= "\n\t$var" . "[]= $r[2];";
 624                         else
 625                                 $x .= "\n\t$var" . "[]= " . _q($r[2]) . ";";
 626                 } else {
 627                   // Pour permettre de passer des tableaux de valeurs
 628                   // on repere l'utilisation brute de #ENV**{X},
 629                   // c'est-a-dire sa  traduction en ($PILE[0][X]).
 630                   // et on deballe mais en rajoutant l'anti XSS
 631                   $x .= "\n\tif (!(is_array($v)))\n\t\t$var" ."[]= $v;\n\telse $var = array_merge($var, $v);";
 632                 }
 633         }
 634
 635         $boucles[$idb]->in .= $x;
 636
 637         // inserer la negation (cf !...)
 638         if (!$crit->not) {
 639                         $boucles[$idb]->default_order[] = "'cpt$cpt'";
 640                         $op = '<>';
 641         } else $op = '=';
 642
 643         $arg = "FIELD($arg,\" . join(',',array_map('_q', $var)) . \")";
 644         if ($boucles[$idb]->group) $arg = "SUM($arg)";
 645         $boucles[$idb]->select[]=  "$arg AS cpt$cpt";
 646         $op = array("'$op'", "'cpt$cpt'", 0);
 647
 648 //      inserer la condition; exemple: {id_mot ?IN (66, 62, 64)}
 649
 650         $boucles[$idb]->having[]= (!$crit->cond ? $op :
 651           array("'?'",
 652                 calculer_argument_precedent($idb, $col, $boucles),
 653                 $op,
 654                 "''"));
 655 }
 656
 657
 658 # Criteres de comparaison
 659
 660 // http://doc.spip.org/@calculer_critere_DEFAUT
 661 function calculer_critere_DEFAUT($idb, &$boucles, $crit)
 662 {
 663         list($arg, $op, $val, $col)= calculer_critere_infixe($idb, $boucles, $crit);
 664
 665         $where = array("'$op'", "'$arg'", $val[0]);
 666
 667         // inserer la negation (cf !...)
 668
 669         if ($crit->not) $where = array("'NOT'", $where);
 670
 671          // inserer la condition (cf {lang?})
 672
 673         $boucles[$idb]->where[]= (!$crit->cond ? $where :
 674           array("'?'",
 675                 calculer_argument_precedent($idb, $col, $boucles),
 676                 $where,
 677                 "''"));
 678 }
 679
 680 // http://doc.spip.org/@calculer_critere_infixe
 681 function calculer_critere_infixe($idb, &$boucles, $crit) {
 682
 683         global $table_des_tables, $tables_principales, $table_date;
 684         global $exceptions_des_jointures;
 685         $boucle = &$boucles[$idb];
 686         $type = $boucle->type_requete;
 687         $table = $boucle->id_table;
 688
 689         list($fct, $col, $op, $val, $args_sql) =
 690           calculer_critere_infixe_ops($idb, $boucles, $crit);
 691         $col_alias = $col;
 692
 693         // Cas particulier : id_enfant => utiliser la colonne id_objet
 694         if ($col == 'id_enfant')
 695           $col = $boucle->primary;
 696
 697         // Cas particulier : id_secteur pour certaines tables
 698         else if (($col == 'id_secteur')&&($type == 'breves')) {
 699                 $col = 'id_rubrique';
 700         }
 701         else if (($col == 'id_secteur')&& ($type == 'forums')) {
 702                 $table = critere_secteur_forum($idb, $boucles, $val, $crit);
 703         }
 704
 705         // Cas particulier : expressions de date
 706         else if ($table_date[$type]
 707         AND preg_match(",^((age|jour|mois|annee)_relatif|date|mois|annee|jour|heure|age)(_[a-z]+)?$,",
 708         $col, $regs)) {
 709                 list($col, $table) =
 710                 calculer_critere_infixe_date($idb, $boucles, $regs);
 711         }
 712
 713         // HACK : selection des documents selon mode 'image'
 714         // => on cherche en fait 'vignette'
 715         else if ($type == 'documents' AND $col == 'mode')
 716                 $val[0] = str_replace('image', 'vignette', $val[0]);
 717
 718         else  {
 719                 $nom = $table_des_tables[$type];
 720                 list($nom, $desc) = trouver_def_table($nom ? $nom : $type, $boucle);
 721                 if (@!array_key_exists($col, $desc['field'])) {
 722                 $calculer_critere_externe = 'calculer_critere_externe_init';
 723                         // gestion par les plugins des jointures tordues pas automatiques mais necessaires
 724                         if (isset($exceptions_des_jointures[$table][$col])){
 725                                 if (count($exceptions_des_jointures[$table][$col])==3)
 726                                         list($t, $col, $calculer_critere_externe) = $exceptions_des_jointures[$table][$col];
 727                                 else
 728                                         list($t, $col) = $exceptions_des_jointures[$table][$col];
 729                         }
 730                         else if (isset($exceptions_des_jointures[$col]))
 731                           // on ignore la table, quel luxe!
 732                                 list($t, $col) = $exceptions_des_jointures[$col];
 733                         $table = $calculer_critere_externe($boucle, $boucle->jointures, $col, $desc, ($crit->cond OR $op !='='), $t);
 734           }
 735         }
 736         // tag du critere pour permettre aux boucles de modifier leurs requetes par defaut en fonction de ca
 737         $boucles[$idb]->modificateur['criteres'][$col] = true;
 738
 739         // ajout pour le cas special d'une condition sur le champ statut:
 740         // il faut alors interdire a la fonction de boucle
 741         // de mettre ses propres criteres de statut
 742         // http://www.spip.net/@statut (a documenter)
 743         // garde pour compatibilite avec code des plugins anterieurs, mais redondant avec la ligne precedente
 744         if ($col == 'statut') $boucles[$idb]->statut = true;
 745
 746         // ajout pour le cas special des forums
 747         // il faut alors interdire a la fonction de boucle sur forum
 748         // de selectionner uniquement les forums sans pere
 749
 750         elseif ($boucles[$idb]->type_requete == 'forums' AND
 751                 ($col == 'id_parent' OR $col == 'id_forum'))
 752                 $boucles[$idb]->modificateur['plat'] = true;
 753         // inserer le nom de la table SQL devant le nom du champ
 754         if ($table) {
 755                 if ($col[0] == "`")
 756                   $arg = "$table." . substr($col,1,-1);
 757                 else $arg = "$table.$col";
 758         } else $arg = $col;
 759
 760         // inserer la fonction SQL
 761         if ($fct) $arg = "$fct($arg$args_sql)";
 762
 763         return array($arg, $op, $val, $col_alias);
 764 }
 765
 766 // Faute de copie du champ id_secteur dans la table des forums,
 767 // faut le retrouver par jointure
 768 // Pour chaque Row il faudrait tester si le forum est
 769 // d'article, de breve, de rubrique, ou de syndication.
 770 // Pour le moment on ne traite que les articles,
 771 // les 3 autres cas ne marcheront donc pas: ca ferait 4 jointures
 772 // qu'il faut traiter optimalement ou alors pas du tout.
 773
 774 // http://doc.spip.org/@critere_secteur_forum
 775 function critere_secteur_forum($idb, &$boucles, $val, $crit)
 776 {
 777         list($nom, $desc) = trouver_def_table('articles', $boucles[$idb]);
 778         return calculer_critere_externe_init($boucles[$idb], array($nom), 'id_secteur', $desc, $crit->cond, true);
 779 }
 780
 781 // Champ hors table, ca ne peut etre qu'une jointure.
 782 // On cherche la table du champ et on regarde si elle est deja jointe
 783 // Si oui et qu'on y cherche un champ nouveau, pas de jointure supplementaire
 784 // Exemple: criteres {titre_mot=...}{type_mot=...}
 785 // Dans les 2 autres cas ==> jointure
 786 // (Exemple: criteres {type_mot=...}{type_mot=...} donne 2 jointures
 787 // pour selectioner ce qui a exactement ces 2 mots-cles.
 788
 789 // http://doc.spip.org/@calculer_critere_externe_init
 790 function calculer_critere_externe_init(&$boucle, $joints, $col, $desc, $eg, $checkarrivee = false)
 791 {
 792         $cle = trouver_champ_exterieur($col, $joints, $boucle, $checkarrivee);
 793         if ($cle) {
 794                 $t = array_search($cle[0], $boucle->from);
 795                 if ($t) {
 796                   $c = '/\b' . $t  . ".$col" . '\b/';
 797                   if (!trouver_champ($c, $boucle->where)) {
 798                     // mais ca peut etre dans le FIELD pour le Having
 799                     $c = "/FIELD.$t" .".$col,/";
 800                     if (!trouver_champ($c, $boucle->select)) return $t;
 801                   }
 802                 }
 803                 $cle = calculer_jointure($boucle, array($boucle->id_table, $desc), $cle, $col, $eg);
 804                 if ($cle) return "L$cle";
 805         }
 806
 807         erreur_squelette(_T('zbug_info_erreur_squelette'),
 808                         _T('zbug_boucle') .
 809                         " $idb " .
 810                         _T('zbug_critere_inconnu',
 811                             array('critere' => $col)));
 812 }
 813
 814 // http://doc.spip.org/@trouver_champ
 815 function trouver_champ($champ, $where)
 816 {
 817   if (!is_array($where))
 818         return preg_match($champ,$where);
 819   else {
 820          foreach ($where as $clause) {
 821            if (trouver_champ($champ, $clause)) return true;
 822          }
 823          return false;
 824   }
 825 }
 826
 827 // deduction automatique des jointures
 828 // une jointure sur une table avec primary key doit se faire sur celle-ci.
 829
 830 // http://doc.spip.org/@calculer_jointure
 831 function calculer_jointure(&$boucle, $depart, $arrivee, $col='', $cond=false)
 832 {
 833   static $num=array();
 834   $res = calculer_chaine_jointures($boucle, $depart, $arrivee);
 835   if (!$res) return "";
 836
 837   list($dnom,$ddesc) = $depart;
 838   $id_primary = $ddesc['key']['PRIMARY KEY'];
 839         $keys = preg_split('/,\s*/', $id_primary);
 840   $id_table = "";
 841   $cpt = &$num[$boucle->descr['nom']][$boucle->id_boucle];
 842   foreach($res as $r) {
 843     list($d, $a, $j) = $r;
 844     $n = ++$cpt;
 845     $boucle->join[$n]= array(($id_table ? $id_table : $d), $j);
 846     $boucle->from[$id_table = "L$n"] = $a[0];
 847   }
 848
 849   // pas besoin de group by
 850   // (cf http://article.gmane.org/gmane.comp.web.spip.devel/30555)
 851   // si une seule jointure et sur une table avec primary key formee
 852   // de l'index principal et de l'index de jointure (non conditionnel! [6031])
 853   // et operateur d'egalite (http://trac.rezo.net/trac/spip/ticket/477)
 854
 855   if ($pk = (count($boucle->from) == 1) && !$cond) {
 856     if ($pk = $a[1]['key']['PRIMARY KEY']) {
 857         $pk=preg_match("/^$id_primary, *$col$/", $pk) OR
 858           preg_match("/^$col, *$id_primary$/", $pk);
 859     }
 860   }
 861   // la clause Group by est en conflit avec ORDER BY, a completer
 862
 863   if (!$pk)
 864         foreach($keys as $id_prim){
 865                 $id_field = $dnom . '.' . $id_prim;
 866                 if (!in_array($id_field, $boucle->group)) {
 867                         $boucle->group[] = $id_field;
 868                         // postgres exige que le champ pour GROUP soit dans le SELECT
 869                         if (!in_array($id_field, $boucle->select))
 870                         $boucle->select[] = $id_field;
 871                 }
 872         }
 873
 874   $boucle->modificateur['lien'] = true;
 875   return $n;
 876 }
 877
 878 // http://doc.spip.org/@calculer_chaine_jointures
 879 function calculer_chaine_jointures(&$boucle, $depart, $arrivee, $vu=array(), $milieu_prec = false)
 880 {
 881         list($dnom,$ddesc) = $depart;
 882         list($anom,$adesc) = $arrivee;
 883         if (!count($vu))
 884                 $vu[] = $dnom; // ne pas oublier la table de depart
 885
 886         $keys = $ddesc['key'];
 887         if ($v = $adesc['key']['PRIMARY KEY']) {
 888                 unset($adesc['key']['PRIMARY KEY']);
 889                 $akeys = array_merge(preg_split('/,\s*/', $v), $adesc['key']);
 890         }
 891         else $akeys = $adesc['key'];
 892         // priorite a la primaire, qui peut etre multiple
 893         if ($v = (preg_split('/,\s*/', $keys['PRIMARY KEY'])))
 894                 $keys = $v;
 895         $v = array_intersect($keys, $akeys);
 896         if ($v)
 897                 return array(array($dnom, $arrivee, array_shift($v)));
 898         else    {
 899                 $new = $vu;
 900                 foreach($boucle->jointures as $v) {
 901                         if ($v && (!in_array($v,$vu)) &&
 902                             ($def = trouver_def_table($v, $boucle))) {
 903                                 list($table,$join) = $def;
 904                                 $milieu = array_intersect($ddesc['key'], trouver_cles_table($join['key']));
 905                                 $new[] = $v;
 906                                 foreach ($milieu as $k)
 907                                         if ($k!=$milieu_prec) // ne pas repasser par la meme cle car c'est un chemin inutilement long
 908                                         {
 909                                                 $r = calculer_chaine_jointures($boucle, array($v, $join), $arrivee, $new, $k);
 910                                                 if ($r) {
 911                                                         array_unshift($r, array($dnom, $def, $k));
 912                                                         return $r;
 913                                                 }
 914                                         }
 915                         }
 916                 }
 917         }
 918         return array();
 919 }
 920
 921 // applatit les cles multiples
 922
 923 // http://doc.spip.org/@trouver_cles_table
 924 function trouver_cles_table($keys)
 925 {
 926   $res =array();
 927   foreach ($keys as $v) {
 928     if (!strpos($v,","))
 929       $res[$v]=1;
 930     else {
 931       foreach (split(" *, *", $v) as $k) {
 932         $res[$k]=1;
 933       }
 934     }
 935   }
 936   return array_keys($res);
 937 }
 938
 939 // Trouve la description d'une table dans les globales de Spip
 940 // (le prefixe des tables y est toujours 'spip_', son chgt est ulterieur)
 941 // Si on ne la trouve pas, on demande au serveur SQL (marche pas toujours)
 942
 943 // http://doc.spip.org/@trouver_def_table
 944 function trouver_def_table($nom, &$boucle)
 945 {
 946         global $tables_principales, $tables_auxiliaires, $table_des_tables, $tables_des_serveurs_sql;
 947
 948         $nom_table = $nom;
 949         $s = $boucle->sql_serveur;
 950         if (!$s) {
 951                 $s = 'localhost';
 952                 if (in_array($nom, $table_des_tables))
 953                    $nom_table = 'spip_' . $nom;
 954         }
 955
 956         $desc = $tables_des_serveurs_sql[$s];
 957
 958         if (isset($desc[$nom_table]))
 959                 return array($nom_table, $desc[$nom_table]);
 960
 961         include_spip('base/auxiliaires');
 962         $nom_table = 'spip_' . $nom;
 963         if ($desc = $tables_auxiliaires[$nom_table])
 964                 return array($nom_table, $desc);
 965
 966         if ($desc = spip_abstract_showtable($nom, $boucle->sql_serveur))
 967           if (isset($desc['field'])) {
 968       // faudrait aussi prevoir le cas du serveur externe
 969             $tables_principales[$nom] = $desc;
 970             return array($nom, $desc);
 971           }
 972         erreur_squelette(_T('zbug_table_inconnue', array('table' => $nom)),
 973                          $boucle->id_boucle);
 974         }
 975
 976 // http://doc.spip.org/@trouver_champ_exterieur
 977 function trouver_champ_exterieur($cle, $joints, &$boucle, $checkarrivee = false)
 978 {
 979   foreach($joints as $k => $join) {
 980     if ($join && $table = trouver_def_table($join, $boucle)) {
 981       if (array_key_exists($cle, $table[1]['field'])
 982         && ($checkarrivee==false || $checkarrivee==$table[0])) // si on sait ou on veut arriver, il faut que ca colle
 983         return  $table;
 984     }
 985   }
 986   return "";
 987 }
 988
 989 // determine l'operateur et les operandes
 990
 991 // http://doc.spip.org/@calculer_critere_infixe_ops
 992 function calculer_critere_infixe_ops($idb, &$boucles, $crit)
 993 {
 994         // cas d'une valeur comparee a elle-meme ou son referent
 995         if (count($crit->param) == 0)
 996           { $op = '=';
 997             $col = $val = $crit->op;
 998             // Cas special {lang} : aller chercher $GLOBALS['spip_lang']
 999             if ($val == 'lang')
1000               $val = array(kwote('$GLOBALS[\'spip_lang\']'));
1001             else {
1002             // Si id_parent, comparer l'id_parent avec l'id_objet
1003             // de la boucle superieure.... faudrait verifier qu'il existe
1004               // pour eviter l'erreur SQL
1005               if ($val == 'id_parent')
1006                 $val = $boucles[$idb]->primary;
1007               // Si id_enfant, comparer l'id_objet avec l'id_parent
1008               // de la boucle superieure
1009               else if ($val == 'id_enfant')
1010                 $val = 'id_parent';
1011               $val = array(kwote(calculer_argument_precedent($idb, $val, $boucles)));
1012             }
1013           } else {
1014             // comparaison explicite
1015             // le phraseur impose que le premier param soit du texte
1016             $params = $crit->param;
1017             $op = $crit->op;
1018             if ($op == '==') $op = 'REGEXP';
1019             $col = array_shift($params);
1020             $col = $col[0]->texte;
1021
1022             $val = array();
1023             $desc = array('id_mere' => $idb);
1024             $parent = $boucles[$idb]->id_parent;
1025
1026                         // Dans le cas {x=='#DATE'} etc, defaire le travail du phraseur,
1027                         // celui ne sachant pas ce qu'est un critere infixe
1028                         // et a fortiori son 2e operande qu'entoure " ou '
1029                         if (count($params)==1
1030                                         AND count($params[0]==3)
1031                                         AND $params[0][0]->type == 'texte'
1032                                         AND $params[0][2]->type == 'texte'
1033                                         AND ($p=$params[0][0]->texte) == $params[0][2]->texte
1034                                         AND (($p == "'") OR ($p == '"'))
1035                                         AND $params[0][1]->type == 'champ' ) {
1036                                 $val[]= "$p\\$p#" . $params[0][1]->nom_champ . "\\$p$p";
1037                         }
1038                         else
1039                                 foreach ((($op != 'IN') ? $params : calculer_vieux_in($params)) as $p) {
1040                                         $a = calculer_liste($p, $desc, $boucles, $parent);
1041                                         if ($op == 'IN') $val[]= $a;
1042                                         else $val[]=kwote($a);
1043                                 }
1044         }
1045
1046         $fct = $args_sql = '';
1047         // fonction SQL ?
1048         if (preg_match('/^(.*)' . SQL_ARGS . '$/', $col, $m)) {
1049           $fct = $m[1];
1050           preg_match('/^\(([^,]*)(.*)\)$/', $m[2], $a);
1051           $col = $a[1];
1052           if (preg_match('/^(\S*)(\s+AS\s+.*)$/i', $col, $m)) {
1053             $col=$m[1];
1054             $args_sql = $m[2];
1055           }
1056           $args_sql .= $a[2];;
1057         }
1058         return array($fct, $col, $op, $val, $args_sql);
1059 }
1060
1061 // compatibilite ancienne version
1062
1063 // http://doc.spip.org/@calculer_vieux_in
1064 function calculer_vieux_in($params)
1065 {
1066               $deb = $params[0][0];
1067               $k = count($params)-1;
1068               $last = $params[$k];
1069               $j = count($last)-1;
1070               $last = $last[$j];
1071               $n = strlen($last->texte);
1072
1073               if (!(($deb->texte[0] == '(') && ($last->texte[$n-1] == ')')))
1074                 return $params;
1075               $params[0][0]->texte = substr($deb->texte,1);
1076               // attention, on peut avoir k=0,j=0 ==> recalculer
1077               $last = $params[$k][$j];
1078               $n = strlen($last->texte);
1079               $params[$k][$j]->texte = substr($last->texte,0,$n-1);
1080               $newp = array();
1081               foreach($params as $v) {
1082                     if ($v[0]->type != 'texte')
1083                       $newp[] = $v;
1084                     else {
1085                       foreach(split(',', $v[0]->texte) as $x) {
1086                         $t = new Texte;
1087                         $t->texte = $x;
1088                         $newp[] = array($t);
1089                       }
1090                     }
1091               }
1092               return  $newp;
1093 }
1094
1095 // http://doc.spip.org/@calculer_critere_infixe_date
1096 function calculer_critere_infixe_date($idb, &$boucles, $regs)
1097 {
1098   global $table_date, $table_des_tables, $tables_principales;
1099         $boucle = $boucles[$idb];
1100         list(,$col, $rel, $suite) = $regs;
1101         $date_orig = $pred = $table_date[$boucle->type_requete];
1102         if ($suite) {
1103         # Recherche de l'existence du champ date_xxxx,
1104         # si oui choisir ce champ, sinon choisir xxxx
1105                 list(,$t)= trouver_def_table($boucle->type_requete, $boucle);
1106                 if ($t['field']["date$suite"])
1107                         $date_orig = 'date'.$suite;
1108                 else
1109                         $date_orig = substr($suite, 1);
1110                 $pred = $date_orig;
1111         } else if ($rel) $pred = 'date';
1112
1113         $date_compare = "\"' . normaliser_date(" .
1114               calculer_argument_precedent($idb, $pred, $boucles) .
1115               ") . '\"";
1116         $date_orig = $boucle->id_table . '.' . $date_orig;
1117
1118         if ($col == 'date') {
1119                         $col = $date_orig;
1120                         $col_table = '';
1121                 }
1122         else if ($col == 'jour') {
1123                         $col = "DAYOFMONTH($date_orig)";
1124                         $col_table = '';
1125                 }
1126         else if ($col == 'mois') {
1127                         $col = "MONTH($date_orig)";
1128                         $col_table = '';
1129                 }
1130         else if ($col == 'annee') {
1131                         $col = "YEAR($date_orig)";
1132                         $col_table = '';
1133                 }
1134         else if ($col == 'heure') {
1135                         $col = "DATE_FORMAT($date_orig, '%H:%i')";
1136                         $col_table = '';
1137                 }
1138         else if ($col == 'age') {
1139                         $col = calculer_param_date("now()", $date_orig);
1140                         $col_table = '';
1141                 }
1142         else if ($col == 'age_relatif') {
1143                         $col = calculer_param_date($date_compare, $date_orig);
1144                         $col_table = '';
1145                 }
1146         else if ($col == 'jour_relatif') {
1147                         $col = "LEAST(TO_DAYS(" .$date_compare . ")-TO_DAYS(" .
1148                         $date_orig . "), DAYOFMONTH(" . $date_compare .
1149                         ")-DAYOFMONTH(" . $date_orig . ")+30.4368*(MONTH(" .
1150                         $date_compare . ")-MONTH(" . $date_orig .
1151                         "))+365.2422*(YEAR(" . $date_compare . ")-YEAR(" .
1152                         $date_orig . ")))";
1153                         $col_table = '';
1154                 }
1155         else if ($col == 'mois_relatif') {
1156                         $col = "MONTH(" . $date_compare . ")-MONTH(" .
1157                         $date_orig . ")+12*(YEAR(" . $date_compare .
1158                         ")-YEAR(" . $date_orig . "))";
1159                         $col_table = '';
1160                 }
1161         else if ($col == 'annee_relatif') {
1162                         $col = "YEAR(" . $date_compare . ")-YEAR(" .
1163                         $date_orig . ")";
1164                         $col_table = '';
1165                 }
1166         return array($col, $col_table);
1167 }
1168
1169 // http://doc.spip.org/@calculer_param_date
1170 function calculer_param_date($date_compare, $date_orig) {
1171         if (ereg("'\" *\.(.*)\. *\"'", $date_compare, $r)) {
1172           $init = "'\" . (\$x = $r[1]) . \"'";
1173           $date_compare = '\'$x\'';
1174         }
1175         else
1176           $init = $date_compare;
1177
1178         return
1179         "LEAST((UNIX_TIMESTAMP(" .
1180         $init .
1181         ")-UNIX_TIMESTAMP(" .
1182         $date_orig .
1183         "))/86400,\n\tTO_DAYS(" .
1184         $date_compare .
1185         ")-TO_DAYS(" .
1186         $date_orig .
1187         "),\n\tDAYOFMONTH(" .
1188         $date_compare .
1189         ")-DAYOFMONTH(" .
1190         $date_orig .
1191         ")+30.4368*(MONTH(" .
1192         $date_compare .
1193         ")-MONTH(" .
1194         $date_orig .
1195         "))+365.2422*(YEAR(" .
1196         $date_compare .
1197         ")-YEAR(" .
1198         $date_orig .
1199         ")))";
1200 }
1201 ?>