www/ecrire/public/criteres.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 //
  14 // Definition des {criteres} d'une boucle
  15 //
  16
  17 // Une Regexp reperant une chaine produite par le compilateur,
  18 // souvent utilisee pour faire de la concatenation lors de la compilation
  19 // plutot qu'a l'execution, i.e. pour remplacer 'x'.'y' par 'xy'
  20
  21 define('_CODE_QUOTE', ",^(\n//[^\n]*\n)? *'(.*)' *$,");
  22
  23 if (!defined('_ECRIRE_INC_VERSION')) return;
  24
  25 // {racine}
  26 // http://www.spip.net/@racine
  27 // http://doc.spip.org/@critere_racine_dist
  28 function critere_racine_dist($idb, &$boucles, $crit) {
  29         global $exceptions_des_tables;
  30         $not = $crit->not;
  31         $boucle = &$boucles[$idb];
  32         $id_parent = isset($exceptions_des_tables[$boucle->id_table]['id_parent']) ?
  33                 $exceptions_des_tables[$boucle->id_table]['id_parent'] :
  34                 'id_parent';
  35
  36         if ($not)
  37                 return (array('zbug_critere_inconnu', array('critere' => $not . $crit->op)));
  38
  39         $boucle->where[]= array("'='", "'$boucle->id_table." . "$id_parent'", 0);
  40 }
  41
  42 // {exclus}
  43 // http://www.spip.net/@exclus
  44 // http://doc.spip.org/@critere_exclus_dist
  45 function critere_exclus_dist($idb, &$boucles, $crit) {
  46         $not = $crit->not;
  47         $boucle = &$boucles[$idb];
  48         $id = $boucle->primary;
  49
  50         if ($not OR !$id)
  51                 return (array('zbug_critere_inconnu', array('critere' => $not . $crit->op)));
  52         $arg = kwote(calculer_argument_precedent($idb, $id, $boucles));
  53         $boucle->where[]= array("'!='", "'$boucle->id_table." . "$id'", $arg);
  54 }
  55
  56 // {doublons} ou {unique}
  57 // http://www.spip.net/@doublons
  58 // attention: boucle->doublons designe une variable qu'on affecte
  59 // http://doc.spip.org/@critere_doublons_dist
  60 function critere_doublons_dist($idb, &$boucles, $crit) {
  61         $boucle = &$boucles[$idb];
  62         $primary = $boucle->primary;
  63         $type = $boucle->type_requete;
  64         // Dans le cas NOT, la table du doublon peut etre indiquee
  65         // si la table courante a un champ homonyme de sa cle primaire.
  66         // Tres utile pour la table des forums.
  67         if (isset($crit->param[1])) {
  68           $primary = '';
  69           $x = !$crit->not ? '' : calculer_liste($crit->param[1], array(), $boucles, $boucle->id_parent);
  70           # attention au commentaire "// x signes" qui precede
  71           if (preg_match(",^(?:\s*//[^\n]*\n)?'([^']+)'*$,ms", $x, $m))  {
  72             $x = id_table_objet($type = $m[1]);
  73             if (isset($boucle->show['field'][$x]))
  74               $primary = $x; // sinon erreur declenchee ci-dessous
  75           }
  76         }
  77
  78         if (!$primary OR strpos($primary,',')) {
  79                 return (array('zbug_doublon_sur_table_sans_cle_primaire'));
  80         }
  81         $not = ($crit->not ? '' : 'NOT');
  82         $nom = !isset($crit->param[0]) ? "''" : calculer_liste($crit->param[0], array(), $boucles, $boucles[$idb]->id_parent);
  83         // mettre un tableau pour que ce ne soit pas vu comme une constante
  84
  85         $nom = "'" . $type .  "'" .  ($nom == "''" ? '' : " . $nom");
  86
  87         $debutdoub = '$doublons['
  88         .  (!$not ? '' : ($boucle->doublons . "[]= "));
  89
  90         $findoub = "($nom)]";
  91
  92         $debin = "sql_in('" . $boucle->id_table . '.' . $primary . "', ";
  93
  94         $suitin = $debin . $debutdoub;
  95
  96         // si autre critere doublon, fusionner pour avoir un seul In
  97         foreach ($boucle->where as $k => $w) {
  98                 if (strpos($w[0], $suitin) ===0) {
  99                         $boucle->where[$k][0] = $debin . $debutdoub . $findoub . ' . ' . substr($w[0],strlen($debin));
 100                         return;
 101                 }
 102         }
 103         $boucle->where[]= array($suitin . $findoub . ", '" . $not . "')");
 104
 105 # la ligne suivante avait l'intention d'eviter une collecte deja faite
 106 # mais elle fait planter une boucle a 2 critere doublons:
 107 # {!doublons A}{doublons B}
 108 # (de http://article.gmane.org/gmane.comp.web.spip.devel/31034)
 109 #       if ($crit->not) $boucle->doublons = "";
 110 }
 111
 112 // {lang_select}
 113 // http://www.spip.net/@lang_select
 114 // http://doc.spip.org/@critere_lang_select_dist
 115 function critere_lang_select_dist($idb, &$boucles, $crit) {
 116         if (!($param = $crit->param[1][0]->texte)) $param = 'oui';
 117         if ($crit->not) $param = ($param=='oui') ? 'non' : 'oui';
 118         $boucle = &$boucles[$idb];
 119         $boucle->lang_select = $param;
 120 }
 121
 122 // {debut_xxx}
 123 // http://www.spip.net/@debut_
 124 // http://doc.spip.org/@critere_debut_dist
 125 function critere_debut_dist($idb, &$boucles, $crit) {
 126         list($un, $deux) = $crit->param;
 127         $un = $un[0]->texte;
 128         $deux = $deux[0]->texte;
 129         if ($deux) {
 130                 $boucles[$idb]->limit = 'intval($Pile[0]["debut' .
 131                   $un .
 132                   '"]) . ",' .
 133                   $deux .
 134                   '"' ;
 135         } else calculer_critere_DEFAUT_dist($idb, $boucles, $crit);
 136 }
 137
 138 // {pagination}
 139 // {pagination 20}
 140 // {pagination #ENV{pages,5}} etc
 141 // {pagination 20 #ENV{truc,chose}} pour utiliser la variable debut_#ENV{truc,chose}
 142 // http://www.spip.net/@pagination
 143 // http://doc.spip.org/@critere_pagination_dist
 144 function critere_pagination_dist($idb, &$boucles, $crit) {
 145
 146         $boucle = &$boucles[$idb];
 147         // definition de la taille de la page
 148         $pas = !isset($crit->param[0][0]) ? "''" : calculer_liste(array($crit->param[0][0]), array(), $boucles, $boucle->id_parent);
 149
 150         if (!preg_match(_CODE_QUOTE, $pas, $r)) {
 151                 $pas = "((\$a = intval($pas)) ? \$a : 10)";
 152         } else {
 153                 $r = intval($r[2]);
 154                 $pas = strval($r ? $r : 10);
 155         }
 156         $type = !isset($crit->param[0][1]) ? "'$idb'" : calculer_liste(array($crit->param[0][1]), array(), $boucles, $boucle->id_parent);
 157         $debut = ($type[0]!=="'") ? "'debut'.$type"
 158           : ("'debut" .substr($type,1));
 159
 160         $boucle->modificateur['debut_nom'] = $type;
 161         $partie =
 162                  // tester si le numero de page demande est de la forme '@yyy'
 163                  'isset($Pile[0]['.$debut.']) ? $Pile[0]['.$debut.'] : _request('.$debut.");\n"
 164                 ."\tif(substr(\$debut_boucle,0,1)=='@'){\n"
 165                 ."\t\t".'$debut_boucle = $Pile[0]['. $debut.'] = quete_debut_pagination(\''.$boucle->primary.'\',$Pile[0][\'@'.$boucle->primary.'\'] = substr($debut_boucle,1),'.$pas.',$result,'._q($boucle->sql_serveur).');'."\n"
 166                 ."\t\t".'if (!sql_seek($result,0,'._q($boucle->sql_serveur).")){\n"
 167                 ."\t\t\t".'@sql_free($result,'._q($boucle->sql_serveur).");\n"
 168                 ."\t\t\t".'$result = calculer_select($select, $from, $type, $where, $join, $groupby, $orderby, $limit, $having, $table, $id, $connect);'."\n"
 169                 ."\t\t}\n"
 170                 ."\t}\n"
 171                 ."\t".'$debut_boucle = intval($debut_boucle)';
 172
 173
 174         $boucle->total_parties = $pas;
 175         calculer_parties($boucles, $idb, $partie, 'p+');
 176         // ajouter la cle primaire dans le select pour pouvoir gerer la pagination referencee par @id
 177         // sauf si pas de primaire, ou si primaire composee
 178         // dans ce cas, on ne sait pas gerer une pagination indirecte
 179         $t = $boucle->id_table . '.' . $boucle->primary;
 180         if ($boucle->primary
 181                 AND !preg_match('/[,\s]/',$boucle->primary)
 182                 AND !in_array($t, $boucle->select))
 183           $boucle->select[]= $t;
 184 }
 185
 186
 187 // {recherche} ou {recherche susan}
 188 // http://www.spip.net/@recherche
 189 // http://doc.spip.org/@critere_recherche_dist
 190 function critere_recherche_dist($idb, &$boucles, $crit) {
 191
 192         $boucle = &$boucles[$idb];
 193
 194         if (isset($crit->param[0]))
 195                 $quoi = calculer_liste($crit->param[0], array(), $boucles, $boucles[$idb]->id_parent);
 196         else
 197                 $quoi = '@$Pile[0]["recherche"]';
 198
 199         // indiquer si l'on est dans une boucle forum avec le critère {plat} ou {tout}
 200         $plat = "false" ;
 201         if (isset($boucle->modificateur['tout']) OR isset($boucle->modificateur['plat'])) {
 202                 $plat = "true" ;
 203         }
 204
 205         $boucle->hash .= '
 206         // RECHERCHE
 207         $prepare_recherche = charger_fonction(\'prepare_recherche\', \'inc\');
 208         list($rech_select, $rech_where) = $prepare_recherche('.$quoi.', "'.$boucle->id_table.'", "'.$crit->cond.'","' . $boucle->sql_serveur . '", "'.$plat.'");
 209         ';
 210
 211         $t = $boucle->id_table . '.' . $boucle->primary;
 212         if (!in_array($t, $boucles[$idb]->select))
 213           $boucle->select[]= $t; # pour postgres, neuneu ici
 214         $boucle->join['resultats']=array("'".$boucle->id_table."'","'id'","'".$boucle->primary."'");
 215         $boucle->from['resultats']='spip_resultats';
 216         $boucle->select[]= '$rech_select';
 217         //$boucle->where[]= "\$rech_where?'resultats.id=".$boucle->id_table.".".$boucle->primary."':''";
 218
 219         // et la recherche trouve
 220         $boucle->where[]= '$rech_where?$rech_where:\'\'';
 221 }
 222
 223 // {traduction}
 224 // http://www.spip.net/@traduction
 225 //   (id_trad>0 AND id_trad=id_trad(precedent))
 226 //    OR id_article=id_article(precedent)
 227 // http://doc.spip.org/@critere_traduction_dist
 228 function critere_traduction_dist($idb, &$boucles, $crit) {
 229         $boucle = &$boucles[$idb];
 230         $prim = $boucle->primary;
 231         $table = $boucle->id_table;
 232         $arg = kwote(calculer_argument_precedent($idb, 'id_trad', $boucles));
 233         $dprim = kwote(calculer_argument_precedent($idb, $prim, $boucles));
 234         $boucle->where[]=
 235                 array("'OR'",
 236                         array("'AND'",
 237                                 array("'='", "'$table.id_trad'", 0),
 238                                 array("'='", "'$table.$prim'", $dprim)
 239                         ),
 240                         array("'AND'",
 241                                 array("'>'", "'$table.id_trad'", 0),
 242                                 array("'='", "'$table.id_trad'", $arg)
 243                         )
 244                 );
 245 }
 246
 247 // {origine_traduction}
 248 //   (id_trad>0 AND id_article=id_trad) OR (id_trad=0)
 249 // http://www.spip.net/@origine_traduction
 250 // http://doc.spip.org/@critere_origine_traduction_dist
 251 function critere_origine_traduction_dist($idb, &$boucles, $crit) {
 252         $boucle = &$boucles[$idb];
 253         $prim = $boucle->primary;
 254         $table = $boucle->id_table;
 255
 256         $c =
 257         array("'OR'",
 258                 array("'='", "'$table." . "id_trad'", "'$table.$prim'"),
 259                 array("'='", "'$table.id_trad'", "'0'")
 260         );
 261         $boucle->where[]= ($crit->not ? array("'NOT'", $c) : $c);
 262 }
 263
 264 // {meme_parent}
 265 // http://www.spip.net/@meme_parent
 266 // http://doc.spip.org/@critere_meme_parent_dist
 267 function critere_meme_parent_dist($idb, &$boucles, $crit) {
 268         global $exceptions_des_tables;
 269         $boucle = &$boucles[$idb];
 270         $arg = kwote(calculer_argument_precedent($idb, 'id_parent', $boucles));
 271         $id_parent = isset($exceptions_des_tables[$boucle->id_table]['id_parent']) ?
 272                 $exceptions_des_tables[$boucle->id_table]['id_parent'] :
 273                 'id_parent';
 274         $mparent = $boucle->id_table . '.' . $id_parent;
 275
 276         if ($boucle->type_requete == 'rubriques' OR isset($exceptions_des_tables[$boucle->id_table]['id_parent'])) {
 277                 $boucle->where[]= array("'='", "'$mparent'", $arg);
 278
 279         } else if ($boucle->type_requete == 'forums') {
 280                         $boucle->where[]= array("'='", "'$mparent'", $arg);
 281                         $boucle->where[]= array("'>'", "'$mparent'", 0);
 282                         $boucle->modificateur['plat'] = true;
 283         } else erreur_squelette(_T('zbug_info_erreur_squelette'), "{meme_parent} BOUCLE$idb");
 284 }
 285
 286 // {branche ?}
 287 // http://www.spip.net/@branche
 288 // http://doc.spip.org/@critere_branche_dist
 289 function critere_branche_dist($idb, &$boucles, $crit) {
 290
 291         $not = $crit->not;
 292         $boucle = &$boucles[$idb];
 293         $arg = calculer_argument_precedent($idb, 'id_rubrique', $boucles);
 294
 295         //Trouver une jointure
 296         $desc = $boucle->show;
 297         //Seulement si necessaire
 298         if (!array_key_exists('id_rubrique', $desc['field'])) {
 299                 $cle = trouver_jointure_champ('id_rubrique', $boucle);
 300         } else $cle = $boucle->id_table;
 301
 302         $c = "sql_in('$cle" . ".id_rubrique', calcul_branche_in($arg)"
 303           . ($not ? ", 'NOT'" : '') . ")";
 304         $boucle->where[]= !$crit->cond ? $c :
 305           ("($arg ? $c : " . ($not ? "'0=1'" : "'1=1'") .')');
 306 }
 307
 308 // {logo} liste les objets qui ont un logo
 309 // http://doc.spip.org/@critere_logo_dist
 310 function critere_logo_dist($idb, &$boucles, $crit) {
 311
 312         $not = $crit->not;
 313         $boucle = &$boucles[$idb];
 314
 315         $c = "sql_in('" .
 316           $boucle->id_table . '.' . $boucle->primary
 317           . "', lister_objets_avec_logos('". $boucle->primary ."'), '')";
 318         if ($crit->cond) $c = "($arg ? $c : 1)";
 319
 320         if ($not)
 321                 $boucle->where[]= array("'NOT'", $c);
 322         else
 323                 $boucle->where[]= $c;
 324 }
 325
 326 // c'est la commande SQL "GROUP BY"
 327 // par exemple <boucle(articles){fusion lang}>
 328 // http://doc.spip.org/@critere_fusion_dist
 329 function critere_fusion_dist($idb,&$boucles, $crit) {
 330         if ($t = isset($crit->param[0])) {
 331                 $t = $crit->param[0];
 332                 if ($t[0]->type == 'texte') {
 333                         $t = $t[0]->texte;
 334                         if (preg_match("/^(.*)\.(.*)$/", $t, $r)) {
 335                                 $t = table_objet_sql($r[1]);
 336                                 $t = array_search($t, $boucles[$idb]->from);
 337                                 if ($t) $t .= '.' . $r[2];
 338                         }
 339                 } else { $t = '".'
 340                     . calculer_critere_arg_dynamique($idb, $boucles, $t)
 341                     . '."';
 342                 }
 343         }
 344         if ($t) {
 345                 $boucles[$idb]->group[] = $t;
 346                 if (!in_array($t, $boucles[$idb]->select))
 347                     $boucles[$idb]->select[] = $t;
 348         } else
 349                 return (array('zbug_critere_inconnu', array('critere' => $crit->op . ' ?')));
 350 }
 351
 352 // c'est la commande SQL "COLLATE"
 353 // qui peut etre appliquee sur les order by, group by, where like ...
 354 // http://doc.spip.org/@critere_collecte_dist
 355 function critere_collecte_dist($idb,&$boucles, $crit) {
 356         if (isset($crit->param[0])) {
 357                 $_coll = calculer_liste($crit->param[0], array(), $boucles, $boucles[$idb]->id_parent);
 358                 $boucle = $boucles[$idb];
 359                 $boucle->modificateur['collate'] = "($_coll ?' COLLATE '.$_coll:'')";
 360     $n = count($boucle->order);
 361     if ($n && (strpos($boucle->order[$n-1],'COLLATE')===false))
 362         $boucle->order[$n-1] .= " . " . $boucle->modificateur['collate'];
 363         } else
 364                 return (array('zbug_critere_inconnu', array('critere' => $crit->op . " $n")));
 365 }
 366
 367 // http://doc.spip.org/@calculer_critere_arg_dynamique
 368 function calculer_critere_arg_dynamique($idb, &$boucles, $crit, $suffix='')
 369 {
 370         $boucle = $boucles[$idb];
 371         $alt = "('" . $boucle->id_table . '.\' . $x' . $suffix . ')';
 372         $var = '$champs_' . $idb;
 373         $desc = (strpos($boucle->in, "static $var =") !== false);
 374         if (!$desc) {
 375                 $desc = $boucle->show['field'];
 376                 $desc = implode(',',array_map('_q',array_keys($desc)));
 377                 $boucles[$idb]->in .= "\n\tstatic $var = array(" . $desc .");";
 378         }
 379         if ($desc) $alt = "(in_array(\$x, $var)  ? $alt :(\$x$suffix))";
 380         $arg = calculer_liste($crit, array(), $boucles, $boucle->id_parent);
 381         return  "((\$x = preg_replace(\"/\\W/\",'', $arg)) ? $alt : '')";
 382 }
 383 // Tri : {par xxxx}
 384 // http://www.spip.net/@par
 385 // http://doc.spip.org/@critere_par_dist
 386 function critere_par_dist($idb, &$boucles, $crit) {
 387         return critere_parinverse($idb, $boucles, $crit) ;
 388 }
 389
 390 // http://doc.spip.org/@critere_parinverse
 391 function critere_parinverse($idb, &$boucles, $crit, $sens='') {
 392         global $exceptions_des_jointures;
 393         $boucle = &$boucles[$idb];
 394         if ($crit->not) $sens = $sens ? "" : " . ' DESC'";
 395         $collecte = (isset($boucle->modificateur['collecte']))?" . ".$boucle->modificateur['collecte']:"";
 396
 397         foreach ($crit->param as $tri) {
 398
 399           $order = $fct = ""; // en cas de fonction SQL
 400         // tris specifies dynamiquement
 401           if ($tri[0]->type != 'texte') {
 402                 // calculer le order dynamique qui verifie les champs
 403                         $order = calculer_critere_arg_dynamique($idb, $boucles, $tri, $sens);
 404                         // et si ce n'est fait, ajouter un champ 'hasard'
 405                         // pour supporter 'hasard' comme tri dynamique
 406                         $par = "rand()";
 407                         $parha = $par . " AS hasard";
 408                         if (!in_array($parha, $boucle->select))
 409                                 $boucle->select[]= $parha;
 410           } else {
 411               $par = array_shift($tri);
 412               $par = $par->texte;
 413     // par multi champ
 414               if (preg_match(",^multi[\s]*(.*)$,",$par, $m)) {
 415                   $texte = $boucle->id_table . '.' . trim($m[1]);
 416                   $boucle->select[] =  "\".sql_multi('".$texte."', \$GLOBALS['spip_lang']).\"" ;
 417                   $order = "'multi'";
 418         // par num champ(, suite)
 419               } else if (preg_match(",^num (.*)$,m",$par, $m)) {
 420                   $texte = '0+' . $boucle->id_table . '.' . trim($m[1]);
 421                   $suite = calculer_liste($tri, array(), $boucles, $boucle->id_parent);
 422                   if ($suite !== "''")
 423                     $texte = "\" . ((\$x = $suite) ? ('$texte' . \$x) : '0')" . " . \"";
 424                   $as = 'num' .($boucle->order ? count($boucle->order) : "");
 425                   $boucle->select[] = $texte . " AS $as";
 426                   $order = "'$as'";
 427               } else {
 428                 if (!preg_match(",^" . CHAMP_SQL_PLUS_FONC . '$,is', $par, $match)) {
 429                         return (array('zbug_critere_inconnu', array('critere' => $crit->op . " $par")));
 430                 } else {
 431                 if (count($match)>2) { $par = substr($match[2],1,-1); $fct = $match[1]; }
 432         // par hasard
 433                 if ($par == 'hasard') {
 434                         $par = "rand()";
 435                         $boucle->select[]= $par . " AS alea";
 436                         $order = "'alea'";
 437                 }
 438         // par titre_mot ou type_mot voire d'autres
 439                 else if (isset($exceptions_des_jointures[$par])) {
 440                         list($table, $champ) =  $exceptions_des_jointures[$par];
 441                         $order = critere_par_joint($table, $champ, $boucle, $idb);
 442                         if (!$order)
 443                                 return (array('zbug_critere_inconnu', array('critere' => $crit->op . " $par")));
 444                 }
 445                 else if ($par == 'date'
 446                 AND isset($GLOBALS['table_date'][$boucle->type_requete])) {
 447                         $m = $GLOBALS['table_date'][$boucle->type_requete];
 448                         $order = "'".$boucle->id_table ."." . $m . "'";
 449                 }
 450                 // par champ. Verifier qu'ils sont presents.
 451                 elseif (preg_match("/^([^,]*)\.(.*)$/", $par, $r)) {
 452                   // cas du tri sur champ de jointure explicite
 453                         $t = array_search($r[1], $boucle->from);
 454                         if (!$t) {
 455                                 $t = trouver_champ_exterieur($r[2], array($r[1]), $boucle);
 456                                 $t = array_search(@$t[0], $boucle->from);
 457                         }
 458                         if (!$t) {
 459                                 return (array('zbug_critere_inconnu', array('critere' => $crit->op . " $par")));
 460                         } else  $order = "'" . $t . '.' . $r[2] . "'";
 461                 } else {
 462                         $desc = $boucle->show;
 463                         if ($desc['field'][$par])
 464                                 $par = $boucle->id_table.".".$par;
 465                   // sinon tant pis, ca doit etre un champ synthetise (cf points)
 466                         $order = "'$par'";
 467                 }
 468               }
 469               }
 470           }
 471           if (preg_match('/^\'([^"]*)\'$/', $order, $m)) {
 472               $t = $m[1];
 473               if (strpos($t,'.') AND !in_array($t, $boucle->select)) {
 474                 $boucle->select[] = $t;
 475               }
 476           } else $sens ='';
 477
 478           if ($fct) {
 479             if (preg_match("/^\s*'(.*)'\s*$/", $order, $r))
 480               $order = "'$fct(" . $r[1] . ")'";
 481             else $order = "'$fct(' . $order . ')'";
 482           }
 483           $t = $order . $collecte . $sens;
 484           if (preg_match("/^(.*)'\s*\.\s*'([^']*')$/", $t, $r))
 485               $t = $r[1] . $r[2];
 486           $boucle->order[] = $t;
 487         }
 488 }
 489
 490 // http://doc.spip.org/@critere_par_joint
 491 function critere_par_joint($table, $champ, &$boucle, $idb)
 492 {
 493         $t = array_search($table, $boucle->from);
 494         if (!$t) $t = trouver_jointure_champ($champ, $boucle);
 495         return !$t ? '' : ("'" . $t . '.' . $champ . "'");
 496 }
 497
 498 // {inverse}
 499 // http://www.spip.net/@inverse
 500
 501 // http://doc.spip.org/@critere_inverse_dist
 502 function critere_inverse_dist($idb, &$boucles, $crit) {
 503
 504         $boucle = &$boucles[$idb];
 505         // Classement par ordre inverse
 506         if ($crit->not)
 507                 critere_parinverse($idb, $boucles, $crit);
 508         else
 509           {
 510                 $order = "' DESC'";
 511         // Classement par ordre inverse fonction eventuelle de #ENV{...}
 512                 if (isset($crit->param[0])){
 513                         $critere = calculer_liste($crit->param[0], array(), $boucles, $boucles[$idb]->id_parent);
 514                         $order = "(($critere)?' DESC':'')";
 515                 }
 516
 517                 $n = count($boucle->order);
 518                 if (!$n) {
 519                   if (isset($boucle->default_order[0]))
 520                         $boucle->default_order[0] .=  ' . " DESC"';
 521                   else
 522                         $boucle->default_order[] =  ' DESC';
 523                 }
 524                 else {
 525                         $t = $boucle->order[$n-1] . " . $order";
 526                         if (preg_match("/^(.*)'\s*\.\s*'([^']*')$/", $t, $r))
 527                                 $t = $r[1] . $r[2];
 528                         $boucle->order[$n-1] = $t;
 529                 }
 530           }
 531 }
 532
 533 // http://doc.spip.org/@critere_agenda_dist
 534 function critere_agenda_dist($idb, &$boucles, $crit)
 535 {
 536         $params = $crit->param;
 537
 538         if (count($params) < 1)
 539                 return array('zbug_critere_inconnu', array('critere' => $crit->op . " ?"));
 540
 541         $boucle = &$boucles[$idb];
 542         $parent = $boucle->id_parent;
 543         $fields = $boucle->show['field'];
 544
 545         $date = array_shift($params);
 546         $type = array_shift($params);
 547
 548         // la valeur $type doit etre connue a la compilation
 549         // donc etre forcement reduite a un litteral unique dans le source
 550
 551         $type = $type[0]->texte;
 552
 553         // La valeur date doit designer un champ de la table SQL.
 554         // Si c'est un litteral unique dans le source, verifier a la compil,
 555         // sinon synthetiser le test de verif pour execution ulterieure
 556         // On prendra arbitrairement le premier champ si test negatif.
 557
 558         if ((count($date) == 1)  AND ($date[0]->type == 'texte')) {
 559                 $date = $date[0]->texte;
 560                 if (!isset($fields[$date]))
 561                   return array('zbug_critere_inconnu', array('critere' => $crit->op . " " . $date));
 562         } else  {
 563                 $a = calculer_liste($date, array(), $boucles, $parent);
 564                 $noms = array_keys($fields);
 565                 $defaut = $noms[0];
 566                 $noms = join(" ", $noms);
 567                 # bien laisser 2 espaces avant $nom pour que strpos<>0
 568                 $cond = "(\$a=strval($a))AND\nstrpos(\"  $noms \",\" \$a \")";
 569                 $date = "'.(($cond)\n?\$a:\"$defaut\").'";
 570         }
 571         $annee = $params ? array_shift($params) : "";
 572         $annee = "\n" . 'sprintf("%04d", ($x = ' .
 573                 calculer_liste($annee, array(), $boucles, $parent) .
 574                 ') ? $x : date("Y"))';
 575
 576         $mois =  $params ? array_shift($params) : "";
 577         $mois = "\n" . 'sprintf("%02d", ($x = ' .
 578                 calculer_liste($mois, array(), $boucles, $parent) .
 579                 ') ? $x : date("m"))';
 580
 581         $jour =  $params ? array_shift($params) : "";
 582         $jour = "\n" . 'sprintf("%02d", ($x = ' .
 583                 calculer_liste($jour, array(), $boucles, $parent) .
 584                 ') ? $x : date("d"))';
 585
 586         $annee2 = $params ? array_shift($params) : "";
 587         $annee2 = "\n" . 'sprintf("%04d", ($x = ' .
 588                 calculer_liste($annee2, array(), $boucles, $parent) .
 589                 ') ? $x : date("Y"))';
 590
 591         $mois2 =  $params ? array_shift($params) : "";
 592         $mois2 = "\n" . 'sprintf("%02d", ($x = ' .
 593                 calculer_liste($mois2, array(), $boucles, $parent) .
 594                 ') ? $x : date("m"))';
 595
 596         $jour2 =  $params ? array_shift($params) : "";
 597         $jour2 = "\n" .  'sprintf("%02d", ($x = ' .
 598                 calculer_liste($jour2, array(), $boucles, $parent) .
 599                 ') ? $x : date("d"))';
 600
 601         $date = $boucle->id_table . ".$date";
 602
 603         if ($type == 'jour')
 604                 $boucle->where[]= array("'='", "'DATE_FORMAT($date, \'%Y%m%d\')'",
 605                                         ("$annee . $mois . $jour"));
 606         elseif ($type == 'mois')
 607                 $boucle->where[]= array("'='", "'DATE_FORMAT($date, \'%Y%m\')'",
 608                                         ("$annee . $mois"));
 609         elseif ($type == 'semaine')
 610                 $boucle->where[]= array("'AND'",
 611                                         array("'>='",
 612                                              "'DATE_FORMAT($date, \'%Y%m%d\')'",
 613                                               ("date_debut_semaine($annee, $mois, $jour)")),
 614                                         array("'<='",
 615                                               "'DATE_FORMAT($date, \'%Y%m%d\')'",
 616                                               ("date_fin_semaine($annee, $mois, $jour)")));
 617         elseif (count($crit->param) > 2)
 618                 $boucle->where[]= array("'AND'",
 619                                         array("'>='",
 620                                               "'DATE_FORMAT($date, \'%Y%m%d\')'",
 621                                               ("$annee . $mois . $jour")),
 622                                         array("'<='", "'DATE_FORMAT($date, \'%Y%m%d\')'", ("$annee2 . $mois2 . $jour2")));
 623         // sinon on prend tout
 624 }
 625
 626 // http://doc.spip.org/@calculer_critere_parties
 627 function calculer_critere_parties($idb, &$boucles, $crit) {
 628         $boucle = &$boucles[$idb];
 629         $a1 = $crit->param[0];
 630         $a2 = $crit->param[1];
 631         $op = $crit->op;
 632
 633         list($a11,$a12) = calculer_critere_parties_aux($idb, $boucles, $a1);
 634         list($a21,$a22) = calculer_critere_parties_aux($idb, $boucles, $a2);
 635         if (($op== ',')&&(is_numeric($a11) && (is_numeric($a21))))
 636             $boucle->limit = $a11 .',' . $a21;
 637         else {
 638                 $boucle->total_parties =  ($a21 != 'n') ? $a21 : $a22;
 639                 $partie = ($a11 != 'n') ? $a11 : $a12;
 640                 $mode = (($op == '/') ? '/' :
 641                         (($a11=='n') ? '-' : '+').(($a21=='n') ? '-' : '+'));
 642                 calculer_parties($boucles, $idb, $partie,  $mode);
 643         }
 644 }
 645
 646 //
 647 // Code specifique aux criteres {pagination}, {1,n} {n/m} etc
 648 //
 649
 650 function calculer_parties(&$boucles, $id_boucle, $debut, $mode) {
 651
 652         $total_parties = $boucles[$id_boucle]->total_parties;
 653         preg_match(",([+-/p])([+-/])?,", $mode, $regs);
 654         list(,$op1,$op2) = $regs;
 655         $nombre_boucle = "\$Numrows['$id_boucle']['total']";
 656         // {1/3}
 657         if ($op1 == '/') {
 658                 $pmoins1 = is_numeric($debut) ? ($debut-1) : "($debut-1)";
 659                 $totpos = is_numeric($total_parties) ? ($total_parties) :
 660                   "($total_parties ? $total_parties : 1)";
 661                 $fin = "ceil(($nombre_boucle * $debut )/$totpos) - 1";
 662                 $debut = !$pmoins1 ? 0 : "ceil(($nombre_boucle * $pmoins1)/$totpos);";
 663         } else {
 664                 // cas {n-1,x}
 665                 if ($op1 == '-') $debut = "$nombre_boucle - $debut;";
 666
 667                 // cas {x,n-1}
 668                 if ($op2 == '-') {
 669                         $fin = '$debut_boucle + '.$nombre_boucle.' - '
 670                         . (is_numeric($total_parties) ? ($total_parties+1) :
 671                            ($total_parties . ' - 1'));
 672                 } else {
 673                         // {x,1} ou {pagination}
 674                         $fin = '$debut_boucle'
 675                         . (is_numeric($total_parties) ?
 676                              (($total_parties==1) ? "" :(' + ' . ($total_parties-1))):
 677                              ('+' . $total_parties . ' - 1'));
 678                 }
 679
 680                 // {pagination}, gerer le debut_xx=-1 pour tout voir
 681                 if ($op1 == 'p') {
 682                         $debut .= ";\n  \$debut_boucle = ((\$tout=(\$debut_boucle == -1))?0:(\$debut_boucle))";
 683                         $debut .= ";\n  \$debut_boucle = max(0,min(\$debut_boucle,floor(($nombre_boucle-1)/($total_parties))*($total_parties)))";
 684                         $fin = "(\$tout ? $nombre_boucle : $fin)";
 685                 }
 686         }
 687
 688         // Notes :
 689         // $debut_boucle et $fin_boucle sont les indices SQL du premier
 690         // et du dernier demandes dans la boucle : 0 pour le premier,
 691         // n-1 pour le dernier ; donc total_boucle = 1 + debut - fin
 692         // Utiliser min pour rabattre $fin_boucle sur total_boucle.
 693
 694         $boucles[$id_boucle]->mode_partie = "\n\t"
 695         . '$debut_boucle = ' . $debut .   ";\n  "
 696         . '$fin_boucle = min(' . $fin . ", \$Numrows['$id_boucle']['total'] - 1);\n     "
 697         . '$Numrows[\''.$id_boucle. "']['grand_total'] = \$Numrows['$id_boucle']['total'];\n    "
 698         . '$Numrows[\''.$id_boucle.'\']["total"] = max(0,$fin_boucle - $debut_boucle + 1);'
 699         . "\n\tif (\$debut_boucle>0 AND \$debut_boucle < \$Numrows['$id_boucle']['grand_total'] AND sql_seek(\$result,\$debut_boucle,"._q($boucles[$id_boucle]->sql_serveur).",'continue'))\n\t\t\$Numrows['$id_boucle']['compteur_boucle'] = \$debut_boucle;\n\t";
 700
 701         $boucles[$id_boucle]->partie = "
 702                 if (\$Numrows['$id_boucle']['compteur_boucle'] <= \$debut_boucle) continue;
 703                 if (\$Numrows['$id_boucle']['compteur_boucle']-1 > \$fin_boucle) break;";
 704 }
 705
 706 // http://doc.spip.org/@calculer_critere_parties_aux
 707 function calculer_critere_parties_aux($idb, &$boucles, $param) {
 708         if ($param[0]->type != 'texte')
 709           {
 710             $a1 = calculer_liste(array($param[0]), array('id_mere' => $idb), $boucles, $boucles[$idb]->id_parent);
 711           preg_match(',^ *(-([0-9]+))? *$,', $param[1]->texte, $m);
 712           return array("intval($a1)", ($m[2] ? $m[2] : 0));
 713           } else {
 714             preg_match(',^ *(([0-9]+)|n) *(- *([0-9]+)? *)?$,', $param[0]->texte, $m);
 715             $a1 = $m[1];
 716             if (!@$m[3])
 717               return array($a1, 0);
 718             elseif ($m[4])
 719               return array($a1, $m[4]);
 720             else return array($a1,
 721                               calculer_liste(array($param[1]), array(), $boucles[$idb]->id_parent, $boucles));
 722         }
 723 }
 724
 725 //
 726 // La fonction d'aiguillage sur le nom du critere dans leur liste
 727 // Si l'une au moins des fonctions associees retourne une erreur
 728 // (i.e. un tableau), on propage l'information
 729 // Sinon, ne retourne rien (affectation directe dans l'arbre)
 730
 731 // http://doc.spip.org/@calculer_criteres
 732 function calculer_criteres ($idb, &$boucles)
 733 {
 734         $msg = '';
 735         $boucle = $boucles[$idb];
 736         $table = strtoupper($boucle->id_table);
 737         $defaut = charger_fonction('DEFAUT', 'calculer_critere');
 738         // s'il y avait une erreur de syntaxe, propager cette info
 739         if (!is_array($boucle->criteres)) return array();
 740         foreach($boucle->criteres as $crit) {
 741                 $critere = $crit->op;
 742                 // critere personnalise ?
 743                 if ((!function_exists($f="critere_".$table."_".$critere))
 744                 AND (!function_exists($f=$f."_dist"))
 745                 AND (!function_exists($f="critere_".$critere))
 746                 AND (!function_exists($f=$f."_dist"))   ) {
 747                         // fonction critere standard
 748                         $f = $defaut;
 749                 }
 750                 // compile le critere
 751                 $res = $f($idb, $boucles, $crit);
 752
 753                 // Gestion centralisee des erreurs pour pouvoir propager
 754                 if (is_array($res)) {
 755                         $msg = $res;
 756                         erreur_squelette($msg, $boucle);
 757                 }
 758         }
 759         return $msg;
 760 }
 761
 762 // Madeleine de Proust, revision MIT-1958 sqq, revision CERN-1989
 763 // hum, c'est kwoi cette fonxion ?
 764 // http://doc.spip.org/@kwote
 765 function kwote($lisp)
 766 {
 767         if (preg_match(_CODE_QUOTE, $lisp, $r))
 768                 return $r[1] . "\"" . sql_quote(str_replace(array("\\'","\\\\"),array("'","\\"),$r[2])) . "\"" ;
 769         else
 770                 return "sql_quote($lisp)";
 771 }
 772
 773 // Si on a une liste de valeurs dans #ENV{x}, utiliser la double etoile
 774 // pour faire par exemple {id_article IN #ENV**{liste_articles}}
 775 // http://doc.spip.org/@critere_IN_dist
 776 function critere_IN_dist ($idb, &$boucles, $crit)
 777 {
 778         $r = calculer_critere_infixe($idb, $boucles, $crit);
 779         if (!$r) {
 780                 return (array('zbug_critere_inconnu', array('critere' => $crit->op . " ?")));
 781         }
 782         list($arg, $op, $val, $col, $where_complement) = $r;
 783
 784         $in = critere_IN_cas($idb, $boucles, $crit->not ? 'NOT' : ($crit->exclus? 'exclus' :  ''), $arg, $op, $val, $col);
 785 //      inserer la condition; exemple: {id_mot ?IN (66, 62, 64)}
 786         $where = $in;
 787         if ($crit->cond) {
 788                 $pred = calculer_argument_precedent($idb, $col, $boucles);
 789                 $where = array("'?'",$pred,     $where,"''");
 790                 if ($where_complement) // condition annexe du type "AND (objet='article')"
 791                         $where_complement = array("'?'",$pred,  $where_complement,"''");
 792         }
 793         if ($crit->exclus)
 794                 if (!preg_match(",^L[0-9]+[.],",$arg))
 795                         $where = array("'NOT'", $where);
 796                 else
 797                         // un not sur un critere de jointure se traduit comme un NOT IN avec une sous requete
 798                         $where = array("'NOT'",array("'IN'","'".$boucles[$idb]->id_table.".".$boucles[$idb]->primary."'" ,array("'SELF'","'".$boucles[$idb]->id_table.".".$boucles[$idb]->primary."'",$where)));
 799
 800         $boucles[$idb]->where[] = $where;
 801         if ($where_complement) // condition annexe du type "AND (objet='article')"
 802                 $boucles[$idb]->where[]= $where_complement;
 803 }
 804
 805 // http://doc.spip.org/@critere_IN_cas
 806 function critere_IN_cas ($idb, &$boucles, $crit2, $arg, $op, $val, $col)
 807 {
 808         static $num = array();
 809         $descr = $boucles[$idb]->descr;
 810         $cpt = &$num[$descr['nom']][$descr['gram']][$idb];
 811
 812         $var = '$in' . $cpt++;
 813         $x= "\n\t$var = array();";
 814         foreach ($val as $k => $v) {
 815                 if (preg_match(",^(\n//.*\n)?'(.*)'$,", $v, $r)) {
 816                   // optimiser le traitement des constantes
 817                         if (is_numeric($r[2]))
 818                                 $x .= "\n\t$var" . "[]= $r[2];";
 819                         else
 820                                 $x .= "\n\t$var" . "[]= " . sql_quote($r[2]) . ";";
 821                 } else {
 822                   // Pour permettre de passer des tableaux de valeurs
 823                   // on repere l'utilisation brute de #ENV**{X},
 824                   // c'est-a-dire sa  traduction en ($PILE[0][X]).
 825                   // et on deballe mais en rajoutant l'anti XSS
 826                   $x .= "\n\tif (!(is_array(\$a = ($v))))\n\t\t$var" ."[]= \$a;\n\telse $var = array_merge($var, \$a);";
 827                 }
 828         }
 829
 830         $boucles[$idb]->in .= $x;
 831
 832         // inserer le tri par defaut selon les ordres du IN ...
 833         // avec une ecriture de type FIELD qui degrade les performances (du meme ordre qu'un rexgexp)
 834         // et que l'on limite donc strictement aux cas necessaires :
 835         // si ce n'est pas un !IN, et si il n'y a pas d'autre order dans la boucle
 836         if (!$crit2){
 837                 $boucles[$idb]->default_order[] = "((!sql_quote($var) OR sql_quote($var)===\"''\") ? 0 : ('FIELD($arg,' . sql_quote($var) . ')'))";
 838         }
 839
 840         return "sql_in('$arg',sql_quote($var)".($crit2=='NOT'?",'NOT'":"").")";
 841 }
 842
 843 # Criteres de comparaison
 844
 845 // http://doc.spip.org/@calculer_critere_DEFAUT
 846 function calculer_critere_DEFAUT_dist($idb, &$boucles, $crit)
 847 {
 848         // double cas particulier {0,1} et {1/2} repere a l'analyse lexicale
 849         if (($crit->op == ",") OR ($crit->op == '/'))
 850                 return calculer_critere_parties($idb, $boucles, $crit);
 851
 852         $r = calculer_critere_infixe($idb, $boucles, $crit);
 853
 854         if (!$r) {
 855                 return (array('zbug_critere_inconnu', array('critere' => $crit->op )));
 856         } else calculer_critere_DEFAUT_args($idb, $boucles, $crit, $r);
 857 }
 858
 859 function calculer_critere_DEFAUT_args($idb, &$boucles, $crit, $args)
 860 {
 861         list($arg, $op, $val, $col, $where_complement) = $args;
 862
 863         $where = array("'$op'", "'$arg'", $val[0]);
 864
 865         // inserer la negation (cf !...)
 866
 867         if ($crit->not) $where = array("'NOT'", $where);
 868         if ($crit->exclus)
 869                 if (!preg_match(",^L[0-9]+[.],",$arg))
 870                         $where = array("'NOT'", $where);
 871                 else
 872                         // un not sur un critere de jointure se traduit comme un NOT IN avec une sous requete
 873                         $where = array("'NOT'",array("'IN'","'".$boucles[$idb]->id_table.".".$boucles[$idb]->primary."'" ,array("'SELF'","'".$boucles[$idb]->id_table.".".$boucles[$idb]->primary."'",$where)));
 874
 875         // inserer la condition (cf {lang?})
 876         // traiter a part la date, elle est mise d'office par SPIP,
 877         if ($crit->cond) {
 878                 $pred = calculer_argument_precedent($idb, $col, $boucles);
 879                 if ($col == "date" OR $col == "date_redac") {
 880                         if($pred == "\$Pile[0]['".$col."']") {
 881                           $pred = "(\$Pile[0]['{$col}_default']?'':$pred)";
 882                         }
 883                 }
 884
 885                 if ($op == '=' AND !$crit->not)
 886                   $where = array("'?'", "(is_array($pred))",
 887                                  critere_IN_cas ($idb, $boucles, 'COND', $arg, $op, array($pred), $col),
 888                                  $where);
 889                 $where = array("'?'", "!(is_array($pred)?count($pred):strlen($pred))","''", $where);
 890                 if ($where_complement) // condition annexe du type "AND (objet='article')"
 891                         $where_complement = array("'?'", "!$pred","''", $where_complement);
 892         }
 893
 894         $boucles[$idb]->where[]= $where;
 895         if ($where_complement) // condition annexe du type "AND (objet='article')"
 896                 $boucles[$idb]->where[]= $where_complement;
 897 }
 898
 899 // http://doc.spip.org/@calculer_critere_infixe
 900 function calculer_critere_infixe($idb, &$boucles, $crit) {
 901
 902         global $table_criteres_infixes;
 903         global $exceptions_des_jointures, $exceptions_des_tables;
 904
 905         $boucle = &$boucles[$idb];
 906         $type = $boucle->type_requete;
 907         $table = $boucle->id_table;
 908         $desc = $boucle->show;
 909         $date = array();
 910
 911         list($fct, $col, $op, $val, $args_sql) =
 912           calculer_critere_infixe_ops($idb, $boucles, $crit);
 913
 914         $col_alias = $col;
 915         $where_complement =false;
 916
 917         // Cas particulier : id_enfant => utiliser la colonne id_objet
 918         if ($col == 'id_enfant')
 919           $col = $boucle->primary;
 920
 921         // Cas particulier : id_parent => verifier les exceptions de tables
 922         if ($col == 'id_parent')
 923           $col = isset($exceptions_des_tables[$table]['id_parent']) ?
 924                 $exceptions_des_tables[$table]['id_parent'] :
 925                 'id_parent';
 926
 927         // Cas particulier : id_secteur pour certaines tables
 928         else if (($col == 'id_secteur')&&($type == 'breves')) {
 929                 $col = 'id_rubrique';
 930         }
 931         // et possibilite de gerer un critere secteur sur des tables de plugins (ie forums)
 932         else if (($col == 'id_secteur') AND ($critere_secteur = charger_fonction("critere_secteur_$type","public",true))) {
 933                 $table = $critere_secteur($idb, $boucles, $val, $crit);
 934         }
 935
 936         // cas id_article=xx qui se mappe en id_objet=xx AND objet=article
 937         else if (count(trouver_champs_decomposes($col,$desc))>1){
 938                 $e = decompose_champ_id_objet($col);
 939                 $col = array_shift($e);
 940                 $where_complement = primary_doublee($e, $table);
 941
 942         }
 943         // Cas particulier : expressions de date
 944         else if ($date = tester_param_date($boucle->type_requete, $col)) {
 945                 $col = calculer_critere_infixe_date($idb, $boucles, $date);
 946                 $table = '';
 947         }
 948         else if (preg_match('/^(.*)\.(.*)$/', $col, $r)) {
 949                   list(,$table, $col) = $r;
 950                   $col_alias = $col;
 951                   $table = calculer_critere_externe_init($boucle, array($table), $col, $desc, ($crit->cond OR $op !='='), true);
 952                   if (!$table) return '';
 953         }
 954         elseif (@!array_key_exists($col, $desc['field'])) {
 955                 $r = calculer_critere_infixe_externe($boucle, $crit, $op, $desc, $col, $col_alias, $table);
 956                 if (!$r) return '';
 957                 list($col, $col_alias, $table, $where_complement) = $r;
 958         }
 959         // Si la colonne SQL est numerique ou le critere est une date relative
 960         // virer les guillemets eventuels qui sont refuses par certains SQL
 961         // Ne pas utiliser intval, PHP tronquant les Bigint de SQL
 962
 963         if (($op == '=' OR in_array($op, $table_criteres_infixes))
 964         AND (($desc AND isset($desc['field'][$col]) AND sql_test_int($desc['field'][$col]))
 965              OR ($date AND strpos($date[0], '_relatif')))) {
 966                 if (preg_match("/^\"'(-?\d+)'\"$/", $val[0], $r))
 967                         $val[0] = $r[1];
 968                 elseif (preg_match('/^sql_quote[(](.*?)(,[^)]*)?[)]\s*$/', $val[0], $r)) {
 969                   $r = $r[1] . ($r[2] ? $r[2] : ",''") . ",'int'";
 970                   $val[0] = "sql_quote($r)";
 971                 }
 972         }
 973         // Indicateur pour permettre aux fonctionx boucle_X de modifier
 974         // leurs requetes par defaut, notamment le champ statut
 975         // Ne pas confondre champs de la table principale et des jointures
 976         if ($table === $boucle->id_table) {
 977                 $boucles[$idb]->modificateur['criteres'][$col] = true;
 978                 if ($col_alias!=$col)
 979                         $boucles[$idb]->modificateur['criteres'][$col_alias] = true;
 980         }
 981
 982         // ajout pour le cas special d'une condition sur le champ statut:
 983         // il faut alors interdire a la fonction de boucle
 984         // de mettre ses propres criteres de statut
 985         // http://www.spip.net/@statut (a documenter)
 986         // garde pour compatibilite avec code des plugins anterieurs, mais redondant avec la ligne precedente
 987         if ($col == 'statut') $boucles[$idb]->statut = true;
 988
 989         // ajout pour le cas special des forums
 990         // il faut alors interdire a la fonction de boucle sur forum
 991         // de selectionner uniquement les forums sans pere
 992
 993         elseif ($boucles[$idb]->type_requete == 'forums' AND
 994                 ($col == 'id_parent' OR $col == 'id_forum'))
 995                 $boucles[$idb]->modificateur['plat'] = true;
 996         // inserer le nom de la table SQL devant le nom du champ
 997         if ($table) {
 998                 if ($col[0] == "`")
 999                   $arg = "$table." . substr($col,1,-1);
1000                 else $arg = "$table.$col";
1001         } else $arg = $col;
1002
1003         // inserer la fonction SQL
1004         if ($fct) $arg = "$fct($arg$args_sql)";
1005
1006         return array($arg, $op, $val, $col_alias, $where_complement);
1007 }
1008
1009 function calculer_critere_infixe_externe(&$boucle, $crit, $op, $desc, $col, $col_alias, $table)
1010 {
1011         global $exceptions_des_jointures;
1012         $where = '';
1013
1014         $calculer_critere_externe = 'calculer_critere_externe_init';
1015         // gestion par les plugins des jointures tordues
1016         // pas automatiques mais necessaires
1017         if (is_array($exceptions_des_jointures[$table])) {
1018
1019                 $t = $exceptions_des_jointures[$table];
1020                 $index = isset($t[$col])
1021                 ?  $t[$col] : (isset($t['']) ? $t[''] : array());
1022
1023                 if (count($index)==3)
1024                         list($t, $col, $calculer_critere_externe) = $index;
1025                 elseif (count($index)==2)
1026                         list($t, $col) = $t[$col];
1027                 elseif (count($index)==1){
1028                         list($calculer_critere_externe) = $index;
1029                         $t = $table;
1030                 }
1031                 else
1032                         $t=''; // jointure non declaree. La trouver.
1033         }
1034         elseif (isset($exceptions_des_jointures[$col]))
1035                 list($t, $col) = $exceptions_des_jointures[$col];
1036         else $t =''; // jointure non declaree. La trouver.
1037
1038         $table = $calculer_critere_externe($boucle, $boucle->jointures, $col, $desc, ($crit->cond OR $op !='='), $t);
1039
1040         if (!$table) return '';
1041
1042         list($nom, $desc) = trouver_champ_exterieur($col, $boucle->jointures, $boucle);
1043         if (count(trouver_champs_decomposes($col,$desc))>1){
1044                 $col_alias = $col; // id_article devient juste le nom d'origine
1045                 $e = decompose_champ_id_objet($col);
1046                 $col = array_shift($e);
1047                 $where = primary_doublee($e, $table);
1048         }
1049
1050         return array($col, $col_alias, $table, $where);
1051 }
1052
1053 // Ne pas appliquer sql_quote lors de la compilation,
1054 // car on ne connait pas le serveur SQL, donc s'il faut \' ou ''
1055
1056 // http://doc.spip.org/@primary_doublee
1057 function primary_doublee($decompose, $table)
1058 {
1059         $e1 = reset($decompose);
1060         $e2 = "sql_quote('" . end($decompose) ."')";
1061         return array("'='","'$table.". $e1 ."'",$e2);
1062 }
1063
1064 // Faute de copie du champ id_secteur dans la table des forums,
1065 // faut le retrouver par jointure
1066 // Pour chaque Row il faudrait tester si le forum est
1067 // d'article, de breve, de rubrique, ou de syndication.
1068 // Pour le moment on ne traite que les articles,
1069 // les 3 autres cas ne marcheront donc pas: ca ferait 4 jointures
1070 // qu'il faut traiter optimalement ou alors pas du tout.
1071
1072 // http://doc.spip.org/@critere_secteur_forum
1073 function critere_secteur_forum($idb, &$boucles, $val, $crit)
1074 {
1075         static $trouver_table;
1076         if (!$trouver_table)
1077                 $trouver_table = charger_fonction('trouver_table', 'base');
1078
1079         $desc = $trouver_table('articles', $boucles[$idb]->sql_serveur);
1080         return calculer_critere_externe_init($boucles[$idb], array($desc['table']), 'id_secteur', $desc, $crit->cond, true);
1081 }
1082
1083 // Champ hors table, ca ne peut etre qu'une jointure.
1084 // On cherche la table du champ et on regarde si elle est deja jointe
1085 // Si oui et qu'on y cherche un champ nouveau, pas de jointure supplementaire
1086 // Exemple: criteres {titre_mot=...}{type_mot=...}
1087 // Dans les 2 autres cas ==> jointure
1088 // (Exemple: criteres {type_mot=...}{type_mot=...} donne 2 jointures
1089 // pour selectioner ce qui a exactement ces 2 mots-cles.
1090
1091 // http://doc.spip.org/@calculer_critere_externe_init
1092 function calculer_critere_externe_init(&$boucle, $joints, $col, $desc, $eg, $checkarrivee = false)
1093 {
1094         $cle = trouver_champ_exterieur($col, $joints, $boucle, $checkarrivee);
1095         if (!$cle) return '';
1096         $t = array_search($cle[0], $boucle->from);
1097         // transformer eventuellement id_xx en (id_objet,objet)
1098         $cols = trouver_champs_decomposes($col,$cle[1]);
1099         if ($t) {
1100                         $joindre = false;
1101                         foreach($cols as $col){
1102                           $c = '/\b' . $t  . ".$col" . '\b/';
1103                           if (trouver_champ($c, $boucle->where)) $joindre = true;
1104                           else {
1105                             // mais ca peut etre dans le FIELD pour le Having
1106                             $c = "/FIELD.$t" .".$col,/";
1107                             if (trouver_champ($c, $boucle->select)) $joindre = true;
1108                           }
1109                         }
1110                   if (!$joindre) return $t;
1111         }
1112         return calculer_jointure($boucle, array($boucle->id_table, $desc), $cle, $cols, $eg);
1113
1114 }
1115
1116 // http://doc.spip.org/@trouver_champ
1117 function trouver_champ($champ, $where)
1118 {
1119   if (!is_array($where))
1120         return preg_match($champ,$where);
1121   else {
1122          foreach ($where as $clause) {
1123            if (trouver_champ($champ, $clause)) return true;
1124          }
1125          return false;
1126   }
1127 }
1128
1129
1130 // determine l'operateur et les operandes
1131
1132 // http://doc.spip.org/@calculer_critere_infixe_ops
1133 function calculer_critere_infixe_ops($idb, &$boucles, $crit)
1134 {
1135         // cas d'une valeur comparee a elle-meme ou son referent
1136         if (count($crit->param) == 0)
1137           { $op = '=';
1138             $col = $val = $crit->op;
1139             if (preg_match('/^(.*)\.(.*)$/', $col, $r)) $val = $r[2];
1140             // Cas special {lang} : aller chercher $GLOBALS['spip_lang']
1141             if ($val == 'lang')
1142               $val = array(kwote('$GLOBALS[\'spip_lang\']'));
1143             else {
1144             // Si id_parent, comparer l'id_parent avec l'id_objet
1145             // de la boucle superieure.... faudrait verifier qu'il existe
1146               // pour eviter l'erreur SQL
1147               if ($val == 'id_parent')
1148                 $val = $boucles[$idb]->primary;
1149               // Si id_enfant, comparer l'id_objet avec l'id_parent
1150               // de la boucle superieure
1151               else if ($val == 'id_enfant')
1152                 $val = 'id_parent';
1153         // un critere conditionnel sur date est traite a part
1154         // car la date est mise d'office par SPIP,
1155               $val = calculer_argument_precedent($idb, $val, $boucles);
1156               if ($crit->cond AND ($col == "date" OR $col == "date_redac")) {
1157                       if($val == "\$Pile[0]['".$col."']") {
1158                         $val = "(\$Pile[0]['{$col}_default']?'':$val)";
1159                       }
1160               }
1161               $val = array(kwote($val));
1162             }
1163           } else {
1164             // comparaison explicite
1165             // le phraseur impose que le premier param soit du texte
1166                 $params = $crit->param;
1167                 $op = $crit->op;
1168                 if ($op == '==') $op = 'REGEXP';
1169                 $col = array_shift($params);
1170                 $col = $col[0]->texte;
1171
1172                 $val = array();
1173                 $desc = array('id_mere' => $idb);
1174                 $parent = $boucles[$idb]->id_parent;
1175
1176                 // Dans le cas {x=='#DATE'} etc, defaire le travail du phraseur,
1177                 // celui ne sachant pas ce qu'est un critere infixe
1178                 // et a fortiori son 2e operande qu'entoure " ou '
1179                 if (count($params)==1
1180                 AND count($params[0]==3)
1181                 AND $params[0][0]->type == 'texte'
1182                 AND @$params[0][2]->type == 'texte'
1183                 AND ($p=$params[0][0]->texte) == $params[0][2]->texte
1184                 AND (($p == "'") OR ($p == '"'))
1185                 AND $params[0][1]->type == 'champ' ) {
1186                         $val[]= "$p\\$p#" . $params[0][1]->nom_champ . "\\$p$p";
1187                 } else
1188                         foreach ((($op != 'IN') ? $params : calculer_vieux_in($params)) as $p) {
1189                                 $a = calculer_liste($p, $desc, $boucles, $parent);
1190                                 if ($op == 'IN') $val[]= $a;
1191                                 else $val[]=kwote($a);
1192                         }
1193         }
1194
1195         $fct = $args_sql = '';
1196         // fonction SQL ?
1197         if (preg_match('/^(.*)' . SQL_ARGS . '$/', $col, $m)) {
1198           $fct = $m[1];
1199           preg_match('/^\(([^,]*)(.*)\)$/', $m[2], $a);
1200           $col = $a[1];
1201           if (preg_match('/^(\S*)(\s+AS\s+.*)$/i', $col, $m)) {
1202             $col=$m[1];
1203             $args_sql = $m[2];
1204           }
1205           $args_sql .= $a[2];;
1206         }
1207
1208         return array($fct, $col, $op, $val, $args_sql);
1209 }
1210
1211 // compatibilite ancienne version
1212
1213 // http://doc.spip.org/@calculer_vieux_in
1214 function calculer_vieux_in($params)
1215 {
1216               $deb = $params[0][0];
1217               $k = count($params)-1;
1218               $last = $params[$k];
1219               $j = count($last)-1;
1220               $last = $last[$j];
1221               $n = strlen($last->texte);
1222
1223               if (!(($deb->texte[0] == '(') && ($last->texte[$n-1] == ')')))
1224                 return $params;
1225               $params[0][0]->texte = substr($deb->texte,1);
1226               // attention, on peut avoir k=0,j=0 ==> recalculer
1227               $last = $params[$k][$j];
1228               $n = strlen($last->texte);
1229               $params[$k][$j]->texte = substr($last->texte,0,$n-1);
1230               $newp = array();
1231               foreach($params as $v) {
1232                     if ($v[0]->type != 'texte')
1233                       $newp[] = $v;
1234                     else {
1235                       foreach(explode(',', $v[0]->texte) as $x) {
1236                         $t = new Texte;
1237                         $t->texte = $x;
1238                         $newp[] = array($t);
1239                       }
1240                     }
1241               }
1242               return  $newp;
1243 }
1244
1245 // http://doc.spip.org/@calculer_critere_infixe_date
1246 function calculer_critere_infixe_date($idb, &$boucles, $regs)
1247 {
1248         global $table_date;
1249         $boucle = $boucles[$idb];
1250         $col = $regs[1];
1251         $date_orig = $pred = isset($table_date[$boucle->type_requete])?$table_date[$boucle->type_requete]:'date';
1252         if (isset($regs[3]) AND $suite=$regs[3]) {
1253         # Recherche de l'existence du champ date_xxxx,
1254         # si oui choisir ce champ, sinon choisir xxxx
1255                 $t = $boucle->show;
1256                 if ($t['field']["date$suite"])
1257                         $date_orig = 'date'.$suite;
1258                 else
1259                         $date_orig = substr($suite, 1);
1260                 $pred = $date_orig;
1261         }
1262         else
1263           if (isset($regs[2]) AND $rel=$regs[2]) $pred = 'date';
1264
1265         $date_compare = "\"' . normaliser_date(" .
1266               calculer_argument_precedent($idb, $pred, $boucles) .
1267               ") . '\"";
1268         $date_orig = $boucle->id_table . '.' . $date_orig;
1269
1270         switch ($col) {
1271                 case 'date':
1272                         $col = $date_orig;
1273                         break;
1274                 case 'jour':
1275                         $col = "DAYOFMONTH($date_orig)";
1276                         break;
1277                 case 'mois':
1278                         $col = "MONTH($date_orig)";
1279                         break;
1280                 case 'annee':
1281                         $col = "YEAR($date_orig)";
1282                         break;
1283                 case 'heure':
1284                         $col = "DATE_FORMAT($date_orig, '%H:%i')";
1285                         break;
1286                 case 'age':
1287                         $col = calculer_param_date("NOW()", $date_orig);
1288                         break;
1289                 case 'age_relatif':
1290                         $col = calculer_param_date($date_compare, $date_orig);
1291                         break;
1292                 case 'jour_relatif':
1293                         $col = "LEAST(TO_DAYS(" .$date_compare . ")-TO_DAYS(" .
1294                         $date_orig . "), DAYOFMONTH(" . $date_compare .
1295                         ")-DAYOFMONTH(" . $date_orig . ")+30.4368*(MONTH(" .
1296                         $date_compare . ")-MONTH(" . $date_orig .
1297                         "))+365.2422*(YEAR(" . $date_compare . ")-YEAR(" .
1298                         $date_orig . ")))";
1299                         break;
1300                 case 'mois_relatif':
1301                         $col = "MONTH(" . $date_compare . ")-MONTH(" .
1302                         $date_orig . ")+12*(YEAR(" . $date_compare .
1303                         ")-YEAR(" . $date_orig . "))";
1304                         break;
1305                 case 'annee_relatif':
1306                         $col = "YEAR(" . $date_compare . ")-YEAR(" .
1307                         $date_orig . ")";
1308                         break;
1309         }
1310         return $col;
1311 }
1312
1313 // http://doc.spip.org/@calculer_param_date
1314 function calculer_param_date($date_compare, $date_orig) {
1315         if (preg_match(",'\" *\.(.*)\. *\"',", $date_compare, $r)) {
1316           $init = "'\" . (\$x = $r[1]) . \"'";
1317           $date_compare = '\'$x\'';
1318         }
1319         else
1320           $init = $date_compare;
1321
1322         return
1323         "LEAST((UNIX_TIMESTAMP(" .
1324         $init .
1325         ")-UNIX_TIMESTAMP(" .
1326         $date_orig .
1327         "))/86400,\n\tTO_DAYS(" .
1328         $date_compare .
1329         ")-TO_DAYS(" .
1330         $date_orig .
1331         "),\n\tDAYOFMONTH(" .
1332         $date_compare .
1333         ")-DAYOFMONTH(" .
1334         $date_orig .
1335         ")+30.4368*(MONTH(" .
1336         $date_compare .
1337         ")-MONTH(" .
1338         $date_orig .
1339         "))+365.2422*(YEAR(" .
1340         $date_compare .
1341         ")-YEAR(" .
1342         $date_orig .
1343         ")))";
1344 }
1345
1346 // http://doc.spip.org/@tester_param_date
1347 function tester_param_date($type, $col)
1348 {
1349         global $table_date;
1350         if (isset($table_date[$type])
1351         AND preg_match(",^((age|jour|mois|annee)_relatif|date|mois|annee|jour|heure|age)(_[a-z]+)?$,", $col, $regs))
1352           return $regs;
1353         else return false;
1354 }
1355
1356 ?>