www/ecrire/public/phraser_html.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 if (!defined('_ECRIRE_INC_VERSION')) return;
  15
  16 # Ce fichier transforme un squelette en un tableau d'objets de classe Boucle
  17 # il est charge par un include calcule
  18 # pour permettre differentes syntaxes en entree
  19
  20 define('BALISE_BOUCLE', '<BOUCLE');
  21 define('BALISE_FIN_BOUCLE', '</BOUCLE');
  22 define('BALISE_PRE_BOUCLE', '<B');
  23 define('BALISE_POST_BOUCLE', '</B');
  24 define('BALISE_ALT_BOUCLE', '<//B');
  25
  26 define('TYPE_RECURSIF', 'boucle');
  27 define('SPEC_BOUCLE','/\s*\(\s*([^\s?)]+)(\s*[^)?]*)([?]?)\)/');
  28 define('NOM_DE_BOUCLE', "[0-9]+|[-_][-_.a-zA-Z0-9]*");
  29 # ecriture alambiquee pour rester compatible avec les hexadecimaux des vieux squelettes
  30 define('NOM_DE_CHAMP', "#((" . NOM_DE_BOUCLE . "):)?(([A-F]*[G-Z_][A-Z_0-9]*)|[A-Z_]+)(\*{0,2})");
  31 define('CHAMP_ETENDU', '/\[([^]\[]*)\(' . NOM_DE_CHAMP . '([^[)]*\)[^]\[]*)\]/S');
  32
  33 define('BALISE_INCLURE','/<INCLU[DR]E[[:space:]]*(\(([^)]*)\))?/S');
  34 define('BALISE_POLYGLOTTE',',<multi>(.*)</multi>,Uims');
  35 define('BALISE_IDIOMES',',<:(([a-z0-9_]+):)?([a-z0-9_]*)({([^\|=>]*=[^\|>]*)})?((\|[^>]*)?:>),iS');
  36 define('BALISE_IDIOMES_ARGS', '@^\s*([^= ]*)\s*=\s*((' . NOM_DE_CHAMP . '[{][^}]*})?[^,]*)\s*,?\s*@s');
  37
  38 define('SQL_ARGS', '(\([^)]*\))');
  39 define('CHAMP_SQL_PLUS_FONC', '`?([A-Z_\/][A-Z_\/0-9.]*)' . SQL_ARGS . '?`?');
  40
  41 // http://doc.spip.org/@phraser_inclure
  42 function phraser_inclure($texte, $ligne, $result) {
  43
  44         while (preg_match(BALISE_INCLURE, $texte, $match)) {
  45                 $p = strpos($texte,$match[0]);
  46                 $debut = substr($texte, 0, $p);
  47                 if ($p) $result = phraser_idiomes($debut, $ligne, $result);
  48                 $ligne +=  substr_count($debut, "\n");
  49                 $champ = new Inclure;
  50                 $champ->ligne = $ligne;
  51                 $ligne += substr_count($match[0], "\n");
  52                 $fichier = @$match[2];
  53                 # assurer ici la migration .php3 => .php
  54                 # et de l'ancienne syntaxe INCLURE(page.php3) devenue surperflue
  55                 if (preg_match(',^(.*[.]php)3$,', $fichier, $r)) {
  56                         $fichier = $r[1];
  57                 }
  58                 $champ->texte = ($fichier !== 'page.php') ? $fichier : '';
  59                 $texte = substr($texte, $p+strlen($match[0]));
  60                 // on assimile {var=val} a une liste de un argument sans fonction
  61                 phraser_args($texte,"/>","",$result,$champ);
  62                 if (!$champ->texte OR count($champ->param) > 1) {
  63                         if (!function_exists('normaliser_inclure'))
  64                                 include_spip('public/normaliser');
  65                         normaliser_inclure($champ);
  66                 }
  67                 $texte = substr($champ->apres, strpos($champ->apres, '>')+1);
  68                 $champ->apres = "";
  69                 $texte = preg_replace(',^</INCLU[DR]E>,', '', $texte);
  70                 $result[] = $champ;
  71         }
  72         return (($texte==="") ? $result : phraser_idiomes($texte, $ligne, $result));
  73 }
  74
  75 // http://doc.spip.org/@phraser_polyglotte
  76 function phraser_polyglotte($texte,$ligne, $result) {
  77
  78         if (preg_match_all(BALISE_POLYGLOTTE, $texte, $m, PREG_SET_ORDER))
  79         foreach ($m as $match) {
  80                 $p = strpos($texte, $match[0]);
  81                 $debut = substr($texte, 0, $p);
  82                 if ($p) {
  83                         $champ = new Texte;
  84                         $champ->texte = $debut;
  85                         $champ->ligne = $ligne;
  86                         $result[] = $champ;
  87                         $ligne += substr_count($champ->texte, "\n");
  88                 }
  89
  90                 $champ = new Polyglotte;
  91                 $champ->ligne = $ligne;
  92                 $ligne += substr_count($match[0], "\n");
  93                 $lang = '';
  94                 $bloc = $match[1];
  95                 $texte = substr($texte,$p+strlen($match[0]));
  96                 while (preg_match("/^[[:space:]]*([^[{]*)[[:space:]]*[[{]([a-z_]+)[]}](.*)$/si", $bloc, $regs)) {
  97                   $trad = $regs[1];
  98                   if ($trad OR $lang)
  99                         $champ->traductions[$lang] = $trad;
 100                   $lang = $regs[2];
 101                   $bloc = $regs[3];
 102                 }
 103                 $champ->traductions[$lang] = $bloc;
 104                 $result[] = $champ;
 105         }
 106         if ($texte!=="") {
 107                         $champ = new Texte;
 108                         $champ->texte = $texte;
 109                         $champ->ligne = $ligne;
 110                         $result[] = $champ;
 111         }
 112         return $result;
 113 }
 114
 115
 116 // Reperer les balises de traduction
 117 // <:module:chaine{arg1=texte1,arg2=#BALISE}|filtre1{texte2,#BALISE}|filtre2:>
 118 // chaine peut etre vide si =texte1 est present et arg1 est vide
 119 // sinon ce n'est pas un idiome
 120 // http://doc.spip.org/@phraser_idiomes
 121 function phraser_idiomes($texte,$ligne,$result) {
 122         while (preg_match(BALISE_IDIOMES, $texte, $match)) {
 123                 $p = strpos($texte, $match[0]);
 124                 $ko = (!$match[3] && ($match[5][0]!=='='));
 125                 $debut = substr($texte, 0, $p + ($ko ? strlen($match[0]) : 0));
 126                 if ($debut) $result = phraser_champs($debut, $ligne, $result);
 127                 $texte = substr($texte,$p+strlen($match[0]));
 128                 $ligne += substr_count($debut, "\n");
 129                 if ($ko) continue; // faux idiome
 130                 $champ = new Idiome;
 131                 $champ->ligne = $ligne;
 132                 $ligne += substr_count($match[0], "\n");
 133                 // Stocker les arguments de la balise de traduction
 134                 $args = array();
 135                 $largs = $match[5];
 136                 while (preg_match(BALISE_IDIOMES_ARGS, $largs, $r)) {
 137                         $args[$r[1]] = phraser_champs($r[2], 0, array());
 138                         $largs = substr($largs, strlen($r[0]));
 139                 }
 140                 $champ->arg = $args;
 141                 $champ->nom_champ = strtolower($match[3]);
 142                 $champ->module = $match[2];
 143                 // pas d'imbrication pour les filtres sur langue
 144                 phraser_args(@$match[7], ":", '', array(), $champ);
 145                 $result[] = $champ;
 146         }
 147         if ($texte!=="")  $result = phraser_champs($texte,$ligne,$result);
 148         return $result;
 149 }
 150
 151 // http://doc.spip.org/@phraser_champs
 152 function phraser_champs($texte,$ligne,$result) {
 153         while (preg_match("/".NOM_DE_CHAMP."/S", $texte, $match)) {
 154           $p = strpos($texte, $match[0]);
 155           $suite = substr($texte,$p+strlen($match[0]));
 156           if ($match[5] || (strpos($suite[0], "[0-9]") === false)) {
 157                 $debut = substr($texte, 0, $p);
 158                 if ($p) $result = phraser_polyglotte($debut, $ligne, $result);
 159                 $ligne += substr_count($debut, "\n");
 160                 $champ = new Champ;
 161                 $champ->ligne = $ligne;
 162                 $ligne += substr_count($match[0], "\n");
 163                 $champ->nom_boucle = $match[2];
 164                 $champ->nom_champ = $match[3];
 165                 $champ->etoile = $match[5];
 166
 167                 if ($suite[0] == '{') {
 168                         phraser_arg($suite, '', array(), $champ);
 169                 // ce ltrim est une ereur de conception
 170                 // mais on le conserve par souci de compatibilite
 171                         $texte = ltrim($suite);
 172                 // Il faudrait le normaliser dans l'arbre de syntaxe abstraite
 173                 // pour faire sauter ce cas particulier a la decompilation.
 174                 /* Ce qui suit est malheureusement incomplet pour cela:
 175                         if ($n = (strlen($suite) - strlen($texte))) {
 176                                 $champ->apres = array(new Texte);
 177                                 $champ->apres[0]->texte = substr($suite,0,$n);
 178                         }
 179                 */
 180                 } else $texte = $suite;
 181                 phraser_vieux($champ);
 182                 $result[] = $champ;
 183           } else {
 184             // faux champ
 185             $result = phraser_polyglotte (substr($texte, 0, $p+1), $ligne, $result);
 186             $texte = (substr($texte, $p+1));
 187           }
 188         }
 189         if ($texte!=="") $result = phraser_polyglotte($texte, $ligne, $result);
 190         return $result;
 191 }
 192
 193 // Gestion des imbrications:
 194 // on cherche les [..] les plus internes et on les remplace par une chaine
 195 // %###N@ ou N indexe un tableau comportant le resultat de leur analyse
 196 // on recommence tant qu'il y a des [...] en substituant a l'appel suivant
 197
 198 // http://doc.spip.org/@phraser_champs_etendus
 199 function phraser_champs_etendus($texte, $ligne,$result) {
 200         if ($texte==="") return $result;
 201         $sep = '##';
 202         while (strpos($texte,$sep)!== false)
 203                 $sep .= '#';
 204         return array_merge($result, phraser_champs_interieurs($texte, $ligne, $sep, array()));
 205 }
 206
 207 //  Analyse les filtres d'un champ etendu et affecte le resultat
 208 // renvoie la liste des lexemes d'origine augmentee
 209 // de ceux trouves dans les arguments des filtres (rare)
 210 // sert aussi aux arguments des includes et aux criteres de boucles
 211 // Tres chevelu
 212
 213 // http://doc.spip.org/@phraser_args
 214 function phraser_args($texte, $fin, $sep, $result, &$pointeur_champ) {
 215   $texte = ltrim($texte);
 216   while (($texte!=="") && strpos($fin, $texte[0]) === false) {
 217         $result = phraser_arg($texte, $sep, $result, $pointeur_champ);
 218         $texte = ltrim($texte);
 219   }
 220 # mettre ici la suite du texte,
 221 # notamment pour que l'appelant vire le caractere fermant si besoin
 222   $pointeur_champ->apres = $texte;
 223   return $result;
 224 }
 225
 226 // http://doc.spip.org/@phraser_arg
 227 function phraser_arg(&$texte, $sep, $result, &$pointeur_champ) {
 228         preg_match(",^(\|?[^}{)|]*)(.*)$,ms", $texte, $match);
 229         $suite = ltrim($match[2]);
 230         $fonc = trim($match[1]);
 231         if ($fonc && $fonc[0] == "|") $fonc = ltrim(substr($fonc,1));
 232         $res = array($fonc);
 233         $err_f = '';
 234         // cas du filtre sans argument ou du critere /
 235         if (($suite && ($suite[0] != '{')) || ($fonc  && $fonc[0] == '/')) {
 236                 // si pas d'argument, alors il faut une fonction ou un double |
 237                 if (!$match[1]) {
 238                         $err_f = array('zbug_erreur_filtre', array('filtre' => $texte));
 239                         erreur_squelette($err_f, $pointeur_champ);
 240                         $texte = '';
 241                 } else  $texte = $suite;
 242                 if ($err_f) $pointeur_champ->param = false;
 243                 elseif ($fonc!=='') $pointeur_champ->param[] = $res;
 244                 // pour les balises avec faux filtres qui boudent ce dur larbeur
 245                 $pointeur_champ->fonctions[] = array($fonc, '');
 246                 return $result;
 247         }
 248         $args = ltrim(substr($suite,1)); // virer le '(' initial
 249         $collecte = array();
 250         while ($args && $args[0] != '}') {
 251                 if ($args[0] == '"')
 252                         preg_match ('/^(")([^"]*)(")(.*)$/ms', $args, $regs);
 253                 else if ($args[0] == "'")
 254                         preg_match ("/^(')([^']*)(')(.*)$/ms", $args, $regs);
 255                 else {
 256                   preg_match("/^([[:space:]]*)([^,([{}]*([(\[{][^])}]*[])}])?[^,}]*)([,}].*)$/ms", $args, $regs);
 257                   if (!strlen($regs[2]))
 258                     {
 259                         $err_f = array('zbug_erreur_filtre', array('filtre' => $args));
 260                         erreur_squelette($err_f, $pointeur_champ);
 261                         $champ = new Texte;
 262                         $champ->apres = $champ->avant = $args = "";
 263                         break;
 264                       }
 265                 }
 266                 $arg = $regs[2];
 267                 if (trim($regs[1])) {
 268                         $champ = new Texte;
 269                         $champ->texte = $arg;
 270                         $champ->apres = $champ->avant = $regs[1];
 271                         $result[] = $champ;
 272                         $collecte[] = $champ;
 273                         $args = ltrim($regs[count($regs)-1]);
 274                 } else {
 275                         if (!preg_match("/".NOM_DE_CHAMP ."([{|])/", $arg, $r)) {
 276                                 // 0 est un aveu d'impuissance. A completer
 277                                 $arg = phraser_champs_exterieurs($arg, 0, $sep, $result);
 278
 279                                 $args = ltrim($regs[count($regs)-1]);
 280                                 $collecte = array_merge($collecte, $arg);
 281                                 $result = array_merge($result, $arg);
 282                         }
 283                         else {
 284                                 $n = strpos($args,$r[0]);
 285                                 $pred = substr($args, 0, $n);
 286                                 $par = ',}';
 287                                 if (preg_match('/^(.*)\($/', $pred, $m))
 288                                         {$pred = $m[1]; $par =')';}
 289                                 if ($pred) {
 290                                         $champ = new Texte;
 291                                         $champ->texte = $pred;
 292                                         $champ->apres = $champ->avant = "";
 293                                         $result[] = $champ;
 294                                         $collecte[] = $champ;
 295                                 }
 296                                 $rec = substr($args, $n + strlen($r[0]) -1);
 297                                 $champ = new Champ;
 298                                 $champ->nom_boucle = $r[2];
 299                                 $champ->nom_champ = $r[3];
 300                                 $champ->etoile = $r[5];
 301                                 $next = $r[6];
 302                                 while ($next=='{') {
 303                                         phraser_arg($rec, $sep, array(), $champ);
 304                                         $args = ltrim($rec) ;
 305                                         $next = isset($args[0]) ? $args[0] : '';
 306                                 }
 307                                 while ($next=='|') {
 308                                         phraser_args($rec, $par, $sep, array(), $champ);
 309                                         $args = $champ->apres ;
 310                                         $champ->apres = '';
 311                                         $next = isset($args[0]) ? $args[0] : '';
 312                                 }
 313                                 // Si erreur de syntaxe dans un sous-argument, propager.
 314                                 if ($champ->param === false)
 315                                         $err_f = true;
 316                                 else phraser_vieux($champ);
 317                                 if ($par==')') $args = substr($args,1);
 318                                 $collecte[] = $champ;
 319                                 $result[] = $champ;
 320                         }
 321                 }
 322                 if (isset($args[0]) AND $args[0] == ',') {
 323                         $args = ltrim(substr($args,1));
 324                         if ($collecte) {$res[] = $collecte; $collecte = array();}
 325                 }
 326         }
 327         if ($collecte) {$res[] = $collecte; $collecte = array();}
 328         $texte = substr($args,1);
 329         $source = substr($suite, 0, strlen($suite) - strlen($texte));
 330         // propager les erreurs, et ignorer les param vides
 331         if ($pointeur_champ->param !== false) {
 332                 if ($err_f)
 333                         $pointeur_champ->param = false;
 334                 elseif ($fonc!=='' || count($res) > 1)
 335                         $pointeur_champ->param[] = $res;
 336         }
 337         // pour les balises avec faux filtres qui boudent ce dur larbeur
 338         $pointeur_champ->fonctions[] = array($fonc, $source);
 339         return $result;
 340 }
 341
 342
 343 // http://doc.spip.org/@phraser_champs_exterieurs
 344 function phraser_champs_exterieurs($texte, $ligne, $sep, $nested) {
 345         $res = array();
 346         while (($p=strpos($texte, "%$sep"))!==false) {
 347                 if (!preg_match(',^%'.preg_quote($sep).'([0-9]+)@,', substr($texte,$p), $m))
 348                         break;
 349                 $debut = substr($texte,0,$p);
 350                 $texte = substr($texte, $p+strlen($m[0]));
 351                 if ($p)
 352                         $res = phraser_inclure($debut, $ligne, $res);
 353                 $ligne += substr_count($debut, "\n");
 354                 $res[]= $nested[$m[1]];
 355         }
 356         return (($texte==='') ? $res : phraser_inclure($texte, $ligne, $res));
 357 }
 358
 359 // http://doc.spip.org/@phraser_champs_interieurs
 360 function phraser_champs_interieurs($texte, $ligne, $sep, $result) {
 361         $i = 0; // en fait count($result)
 362         $x = "";
 363
 364         while (true) {
 365                 $j=$i;
 366                 $n = $ligne;
 367                 while (preg_match(CHAMP_ETENDU, $texte, $match)) {
 368                         $p = strpos($texte, $match[0]);
 369                         $debut = substr($texte, 0, $p);
 370                         if ($p) {
 371                                 $result[$i] = $debut;
 372                                 $i++;
 373                         }
 374                         $nom = $match[4];
 375                         $champ = new Champ;
 376                         // ca ne marche pas encore en cas de champ imbrique
 377                         $champ->ligne = $x ? 0 :($n+substr_count($debut, "\n"));
 378                         $champ->nom_boucle = $match[3];
 379                         $champ->nom_champ = $nom;
 380                         $champ->etoile = $match[6];
 381                         // phraser_args indiquera ou commence apres
 382                         $result = phraser_args($match[7], ")", $sep, $result, $champ);
 383                         phraser_vieux($champ);
 384                         $champ->avant =
 385                                 phraser_champs_exterieurs($match[1],$n,$sep,$result);
 386                         $debut = substr($champ->apres,1);
 387                         $n += substr_count(substr($texte, 0, strpos($texte, $debut)), "\n");
 388                         $champ->apres = phraser_champs_exterieurs($debut,$n,$sep,$result);
 389
 390                         $result[$i] = $champ;
 391                         $i++;
 392                         $texte = substr($texte,$p+strlen($match[0]));
 393                 }
 394                 if ($texte!=="") {$result[$i] = $texte; $i++;}
 395                 $x ='';
 396
 397                 while($j < $i) {
 398                         $z= $result[$j];
 399                         // j'aurais besoin de connaitre le nombre de lignes...
 400                         if (is_object($z))
 401                                 $x .= "%$sep$j@";
 402                         else
 403                                 $x.=$z;
 404                         $j++;
 405                 }
 406                 if (preg_match(CHAMP_ETENDU, $x))
 407                         $texte = $x;
 408                 else
 409                         return phraser_champs_exterieurs($x, $ligne, $sep, $result);
 410         }
 411 }
 412
 413 function phraser_vieux(&$champ)
 414 {
 415         $nom = $champ->nom_champ;
 416         if ($nom == 'EMBED_DOCUMENT') {
 417                 if (!function_exists('phraser_vieux_emb'))
 418                         include_spip('public/normaliser');
 419                 phraser_vieux_emb($champ);
 420         } elseif ($nom == 'EXPOSER') {
 421                 if (!function_exists('phraser_vieux_exposer'))
 422                         include_spip('public/normaliser');
 423                 phraser_vieux_exposer($champ);
 424         } elseif ($champ->param) {
 425                 if ($nom == 'FORMULAIRE_RECHERCHE') {
 426                         if (!function_exists('phraser_vieux_recherche'))
 427                                 include_spip('public/normaliser');
 428                         phraser_vieux_recherche($champ);
 429                 } elseif (preg_match(",^LOGO_[A-Z]+,", $nom)) {
 430                         if (!function_exists('phraser_vieux_logos'))
 431                                 include_spip('public/normaliser');
 432                         phraser_vieux_logos($champ);
 433                 } elseif ($nom == 'MODELE') {
 434                         if (!function_exists('phraser_vieux_modele'))
 435                                 include_spip('public/normaliser');
 436                         phraser_vieux_modele($champ);
 437                 } elseif ($nom == 'INCLURE' OR $nom == 'INCLUDE') {
 438                         if (!function_exists('phraser_vieux_inclu'))
 439                                 include_spip('public/normaliser');
 440                         phraser_vieux_inclu($champ);
 441                 }
 442         }
 443 }
 444
 445
 446 /**
 447  * Analyse les critères de boucle
 448  *
 449  * Chaque paramètre de la boucle (tel que {id_article>3}) est analysé
 450  * pour construire un critère (objet Critere) de boucle.
 451  *
 452  * Un critère a une description plus fine que le paramètre original
 453  * car on en extrait certaines informations tel que la n'égation et l'opérateur
 454  * utilisé s'il y a.
 455  *
 456  * La fonction en profite pour déclarer des modificateurs de boucles
 457  * en présence de certains critères (tout, plat) ou initialiser des
 458  * variables de compilation (doublons)...
 459  *
 460  * @param array $params
 461  *     Tableau de description des paramètres passés à la boucle.
 462  *     Chaque paramètre deviendra un critère
 463  * @param Boucle $result
 464  *     Description de la boucle
 465  *     Elle sera complété de la liste de ses critères
 466  * @return void
 467 **/
 468 function phraser_criteres($params, &$result) {
 469
 470         $err_ci = ''; // indiquera s'il y a eu une erreur
 471         $args = array();
 472         $type = $result->type_requete;
 473         $doublons = array();
 474         foreach($params as $v) {
 475                 $var = $v[1][0];
 476                 $param = ($var->type != 'texte') ? "" : $var->texte;
 477                 if ((count($v) > 2) && (!preg_match(",[^A-Za-z]IN[^A-Za-z],i",$param)))
 478                   {
 479 // plus d'un argument et pas le critere IN:
 480 // detecter comme on peut si c'est le critere implicite LIMIT debut, fin
 481
 482                         if ($var->type != 'texte'
 483                         OR preg_match("/^(n|n-|(n-)?\d+)$/S", $param)) {
 484                           $op = ',';
 485                           $not = "";
 486                         } else {
 487                           // Le debut du premier argument est l'operateur
 488                           preg_match("/^([!]?)([a-zA-Z][a-zA-Z0-9]*)[[:space:]]*(.*)$/ms", $param, $m);
 489                           $op = $m[2];
 490                           $not = $m[1];
 491                           // virer le premier argument,
 492                           // et mettre son reliquat eventuel
 493                           // Recopier pour ne pas alterer le texte source
 494                           // utile au debusqueur
 495                           if ($m[3]) {
 496                             // une maniere tres sale de supprimer les "' autour de {critere "xxx","yyy"}
 497                             if (preg_match(',^(["\'])(.*)\1$,', $m[3])) {
 498                                 $c = null;
 499                                 eval ('$c = '.$m[3].';');
 500                                 if (isset($c))
 501                                         $m[3] = $c;
 502                             }
 503                             $texte = new Texte;
 504                             $texte->texte = $m[3];
 505                             $v[1][0]= $texte;
 506                           } else array_shift($v[1]);
 507                         }
 508                         array_shift($v); // $v[O] est vide
 509                         $crit = new Critere;
 510                         $crit->op = $op;
 511                         $crit->not = $not;
 512                         $crit->exclus ="";
 513                         $crit->param = $v;
 514                         $args[] = $crit;
 515                   } else {
 516                   if ($var->type != 'texte') {
 517                     // cas 1 seul arg ne commencant pas par du texte brut:
 518                     // erreur ou critere infixe "/"
 519                     if (($v[1][1]->type != 'texte') || (trim($v[1][1]->texte) !='/')) {
 520                         $err_ci = array('zbug_critere_inconnu',
 521                                         array('critere' => $var->nom_champ));
 522                         erreur_squelette($err_ci, $result);
 523                     } else {
 524                       $crit = new Critere;
 525                       $crit->op = '/';
 526                       $crit->not = "";
 527                       $crit->exclus ="";
 528                       $crit->param = array(array($v[1][0]),array($v[1][2]));
 529                       $args[] = $crit;
 530                     }
 531                   } else {
 532         // traiter qq lexemes particuliers pour faciliter la suite
 533         // les separateurs
 534                         if ($var->apres)
 535                                 $result->separateur[] = $param;
 536                         elseif (($param == 'tout') OR ($param == 'tous'))
 537                                 $result->modificateur['tout'] = true;
 538                         elseif ($param == 'plat')
 539                                 $result->modificateur['plat'] = true;
 540
 541                         // Boucle hierarchie, analyser le critere id_rubrique
 542                         // et les autres critères {id_x} pour forcer {tout} sur
 543                         // ceux-ci pour avoir la rubrique mere...
 544                         // Les autres critères de la boucle hierarchie doivent être
 545                         // traités normalement.
 546                         elseif (strcasecmp($type, 'hierarchie')==0
 547                                 AND !preg_match(",^id_rubrique\b,",$param)
 548                                 AND preg_match(",^id_\w+\s*$,", $param))
 549                         {
 550                                 $result->modificateur['tout'] = true;
 551                         }
 552                         elseif (strcasecmp($type, 'hierarchie')==0 AND $param=="id_rubrique") {
 553                                 // rien a faire sur {id_rubrique} tout seul
 554                         }
 555                         else {
 556                           // pas d'emplacement statique, faut un dynamique
 557                           /// mais il y a 2 cas qui ont les 2 !
 558                           if (($param == 'unique') || (preg_match(',^!?doublons *,', $param)))
 559                             {
 560                               // cette variable sera inseree dans le code
 561                               // et son nom sert d'indicateur des maintenant
 562                               $result->doublons = '$doublons_index';
 563                               if ($param == 'unique') $param = 'doublons';
 564                             }
 565                           elseif ($param == 'recherche')
 566                             // meme chose (a cause de #nom_de_boucle:URL_*)
 567                               $result->hash = ' ';
 568                           if (preg_match(',^ *([0-9-]+) *(/) *(.+) *$,', $param, $m)) {
 569                             $crit = phraser_critere_infixe($m[1], $m[3],$v, '/', '', '');
 570                           } elseif (preg_match(',^([!]?)(' . CHAMP_SQL_PLUS_FONC .
 571                                          ')[[:space:]]*(\??)(!?)(<=?|>=?|==?|\b(?:IN|LIKE)\b)(.*)$,is', $param, $m)) {
 572                             $a2 = trim($m[8]);
 573                             if ($a2 AND ($a2[0]=="'" OR $a2[0]=='"') AND ($a2[0]==substr($a2,-1)))
 574                               $a2 = substr($a2,1,-1);
 575                             $crit = phraser_critere_infixe($m[2], $a2, $v,
 576                                                            (($m[2] == 'lang_select') ? $m[2] : $m[7]),
 577                                                            $m[6], $m[5]);
 578                                         $crit->exclus = $m[1];
 579                           } elseif (preg_match("/^([!]?)\s*(" .
 580                                                CHAMP_SQL_PLUS_FONC .
 581                                                ")\s*(\??)(.*)$/is", $param, $m)) {
 582                   // contient aussi les comparaisons implicites !
 583                             // Comme ci-dessus:
 584                             // le premier arg contient l'operateur
 585                             array_shift($v);
 586                             if ($m[6]) {
 587                               $v[0][0] = new Texte;
 588                               $v[0][0]->texte = $m[6];
 589                             } else {
 590                               array_shift($v[0]);
 591                               if (!$v[0]) array_shift($v);
 592                             }
 593                             $crit = new Critere;
 594                             $crit->op = $m[2];
 595                             $crit->param = $v;
 596                             $crit->not = $m[1];
 597                             $crit->cond = $m[5];
 598                           }
 599                           else {
 600                                 $err_ci = array('zbug_critere_inconnu',
 601                                         array('critere' => $param));
 602                                 erreur_squelette($err_ci, $result);
 603                           }
 604                           if ((!preg_match(',^!?doublons *,', $param)) || $crit->not)
 605                             $args[] = $crit;
 606                           else
 607                             $doublons[] = $crit;
 608                         }
 609                   }
 610                 }
 611         }
 612         // les doublons non nies doivent etre le dernier critere
 613         // pour que la variable $doublon_index ait la bonne valeur
 614         // cf critere_doublon
 615         if ($doublons) $args= array_merge($args, $doublons);
 616         // Si erreur, laisser la chaine dans ce champ pour le HTTP 503
 617         if (!$err_ci) $result->criteres = $args;
 618 }
 619
 620 // http://doc.spip.org/@phraser_critere_infixe
 621 function phraser_critere_infixe($arg1, $arg2, $args, $op, $not, $cond)
 622 {
 623         $args[0] = new Texte;
 624         $args[0]->texte = $arg1;
 625         $args[0] = array($args[0]);
 626         $args[1][0] = new Texte;
 627         $args[1][0]->texte  = $arg2;
 628         $crit = new Critere;
 629         $crit->op = $op;
 630         $crit->not = $not;
 631         $crit->cond = $cond;
 632         $crit->param = $args;
 633         return $crit;
 634 }
 635
 636 function public_phraser_html_dist($texte, $id_parent, &$boucles, $descr, $ligne=1) {
 637
 638         $all_res = array();
 639
 640         while (($pos_boucle = strpos($texte, BALISE_BOUCLE)) !== false) {
 641
 642                 $err_b = ''; // indiquera s'il y a eu une erreur
 643                 $result = new Boucle;
 644                 $result->id_parent = $id_parent;
 645                 $result->descr = $descr;
 646 # attention: reperer la premiere des 2 balises: pre_boucle ou boucle
 647
 648                 if (!preg_match(",".BALISE_PRE_BOUCLE . '[0-9_],', $texte, $r)
 649                         OR ($n = strpos($texte, $r[0]))===false
 650                         OR ($n > $pos_boucle) ) {
 651                   $debut = substr($texte, 0, $pos_boucle);
 652                   $milieu = substr($texte, $pos_boucle);
 653                   $k = strpos($milieu, '(');
 654                   $id_boucle = trim(substr($milieu,
 655                                            strlen(BALISE_BOUCLE),
 656                                            $k - strlen(BALISE_BOUCLE)));
 657                   $milieu = substr($milieu, $k);
 658
 659                 } else {
 660                   $debut = substr($texte, 0, $n);
 661                   $milieu = substr($texte, $n);
 662                   $k = strpos($milieu, '>');
 663                   $id_boucle = substr($milieu,
 664                                        strlen(BALISE_PRE_BOUCLE),
 665                                        $k - strlen(BALISE_PRE_BOUCLE));
 666
 667                   if (!preg_match(",".BALISE_BOUCLE . $id_boucle . "[[:space:]]*\(,", $milieu, $r)) {
 668                         $err_b = array('zbug_erreur_boucle_syntaxe', array('id' => $id_boucle));
 669                         erreur_squelette($err_b, $result);
 670                   }
 671                   $pos_boucle = $n;
 672                   $n = strpos($milieu, $r[0]);
 673                   $result->avant = substr($milieu, $k+1, $n-$k-1);
 674                   $milieu = substr($milieu, $n+strlen($id_boucle)+strlen(BALISE_BOUCLE));
 675                 }
 676                 $result->id_boucle = $id_boucle;
 677
 678                 preg_match(SPEC_BOUCLE, $milieu, $match);
 679                 $result->type_requete = $match[0];
 680                 $milieu = substr($milieu, strlen($match[0]));
 681                 $type = $match[1];
 682                 $jointures = trim($match[2]);
 683                 $table_optionnelle = ($match[3]);
 684                 if ($jointures) {
 685                         // on affecte pas ici les jointures explicites, mais dans la compilation
 686                         // ou elles seront completees des jointures declarees
 687                         $result->jointures_explicites = $jointures;
 688                 }
 689
 690                 if ($table_optionnelle){
 691                         $result->table_optionnelle = $type;
 692                 }
 693
 694                 // 1ere passe sur les criteres, vu comme des arguments sans fct
 695                 // Resultat mis dans result->param
 696                 phraser_args($milieu,"/>","",$all_res,$result);
 697
 698                 // En 2e passe result->criteres contiendra un tableau
 699                 // pour l'instant on met le source (chaine) :
 700                 // si elle reste ici au final, c'est qu'elle contient une erreur
 701                 $result->criteres =  substr($milieu,0,@strpos($milieu,$result->apres));
 702                 $milieu = $result->apres;
 703                 $result->apres = "";
 704
 705                 //
 706                 // Recuperer la fin :
 707                 //
 708                 if ($milieu[0] === '/') {
 709                         $suite = substr($milieu,2);
 710                         $milieu = '';
 711                 } else {
 712                         $milieu = substr($milieu,1);
 713                         $s = BALISE_FIN_BOUCLE . $id_boucle . ">";
 714                         $p = strpos($milieu, $s);
 715                         if ($p === false) {
 716                                 $err_b = array('zbug_erreur_boucle_fermant',
 717                                         array('id' => $id_boucle));
 718                                 erreur_squelette($err_b, $result);
 719                         }
 720
 721                         $suite = substr($milieu, $p + strlen($s));
 722                         $milieu = substr($milieu, 0, $p);
 723                 }
 724
 725                 $result->milieu = $milieu;
 726
 727                 //
 728                 // 1. Recuperer la partie conditionnelle apres
 729                 //
 730                 $s = BALISE_POST_BOUCLE . $id_boucle . ">";
 731                 $p = strpos($suite, $s);
 732                 if ($p !== false) {
 733                         $result->apres = substr($suite, 0, $p);
 734                         $suite = substr($suite, $p + strlen($s));
 735                 }
 736
 737                 //
 738                 // 2. Recuperer la partie alternative
 739                 //
 740                 $s = BALISE_ALT_BOUCLE . $id_boucle . ">";
 741                 $p = strpos($suite, $s);
 742                 if ($p !== false) {
 743                         $result->altern = substr($suite, 0, $p);
 744                         $suite = substr($suite, $p + strlen($s));
 745                 }
 746                 $result->ligne = $ligne + substr_count($debut, "\n");
 747                 $m = substr_count($milieu, "\n");
 748                 $b = substr_count($result->avant, "\n");
 749                 $a = substr_count($result->apres, "\n");
 750
 751                 if ($p = strpos($type, ':')) {
 752                         $result->sql_serveur = substr($type,0,$p);
 753                         $type = substr($type,$p+1);
 754                 }
 755                 $soustype = strtolower($type);
 756
 757                 if (!isset($GLOBALS["table_des_tables"][$soustype]))
 758                         $soustype = $type;
 759
 760                 $result->type_requete = $soustype;
 761                 // Lancer la 2e passe sur les criteres si la 1ere etait bonne
 762                 if (!is_array($result->param))
 763                         $err_b = true;
 764                 else {
 765                         phraser_criteres($result->param, $result);
 766                         if (strncasecmp($soustype, TYPE_RECURSIF, strlen(TYPE_RECURSIF)) == 0) {
 767                                 $result->type_requete = TYPE_RECURSIF;
 768                                 $args = $result->param;
 769                                 array_unshift($args,
 770                                         substr($type, strlen(TYPE_RECURSIF)));
 771                                 $result->param = $args;
 772                         }
 773                 }
 774
 775                 $result->avant = public_phraser_html_dist($result->avant, $id_parent,$boucles, $descr, $result->ligne);
 776                 $result->apres = public_phraser_html_dist($result->apres, $id_parent,$boucles, $descr, $result->ligne+$b+$m);
 777                 $result->altern = public_phraser_html_dist($result->altern,$id_parent,$boucles, $descr, $result->ligne+$a+$m+$b);
 778                 $result->milieu = public_phraser_html_dist($milieu, $id_boucle,$boucles, $descr, $result->ligne+$b);
 779
 780                 // Prevenir le generateur de code que le squelette est faux
 781                 if ($err_b) $result->type_requete = false;
 782
 783                 // Verifier qu'il n'y a pas double definition
 784                 // apres analyse des sous-parties (pas avant).
 785
 786                 if (isset($boucles[$id_boucle])) {
 787                         $err_b_d = array('zbug_erreur_boucle_double',
 788                                         array('id'=>$id_boucle));
 789                         erreur_squelette($err_b_d, $result);
 790                 // Prevenir le generateur de code que le squelette est faux
 791                         $boucles[$id_boucle]->type_requete = false;
 792                 } else
 793                         $boucles[$id_boucle] = $result;
 794                 $all_res = phraser_champs_etendus($debut, $ligne, $all_res);
 795                 $all_res[] = &$boucles[$id_boucle];
 796                 $ligne += substr_count(substr($texte, 0, strpos($texte, $suite)), "\n");
 797                 $texte = $suite;
 798         }
 799
 800         return phraser_champs_etendus($texte, $ligne, $all_res);
 801 }
 802 ?>