dépôts / velocampus / web / www.git / blob
? search:


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