d087b8898b068939bfbcda35531c917b4694de57
3 /***************************************************************************\
4 * SPIP, Systeme de publication pour l'internet *
6 * Copyright (c) 2001-2017 *
7 * Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
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 \***************************************************************************/
14 * Phraseur d'un squelette ayant une syntaxe SPIP/HTML
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
19 * @package SPIP\Core\Compilateur\Phraseur
22 if (!defined('_ECRIRE_INC_VERSION')) {
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');
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]*");
44 * Nom d'une balise #TOTO
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');
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');
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
. '?`?');
61 // http://code.spip.net/@phraser_inclure
62 function phraser_inclure($texte, $ligne, $result) {
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);
69 $result = phraser_idiomes($debut, $ligne, $result);
71 $ligne +
= substr_count($debut, "\n");
73 $champ->ligne
= $ligne;
74 $ligne +
= substr_count($match[0], "\n");
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)) {
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');
89 normaliser_inclure($champ);
91 $texte = substr($champ->apres
, strpos($champ->apres
, '>') +
1);
93 $texte = preg_replace(',^</INCLU[DR]E>,', '', $texte);
97 return (($texte === "") ?
$result : phraser_idiomes($texte, $ligne, $result));
100 // http://code.spip.net/@phraser_polyglotte
101 function phraser_polyglotte($texte, $ligne, $result) {
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);
109 $champ->texte
= $debut;
110 $champ->ligne
= $ligne;
112 $ligne +
= substr_count($champ->texte
, "\n");
115 $champ = new Polyglotte
;
116 $champ->ligne
= $ligne;
117 $ligne +
= substr_count($match[0], "\n");
120 $texte = substr($texte, $p +
strlen($match[0]));
121 while (preg_match("/^[[:space:]]*([^[{]*)[[:space:]]*[[{]([a-z_]+)[]}](.*)$/si", $bloc, $regs)) {
123 if ($trad or $lang) {
124 $champ->traductions
[$lang] = $trad;
129 $champ->traductions
[$lang] = $bloc;
135 $champ->texte
= $texte;
136 $champ->ligne
= $ligne;
145 * Repérer les balises de traduction (idiomes)
147 * Phrase les idiomes tel que
149 * - `<:module:chaine:>`
150 * - `<:module:chaine{arg1=texte1,arg2=#BALISE}|filtre1{texte2,#BALISE}|filtre2:>`
153 * `chaine` peut etre vide si `=texte1` est present et `arg1` est vide
154 * sinon ce n'est pas un idiome
156 * @param string $texte
158 * @param array $result
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));
168 $result = phraser_champs($debut, $ligne, $result);
170 $texte = substr($texte, $p +
strlen($match[0]));
171 $ligne +
= substr_count($debut, "\n");
176 $champ->ligne
= $ligne;
177 $ligne +
= substr_count($match[0], "\n");
178 // Stocker les arguments de la balise de traduction
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]));
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);
193 $result = phraser_champs($texte, $ligne, $result);
200 * Repère et phrase les balises SPIP tel que `#NOM` dans un texte
202 * Phrase également ses arguments si la balise en a (`#NOM{arg, ...}`)
204 * @uses phraser_polyglotte()
205 * @uses phraser_args()
206 * @uses phraser_vieux()
208 * @param string $texte
210 * @param array $result
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]));
219 $debut = substr($texte, 0, $p);
221 $result = phraser_polyglotte($debut, $ligne, $result);
223 $ligne +
= substr_count($debut, "\n");
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];
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);
247 phraser_vieux($champ);
251 $result = phraser_polyglotte($texte, $ligne, $result);
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
262 // http://code.spip.net/@phraser_champs_etendus
263 function phraser_champs_etendus($texte, $ligne, $result) {
268 while (strpos($texte, $sep) !== false) {
272 return array_merge($result, phraser_champs_interieurs($texte, $ligne, $sep, array()));
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
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);
288 # mettre ici la suite du texte,
289 # notamment pour que l'appelant vire le caractere fermant si besoin
290 $pointeur_champ->apres
= $texte;
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));
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 |
309 $err_f = array('zbug_erreur_filtre', array('filtre' => $texte));
310 erreur_squelette($err_f, $pointeur_champ);
316 $pointeur_champ->param
= false;
317 } elseif ($fonc !== '') {
318 $pointeur_champ->param
[] = $res;
320 // pour les balises avec faux filtres qui boudent ce dur larbeur
321 $pointeur_champ->fonctions
[] = array($fonc, '');
325 $args = ltrim(substr($suite, 1)); // virer le '(' initial
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);
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);
338 $champ->apres
= $champ->avant
= $args = "";
343 if (trim($regs[1])) {
345 $champ->texte
= $arg;
346 $champ->apres
= $champ->avant
= $regs[1];
348 $collecte[] = $champ;
349 $args = ltrim($regs[count($regs) - 1]);
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);
355 $args = ltrim($regs[count($regs) - 1]);
356 $collecte = array_merge($collecte, $arg);
357 $result = array_merge($result, $arg);
359 $n = strpos($args, $r[0]);
360 $pred = substr($args, 0, $n);
362 if (preg_match('/^(.*)\($/', $pred, $m)) {
368 $champ->texte
= $pred;
369 $champ->apres
= $champ->avant
= "";
371 $collecte[] = $champ;
373 $rec = substr($args, $n +
strlen($r[0]) - 1);
375 $champ->nom_boucle
= $r[2];
376 $champ->nom_champ
= $r[3];
377 $champ->etoile
= $r[5];
379 while ($next == '{') {
380 phraser_arg($rec, $sep, array(), $champ);
382 $next = isset($args[0]) ?
$args[0] : '';
384 while ($next == '|') {
385 phraser_args($rec, $par, $sep, array(), $champ);
386 $args = $champ->apres
;
388 $next = isset($args[0]) ?
$args[0] : '';
390 // Si erreur de syntaxe dans un sous-argument, propager.
391 if ($champ->param
=== false) {
394 phraser_vieux($champ);
397 $args = substr($args, 1);
399 $collecte[] = $champ;
403 if (isset($args[0]) and $args[0] == ',') {
404 $args = ltrim(substr($args, 1));
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) {
420 $pointeur_champ->param
= false;
421 } elseif ($fonc !== '' ||
count($res) > 1) {
422 $pointeur_champ->param
[] = $res;
425 // pour les balises avec faux filtres qui boudent ce dur larbeur
426 $pointeur_champ->fonctions
[] = array($fonc, $source);
432 // http://code.spip.net/@phraser_champs_exterieurs
433 function phraser_champs_exterieurs($texte, $ligne, $sep, $nested) {
435 while (($p = strpos($texte, "%$sep")) !== false) {
436 if (!preg_match(',^%' . preg_quote($sep) . '([0-9]+)@,', substr($texte, $p), $m)) {
439 $debut = substr($texte, 0, $p);
440 $texte = substr($texte, $p +
strlen($m[0]));
442 $res = phraser_inclure($debut, $ligne, $res);
444 $ligne +
= substr_count($debut, "\n");
445 $res[] = $nested[$m[1]];
448 return (($texte === '') ?
$res : phraser_inclure($texte, $ligne, $res));
451 // http://code.spip.net/@phraser_champs_interieurs
452 function phraser_champs_interieurs($texte, $ligne, $sep, $result) {
453 $i = 0; // en fait count($result)
459 while (preg_match(CHAMP_ETENDU
, $texte, $match)) {
460 $p = strpos($texte, $match[0]);
461 $debut = substr($texte, 0, $p);
463 $result[$i] = $debut;
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);
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");
482 $champ->apres
= phraser_champs_exterieurs($debut, $n, $sep, $result);
484 $result[$i] = $champ;
486 $texte = substr($texte, $p +
strlen($match[0]));
489 $result[$i] = $texte;
496 // j'aurais besoin de connaitre le nombre de lignes...
504 if (preg_match(CHAMP_ETENDU
, $x)) {
507 return phraser_champs_exterieurs($x, $ligne, $sep, $result);
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');
518 phraser_vieux_emb($champ);
519 } elseif ($nom == 'EXPOSER') {
520 if (!function_exists('phraser_vieux_exposer')) {
521 include_spip('public/normaliser');
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');
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');
534 phraser_vieux_logos($champ);
535 } elseif ($nom == 'MODELE') {
536 if (!function_exists('phraser_vieux_modele')) {
537 include_spip('public/normaliser');
539 phraser_vieux_modele($champ);
540 } elseif ($nom == 'INCLURE' or $nom == 'INCLUDE') {
541 if (!function_exists('phraser_vieux_inclu')) {
542 include_spip('public/normaliser');
544 phraser_vieux_inclu($champ);
551 * Analyse les critères de boucle
553 * Chaque paramètre de la boucle (tel que {id_article>3}) est analysé
554 * pour construire un critère (objet Critere) de boucle.
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
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)...
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
572 function phraser_criteres($params, &$result) {
574 $err_ci = ''; // indiquera s'il y a eu une erreur
576 $type = $result->type_requete
;
578 foreach ($params as $v) {
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)
591 // Le debut du premier argument est l'operateur
592 preg_match("/^([!]?)([a-zA-Z][a-zA-Z0-9_]*)[[:space:]]*(\??)[[:space:]]*(.*)$/ms", $param, $m);
596 // virer le premier argument,
597 // et mettre son reliquat eventuel
598 // Recopier pour ne pas alterer le texte source
599 // utile au debusqueur
601 // une maniere tres sale de supprimer les "' autour de {critere "xxx","yyy"}
602 if (preg_match(',^(["\'])(.*)\1$,', $m[4])) {
604 eval('$c = ' . $m[4] . ';');
610 $texte->texte
= $m[4];
616 array_shift($v); // $v[O] est vide
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
) != '/')) {
630 'zbug_critere_inconnu',
631 array('critere' => $var->nom_champ
)
633 erreur_squelette($err_ci, $result);
639 $crit->param
= array(array($v[1][0]), array($v[1][2]));
643 // traiter qq lexemes particuliers pour faciliter la suite
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;
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)
662 $result->modificateur
['tout'] = true;
663 } elseif (strcasecmp($type, 'hierarchie') == 0 and $param == "id_rubrique") {
664 // rien a faire sur {id_rubrique} tout seul
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') {
675 } elseif ($param == 'recherche') {
676 // meme chose (a cause de #nom_de_boucle:URL_*)
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)) {
685 if ($a2 and ($a2[0] == "'" or $a2[0] == '"') and ($a2[0] == substr($a2, -1))) {
686 $a2 = substr($a2, 1, -1);
688 $crit = phraser_critere_infixe($m[2], $a2, $v,
689 (($m[2] == 'lang_select') ?
$m[2] : $m[7]),
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 !
697 // le premier arg contient l'operateur
700 $v[0][0] = new Texte
;
701 $v[0][0]->texte
= $m[6];
715 'zbug_critere_inconnu',
716 array('critere' => $param)
718 erreur_squelette($err_ci, $result);
721 if ((!preg_match(',^!?doublons *,', $param)) ||
$crit->not
) {
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
735 $args = array_merge($args, $doublons);
738 // Si erreur, laisser la chaine dans ce champ pour le HTTP 503
740 $result->criteres
= $args;
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;
755 $crit->param
= $args;
760 function public_phraser_html_dist($texte, $id_parent, &$boucles, $descr, $ligne = 1) {
764 while (($pos_boucle = strpos($texte, BALISE_BOUCLE
)) !== false) {
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
772 if (!preg_match("," . BALISE_PRE_BOUCLE
. '[0-9_],', $texte, $r)
773 or ($n = strpos($texte, $r[0])) === false
774 or ($n > $pos_boucle)
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);
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
));
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);
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
));
804 $result->id_boucle
= $id_boucle;
806 preg_match(SPEC_BOUCLE
, $milieu, $match);
807 $result->type_requete
= $match[0];
808 $milieu = substr($milieu, strlen($match[0]));
810 $jointures = trim($match[2]);
811 $table_optionnelle = ($match[3]);
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;
818 if ($table_optionnelle) {
819 $result->table_optionnelle
= $type;
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);
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
;
834 // Recuperer la fin :
836 if ($milieu[0] === '/') {
837 $suite = substr($milieu, 2);
840 $milieu = substr($milieu, 1);
841 $s = BALISE_FIN_BOUCLE
. $id_boucle . ">";
842 $p = strpos($milieu, $s);
845 'zbug_erreur_boucle_fermant',
846 array('id' => $id_boucle)
848 erreur_squelette($err_b, $result);
851 $suite = substr($milieu, $p +
strlen($s));
852 $milieu = substr($milieu, 0, $p);
855 $result->milieu
= $milieu;
858 // 1. Recuperer la partie conditionnelle apres
860 $s = BALISE_POST_BOUCLE
. $id_boucle . ">";
861 $p = strpos($suite, $s);
863 $result->apres
= substr($suite, 0, $p);
864 $suite = substr($suite, $p +
strlen($s));
868 // 2. Recuperer la partie alternative
870 $s = BALISE_ALT_BOUCLE
. $id_boucle . ">";
871 $p = strpos($suite, $s);
873 $result->altern
= substr($suite, 0, $p);
874 $suite = substr($suite, $p +
strlen($s));
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");
881 if ($p = strpos($type, ':')) {
882 $result->sql_serveur
= substr($type, 0, $p);
883 $type = substr($type, $p +
1);
885 $soustype = strtolower($type);
887 if (!isset($GLOBALS["table_des_tables"][$soustype])) {
891 $result->type_requete
= $soustype;
892 // Lancer la 2e passe sur les criteres si la 1ere etait bonne
893 if (!is_array($result->param
)) {
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
;
901 substr($type, strlen(TYPE_RECURSIF
)));
902 $result->param
= $args;
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);
911 // Prevenir le generateur de code que le squelette est faux
913 $result->type_requete
= false;
916 // Verifier qu'il n'y a pas double definition
917 // apres analyse des sous-parties (pas avant).
919 if (isset($boucles[$id_boucle])) {
921 'zbug_erreur_boucle_double',
922 array('id' => $id_boucle)
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;
928 $boucles[$id_boucle] = $result;
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");
938 return phraser_champs_etendus($texte, $ligne, $all_res);