www/ecrire/public/phraser_html.php

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