3 /***************************************************************************\
4 * SPIP, Systeme de publication pour l'internet *
6 * Copyright (c) 2001-2014 *
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 if (!defined('_ECRIRE_INC_VERSION')) return;
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
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');
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');
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');
38 define('SQL_ARGS', '(\([^)]*\))');
39 define('CHAMP_SQL_PLUS_FONC', '`?([A-Z_\/][A-Z_\/0-9.]*)' . SQL_ARGS
. '?`?');
41 // http://doc.spip.org/@phraser_inclure
42 function phraser_inclure($texte, $ligne, $result) {
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");
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)) {
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);
67 $texte = substr($champ->apres
, strpos($champ->apres
, '>')+
1);
69 $texte = preg_replace(',^</INCLU[DR]E>,', '', $texte);
72 return (($texte==="") ?
$result : phraser_idiomes($texte, $ligne, $result));
75 // http://doc.spip.org/@phraser_polyglotte
76 function phraser_polyglotte($texte,$ligne, $result) {
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);
84 $champ->texte
= $debut;
85 $champ->ligne
= $ligne;
87 $ligne +
= substr_count($champ->texte
, "\n");
90 $champ = new Polyglotte
;
91 $champ->ligne
= $ligne;
92 $ligne +
= substr_count($match[0], "\n");
95 $texte = substr($texte,$p+
strlen($match[0]));
96 while (preg_match("/^[[:space:]]*([^[{]*)[[:space:]]*[[{]([a-z_]+)[]}](.*)$/si", $bloc, $regs)) {
99 $champ->traductions
[$lang] = $trad;
103 $champ->traductions
[$lang] = $bloc;
108 $champ->texte
= $texte;
109 $champ->ligne
= $ligne;
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
131 $champ->ligne
= $ligne;
132 $ligne +
= substr_count($match[0], "\n");
133 // Stocker les arguments de la balise de traduction
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]));
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);
147 if ($texte!=="") $result = phraser_champs($texte,$ligne,$result);
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");
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];
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);
180 } else $texte = $suite;
181 phraser_vieux($champ);
185 $result = phraser_polyglotte (substr($texte, 0, $p+
1), $ligne, $result);
186 $texte = (substr($texte, $p+
1));
189 if ($texte!=="") $result = phraser_polyglotte($texte, $ligne, $result);
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
198 // http://doc.spip.org/@phraser_champs_etendus
199 function phraser_champs_etendus($texte, $ligne,$result) {
200 if ($texte==="") return $result;
202 while (strpos($texte,$sep)!== false)
204 return array_merge($result, phraser_champs_interieurs($texte, $ligne, $sep, array()));
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
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);
220 # mettre ici la suite du texte,
221 # notamment pour que l'appelant vire le caractere fermant si besoin
222 $pointeur_champ->apres
= $texte;
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));
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 |
238 $err_f = array('zbug_erreur_filtre', array('filtre' => $texte));
239 erreur_squelette($err_f, $pointeur_champ);
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, '');
248 $args = ltrim(substr($suite,1)); // virer le '(' initial
250 while ($args && $args[0] != '}') {
252 preg_match ('/^(")([^"]*)(")(.*)$/ms', $args, $regs);
253 else if ($args[0] == "'")
254 preg_match ("/^(')([^']*)(')(.*)$/ms", $args, $regs);
256 preg_match("/^([[:space:]]*)([^,([{}]*([(\[{][^])}]*[])}])?[^,}]*)([,}].*)$/ms", $args, $regs);
257 if (!strlen($regs[2]))
259 $err_f = array('zbug_erreur_filtre', array('filtre' => $args));
260 erreur_squelette($err_f, $pointeur_champ);
262 $champ->apres
= $champ->avant
= $args = "";
267 if (trim($regs[1])) {
269 $champ->texte
= $arg;
270 $champ->apres
= $champ->avant
= $regs[1];
272 $collecte[] = $champ;
273 $args = ltrim($regs[count($regs)-1]);
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);
279 $args = ltrim($regs[count($regs)-1]);
280 $collecte = array_merge($collecte, $arg);
281 $result = array_merge($result, $arg);
284 $n = strpos($args,$r[0]);
285 $pred = substr($args, 0, $n);
287 if (preg_match('/^(.*)\($/', $pred, $m))
288 {$pred = $m[1]; $par =')';}
291 $champ->texte
= $pred;
292 $champ->apres
= $champ->avant
= "";
294 $collecte[] = $champ;
296 $rec = substr($args, $n +
strlen($r[0]) -1);
298 $champ->nom_boucle
= $r[2];
299 $champ->nom_champ
= $r[3];
300 $champ->etoile
= $r[5];
303 phraser_arg($rec, $sep, array(), $champ);
304 $args = ltrim($rec) ;
305 $next = isset($args[0]) ?
$args[0] : '';
308 phraser_args($rec, $par, $sep, array(), $champ);
309 $args = $champ->apres
;
311 $next = isset($args[0]) ?
$args[0] : '';
313 // Si erreur de syntaxe dans un sous-argument, propager.
314 if ($champ->param
=== false)
316 else phraser_vieux($champ);
317 if ($par==')') $args = substr($args,1);
318 $collecte[] = $champ;
322 if (isset($args[0]) AND $args[0] == ',') {
323 $args = ltrim(substr($args,1));
324 if ($collecte) {$res[] = $collecte; $collecte = array();}
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) {
333 $pointeur_champ->param
= false;
334 elseif ($fonc!=='' ||
count($res) > 1)
335 $pointeur_champ->param
[] = $res;
337 // pour les balises avec faux filtres qui boudent ce dur larbeur
338 $pointeur_champ->fonctions
[] = array($fonc, $source);
343 // http://doc.spip.org/@phraser_champs_exterieurs
344 function phraser_champs_exterieurs($texte, $ligne, $sep, $nested) {
346 while (($p=strpos($texte, "%$sep"))!==false) {
347 if (!preg_match(',^%'.preg_quote($sep).'([0-9]+)@,', substr($texte,$p), $m))
349 $debut = substr($texte,0,$p);
350 $texte = substr($texte, $p+
strlen($m[0]));
352 $res = phraser_inclure($debut, $ligne, $res);
353 $ligne +
= substr_count($debut, "\n");
354 $res[]= $nested[$m[1]];
356 return (($texte==='') ?
$res : phraser_inclure($texte, $ligne, $res));
359 // http://doc.spip.org/@phraser_champs_interieurs
360 function phraser_champs_interieurs($texte, $ligne, $sep, $result) {
361 $i = 0; // en fait count($result)
367 while (preg_match(CHAMP_ETENDU
, $texte, $match)) {
368 $p = strpos($texte, $match[0]);
369 $debut = substr($texte, 0, $p);
371 $result[$i] = $debut;
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);
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);
390 $result[$i] = $champ;
392 $texte = substr($texte,$p+
strlen($match[0]));
394 if ($texte!=="") {$result[$i] = $texte; $i++
;}
399 // j'aurais besoin de connaitre le nombre de lignes...
406 if (preg_match(CHAMP_ETENDU
, $x))
409 return phraser_champs_exterieurs($x, $ligne, $sep, $result);
413 function phraser_vieux(&$champ)
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);
447 * Analyse les critères de boucle
449 * Chaque paramètre de la boucle (tel que {id_article>3}) est analysé
450 * pour construire un critère (objet Critere) de boucle.
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
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)...
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
468 function phraser_criteres($params, &$result) {
470 $err_ci = ''; // indiquera s'il y a eu une erreur
472 $type = $result->type_requete
;
474 foreach($params as $v) {
476 $param = ($var->type
!= 'texte') ?
"" : $var->texte
;
477 if ((count($v) > 2) && (!preg_match(",[^A-Za-z]IN[^A-Za-z],i",$param)))
479 // plus d'un argument et pas le critere IN:
480 // detecter comme on peut si c'est le critere implicite LIMIT debut, fin
482 if ($var->type
!= 'texte'
483 OR preg_match("/^(n|n-|(n-)?\d+)$/S", $param)) {
487 // Le debut du premier argument est l'operateur
488 preg_match("/^([!]?)([a-zA-Z][a-zA-Z0-9_]*)[[:space:]]*(\??)[[:space:]]*(.*)$/ms", $param, $m);
492 // virer le premier argument,
493 // et mettre son reliquat eventuel
494 // Recopier pour ne pas alterer le texte source
495 // utile au debusqueur
497 // une maniere tres sale de supprimer les "' autour de {critere "xxx","yyy"}
498 if (preg_match(',^(["\'])(.*)\1$,', $m[4])) {
500 eval ('$c = '.$m[4].';');
505 $texte->texte
= $m[4];
507 } else array_shift($v[1]);
509 array_shift($v); // $v[O] est vide
518 if ($var->type
!= 'texte') {
519 // cas 1 seul arg ne commencant pas par du texte brut:
520 // erreur ou critere infixe "/"
521 if (($v[1][1]->type
!= 'texte') ||
(trim($v[1][1]->texte
) !='/')) {
522 $err_ci = array('zbug_critere_inconnu',
523 array('critere' => $var->nom_champ
));
524 erreur_squelette($err_ci, $result);
530 $crit->param
= array(array($v[1][0]),array($v[1][2]));
534 // traiter qq lexemes particuliers pour faciliter la suite
537 $result->separateur
[] = $param;
538 elseif (($param == 'tout') OR ($param == 'tous'))
539 $result->modificateur
['tout'] = true;
540 elseif ($param == 'plat')
541 $result->modificateur
['plat'] = true;
543 // Boucle hierarchie, analyser le critere id_rubrique
544 // et les autres critères {id_x} pour forcer {tout} sur
545 // ceux-ci pour avoir la rubrique mere...
546 // Les autres critères de la boucle hierarchie doivent être
547 // traités normalement.
548 elseif (strcasecmp($type, 'hierarchie')==0
549 AND !preg_match(",^id_rubrique\b,",$param)
550 AND preg_match(",^id_\w+\s*$,", $param))
552 $result->modificateur
['tout'] = true;
554 elseif (strcasecmp($type, 'hierarchie')==0 AND $param=="id_rubrique") {
555 // rien a faire sur {id_rubrique} tout seul
558 // pas d'emplacement statique, faut un dynamique
559 /// mais il y a 2 cas qui ont les 2 !
560 if (($param == 'unique') ||
(preg_match(',^!?doublons *,', $param)))
562 // cette variable sera inseree dans le code
563 // et son nom sert d'indicateur des maintenant
564 $result->doublons
= '$doublons_index';
565 if ($param == 'unique') $param = 'doublons';
567 elseif ($param == 'recherche')
568 // meme chose (a cause de #nom_de_boucle:URL_*)
570 if (preg_match(',^ *([0-9-]+) *(/) *(.+) *$,', $param, $m)) {
571 $crit = phraser_critere_infixe($m[1], $m[3],$v, '/', '', '');
572 } elseif (preg_match(',^([!]?)(' . CHAMP_SQL_PLUS_FONC
.
573 ')[[:space:]]*(\??)(!?)(<=?|>=?|==?|\b(?:IN|LIKE)\b)(.*)$,is', $param, $m)) {
575 if ($a2 AND ($a2[0]=="'" OR $a2[0]=='"') AND ($a2[0]==substr($a2,-1)))
576 $a2 = substr($a2,1,-1);
577 $crit = phraser_critere_infixe($m[2], $a2, $v,
578 (($m[2] == 'lang_select') ?
$m[2] : $m[7]),
580 $crit->exclus
= $m[1];
581 } elseif (preg_match("/^([!]?)\s*(" .
582 CHAMP_SQL_PLUS_FONC
.
583 ")\s*(\??)(.*)$/is", $param, $m)) {
584 // contient aussi les comparaisons implicites !
586 // le premier arg contient l'operateur
589 $v[0][0] = new Texte
;
590 $v[0][0]->texte
= $m[6];
593 if (!$v[0]) array_shift($v);
602 $err_ci = array('zbug_critere_inconnu',
603 array('critere' => $param));
604 erreur_squelette($err_ci, $result);
606 if ((!preg_match(',^!?doublons *,', $param)) ||
$crit->not
)
614 // les doublons non nies doivent etre le dernier critere
615 // pour que la variable $doublon_index ait la bonne valeur
616 // cf critere_doublon
617 if ($doublons) $args= array_merge($args, $doublons);
618 // Si erreur, laisser la chaine dans ce champ pour le HTTP 503
619 if (!$err_ci) $result->criteres
= $args;
622 // http://doc.spip.org/@phraser_critere_infixe
623 function phraser_critere_infixe($arg1, $arg2, $args, $op, $not, $cond)
625 $args[0] = new Texte
;
626 $args[0]->texte
= $arg1;
627 $args[0] = array($args[0]);
628 $args[1][0] = new Texte
;
629 $args[1][0]->texte
= $arg2;
634 $crit->param
= $args;
638 function public_phraser_html_dist($texte, $id_parent, &$boucles, $descr, $ligne=1) {
642 while (($pos_boucle = strpos($texte, BALISE_BOUCLE
)) !== false) {
644 $err_b = ''; // indiquera s'il y a eu une erreur
645 $result = new Boucle
;
646 $result->id_parent
= $id_parent;
647 $result->descr
= $descr;
648 # attention: reperer la premiere des 2 balises: pre_boucle ou boucle
650 if (!preg_match(",".BALISE_PRE_BOUCLE
. '[0-9_],', $texte, $r)
651 OR ($n = strpos($texte, $r[0]))===false
652 OR ($n > $pos_boucle) ) {
653 $debut = substr($texte, 0, $pos_boucle);
654 $milieu = substr($texte, $pos_boucle);
655 $k = strpos($milieu, '(');
656 $id_boucle = trim(substr($milieu,
657 strlen(BALISE_BOUCLE
),
658 $k - strlen(BALISE_BOUCLE
)));
659 $milieu = substr($milieu, $k);
662 $debut = substr($texte, 0, $n);
663 $milieu = substr($texte, $n);
664 $k = strpos($milieu, '>');
665 $id_boucle = substr($milieu,
666 strlen(BALISE_PRE_BOUCLE
),
667 $k - strlen(BALISE_PRE_BOUCLE
));
669 if (!preg_match(",".BALISE_BOUCLE
. $id_boucle . "[[:space:]]*\(,", $milieu, $r)) {
670 $err_b = array('zbug_erreur_boucle_syntaxe', array('id' => $id_boucle));
671 erreur_squelette($err_b, $result);
674 $n = strpos($milieu, $r[0]);
675 $result->avant
= substr($milieu, $k+
1, $n-$k-1);
676 $milieu = substr($milieu, $n+
strlen($id_boucle)+
strlen(BALISE_BOUCLE
));
678 $result->id_boucle
= $id_boucle;
680 preg_match(SPEC_BOUCLE
, $milieu, $match);
681 $result->type_requete
= $match[0];
682 $milieu = substr($milieu, strlen($match[0]));
684 $jointures = trim($match[2]);
685 $table_optionnelle = ($match[3]);
687 // on affecte pas ici les jointures explicites, mais dans la compilation
688 // ou elles seront completees des jointures declarees
689 $result->jointures_explicites
= $jointures;
692 if ($table_optionnelle){
693 $result->table_optionnelle
= $type;
696 // 1ere passe sur les criteres, vu comme des arguments sans fct
697 // Resultat mis dans result->param
698 phraser_args($milieu,"/>","",$all_res,$result);
700 // En 2e passe result->criteres contiendra un tableau
701 // pour l'instant on met le source (chaine) :
702 // si elle reste ici au final, c'est qu'elle contient une erreur
703 $result->criteres
= substr($milieu,0,@strpos
($milieu,$result->apres
));
704 $milieu = $result->apres
;
708 // Recuperer la fin :
710 if ($milieu[0] === '/') {
711 $suite = substr($milieu,2);
714 $milieu = substr($milieu,1);
715 $s = BALISE_FIN_BOUCLE
. $id_boucle . ">";
716 $p = strpos($milieu, $s);
718 $err_b = array('zbug_erreur_boucle_fermant',
719 array('id' => $id_boucle));
720 erreur_squelette($err_b, $result);
723 $suite = substr($milieu, $p +
strlen($s));
724 $milieu = substr($milieu, 0, $p);
727 $result->milieu
= $milieu;
730 // 1. Recuperer la partie conditionnelle apres
732 $s = BALISE_POST_BOUCLE
. $id_boucle . ">";
733 $p = strpos($suite, $s);
735 $result->apres
= substr($suite, 0, $p);
736 $suite = substr($suite, $p +
strlen($s));
740 // 2. Recuperer la partie alternative
742 $s = BALISE_ALT_BOUCLE
. $id_boucle . ">";
743 $p = strpos($suite, $s);
745 $result->altern
= substr($suite, 0, $p);
746 $suite = substr($suite, $p +
strlen($s));
748 $result->ligne
= $ligne +
substr_count($debut, "\n");
749 $m = substr_count($milieu, "\n");
750 $b = substr_count($result->avant
, "\n");
751 $a = substr_count($result->apres
, "\n");
753 if ($p = strpos($type, ':')) {
754 $result->sql_serveur
= substr($type,0,$p);
755 $type = substr($type,$p+
1);
757 $soustype = strtolower($type);
759 if (!isset($GLOBALS["table_des_tables"][$soustype]))
762 $result->type_requete
= $soustype;
763 // Lancer la 2e passe sur les criteres si la 1ere etait bonne
764 if (!is_array($result->param
))
767 phraser_criteres($result->param
, $result);
768 if (strncasecmp($soustype, TYPE_RECURSIF
, strlen(TYPE_RECURSIF
)) == 0) {
769 $result->type_requete
= TYPE_RECURSIF
;
770 $args = $result->param
;
772 substr($type, strlen(TYPE_RECURSIF
)));
773 $result->param
= $args;
777 $result->avant
= public_phraser_html_dist($result->avant
, $id_parent,$boucles, $descr, $result->ligne
);
778 $result->apres
= public_phraser_html_dist($result->apres
, $id_parent,$boucles, $descr, $result->ligne+
$b+
$m);
779 $result->altern
= public_phraser_html_dist($result->altern
,$id_parent,$boucles, $descr, $result->ligne+
$a+
$m+
$b);
780 $result->milieu
= public_phraser_html_dist($milieu, $id_boucle,$boucles, $descr, $result->ligne+
$b);
782 // Prevenir le generateur de code que le squelette est faux
783 if ($err_b) $result->type_requete
= false;
785 // Verifier qu'il n'y a pas double definition
786 // apres analyse des sous-parties (pas avant).
788 if (isset($boucles[$id_boucle])) {
789 $err_b_d = array('zbug_erreur_boucle_double',
790 array('id'=>$id_boucle));
791 erreur_squelette($err_b_d, $result);
792 // Prevenir le generateur de code que le squelette est faux
793 $boucles[$id_boucle]->type_requete
= false;
795 $boucles[$id_boucle] = $result;
796 $all_res = phraser_champs_etendus($debut, $ligne, $all_res);
797 $all_res[] = &$boucles[$id_boucle];
798 $ligne +
= substr_count(substr($texte, 0, strpos($texte, $suite)), "\n");
802 return phraser_champs_etendus($texte, $ligne, $all_res);