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 \***************************************************************************/
15 * Fichier principal du compilateur de squelettes
17 * @package SPIP\Compilateur\Compilation
20 if (!defined('_ECRIRE_INC_VERSION')) return;
22 /** Repérer un code ne calculant rien, meme avec commentaire */
23 define('CODE_MONOTONE', ",^(\n//[^\n]*\n)?\(?'([^'])*'\)?$,");
24 /** Indique s'il faut commenter le code produit */
25 define('CODE_COMMENTE', true);
27 // definition des structures de donnees
28 include_spip('public/interfaces');
30 // Definition de la structure $p, et fonctions de recherche et de reservation
31 // dans l'arborescence des boucles
32 include_spip('public/references');
34 // production du code qui peut etre securisee
35 include_spip('public/sandbox');
37 // definition des boucles
38 include_spip('public/boucles');
40 // definition des criteres
41 include_spip('public/criteres');
43 // definition des balises
44 include_spip('public/balises');
46 // Gestion des jointures
47 include_spip('public/jointures');
49 // Les 2 ecritures INCLURE{A1,A2,A3...} et INCLURE(A1){A2}{A3}... sont admises
50 // Preferer la premiere.
51 // Les Ai sont de la forme Vi=Ei ou bien Vi qui veut alors dire Vi=Vi
52 // Le resultat est un tableau indexe par les Vi
53 // Toutefois, si le premier argument n'est pas de la forme Vi=Ei
54 // il est conventionnellement la valeur de l'index 1.
55 // pour la balise #INCLURE
56 // mais pas pour <INCLURE> dont le fond est defini explicitement.
59 // http://doc.spip.org/@argumenter_inclure
60 function argumenter_inclure($params, $rejet_filtres, $p, &$boucles, $id_boucle, $echap=true, $lang = '', $fond1=false){
63 if (!is_array($params)) return $l;
64 foreach($params as $k => $couple) {
65 // la liste d'arguments d'inclusion peut se terminer par un filtre
66 $filtre = array_shift($couple);
68 foreach($couple as $n => $val) {
70 if ($var->type
!= 'texte') {
71 if ($n OR $k OR $fond1) {
72 $erreur_p_i_i = array('zbug_parametres_inclus_incorrects',
73 array('param' => $var->nom_champ
));
74 erreur_squelette($erreur_p_i_i, $p);
75 } else $l[1] = calculer_liste($val, $p->descr
, $boucles, $id_boucle);
78 preg_match(",^([^=]*)(=?)(.*)$,", $var->texte
,$m);
83 if (preg_match(',^[\'"](.*)[\'"]$,', $v, $m)) $v = $m[1];
86 } elseif ($k OR $n OR $fond1) {
92 ?
calculer_liste($val, $p->descr
, $boucles, $id_boucle)
93 : '$GLOBALS["spip_lang"]';
96 ?
index_pile($id_boucle, $var, $boucles)
97 : calculer_liste($val, $p->descr
, $boucles, $id_boucle);
99 $val = ($echap?
"\'$var\' => ' . argumenter_squelette(":"'$var' => ")
100 . $val . ($echap?
") . '":" ");
101 else $val = $echap ?
"'.$val.'" : $val;
107 if ($erreur_p_i_i) return false;
108 // Cas particulier de la langue : si {lang=xx} est definie, on
109 // la passe, sinon on passe la langue courante au moment du calcul
110 // sauf si on n'en veut pas
111 if ($lang === false) return $l;
112 if (!$lang) $lang = '$GLOBALS["spip_lang"]';
113 $l['lang'] = ($echap?
"\'lang\' => ' . argumenter_squelette(":"'lang' => ") . $lang . ($echap?
") . '":" ");
119 * Code d'appel à un <INCLURE()>
121 * Code PHP pour un squelette (aussi pour #INCLURE, #MODELE #LES_AUTEURS)
123 define('CODE_RECUPERER_FOND', 'recuperer_fond(%s, %s, array(%s), %s)');
126 * Compile une inclusion <INCLURE> ou #INCLURE
129 * Description de l'inclusion (AST au niveau de l'inclure)
130 * @param array $boucles
132 * @param string $id_boucle
133 * Identifiant de la boucle contenant l'inclure
135 * Code PHP appelant l'inclusion
137 function calculer_inclure($p, &$boucles, $id_boucle) {
139 $_contexte = argumenter_inclure($p->param
, false, $p, $boucles, $id_boucle, true, '', true);
140 if (is_string($p->texte
)) {
141 $fichier = $p->texte
;
142 $code = "\"$fichier\"";
145 $code = calculer_liste($p->texte
, $p->descr
, $boucles, $id_boucle);
146 if ($code AND preg_match("/^'([^']*)'/s", $code, $r))
150 if (!$code OR $code === '""') {
151 $erreur_p_i_i = array('zbug_parametres_inclus_incorrects',
152 array('param' => $code));
153 erreur_squelette($erreur_p_i_i, $p);
156 $compil = texte_script(memoriser_contexte_compil($p));
158 if (is_array($_contexte)) {
159 // Critere d'inclusion {env} (et {self} pour compatibilite ascendante)
160 if ($env = (isset($_contexte['env'])||
isset($_contexte['self']))) {
161 unset($_contexte['env']);
164 // noter les doublons dans l'appel a public.php
165 if (isset($_contexte['doublons'])) {
166 $_contexte['doublons'] = "\\'doublons\\' => '.var_export(\$doublons,true).'";
169 if ($ajax = isset($_contexte['ajax'])){
170 $ajax = preg_replace(",=>(.*)$,ims",'=> ($v=(\\1))?$v:true',$_contexte['ajax']);
171 unset($_contexte['ajax']);
174 $_contexte = join(",\n\t", $_contexte);
177 return false; // j'aurais voulu toucher le fond ...
179 $contexte = 'array(' . $_contexte .')';
182 $contexte = "array_merge('.var_export(\$Pile[0],1).',$contexte)";
185 // s'il y a une extension .php, ce n'est pas un squelette
186 if (preg_match('/^.+[.]php$/s', $fichier)) {
187 $code = sandbox_composer_inclure_php($fichier, $p);
189 $_options[] = "\"compil\"=>array($compil)";
192 $code = " ' . argumenter_squelette($code) . '";
193 $code = "echo " . sprintf(CODE_RECUPERER_FOND
, $code, $contexte, implode(',',$_options), "_request(\"connect\")") . ';';
196 return "\n'<'.'". "?php ". $code . "\n?'." . "'>'";
201 * Gérer les statuts declarés pour cette table
203 * S'il existe des statuts sur cette table, déclarés dans la description
204 * d'un objet éditorial, applique leurs contraintes
206 * @param Boucle $boucle
207 * Descrition de la boucle
208 * @param bool $echapper
209 * true pour échapper le code créé
210 * @param bool $ignore_previsu
211 * true pour ne tester que le cas publie et ignorer l'eventuel var_mode=preview de la page
213 function instituer_boucle(&$boucle, $echapper=true, $ignore_previsu=false){
215 $show['statut'][] = array(
216 'champ'=>'statut', // champ de la table sur lequel porte le filtrage par le statut
217 'publie'=>'publie', // valeur ou liste de valeurs, qui definissent l'objet comme publie.
218 'previsu'=>'publie,prop', // valeur ou liste de valeurs qui sont visibles en previsu
219 'post_date'=>'date', // un champ de date pour la prise en compte des post_dates, ou rien sinon
220 'exception'=>'statut', // liste des modificateurs qui annulent le filtrage par statut
221 // si plusieurs valeurs : array('statut','tout','lien')
224 Pour 'publier' ou 'previsu', si la chaine commence par un "!" on exclu au lieu de filtrer sur les valeurs donnees
225 si la chaine est vide, on ne garde rien si elle est seulement "!" on n'exclu rien
227 Si le statut repose sur une jointure, 'champ' est alors un tableau du format suivant :
235 champstatut est alors le champ statut sur la tablen
236 dans les jointures, clen peut etre un tableau pour une jointure complexe : array('id_objet','id_article','objet','article')
238 $id_table = $boucle->id_table
;
239 $show = $boucle->show
;
240 if (isset($show['statut']) AND $show['statut']){
241 foreach($show['statut'] as $k=>$s){
242 // Restreindre aux elements publies si pas de {statut} ou autre dans les criteres
244 if (isset($s['exception'])) {
245 foreach(is_array($s['exception'])?
$s['exception']:array($s['exception']) as $m) {
246 if (isset($boucle->modificateur
[$m]) OR isset($boucle->modificateur
['criteres'][$m])) {
254 if (is_array($s['champ'])){
255 $statut = preg_replace(',\W,','',array_pop($s['champ'])); // securite
256 $jointures = array();
257 // indiquer la description de chaque table dans le tableau de jointures,
258 // ce qui permet d'eviter certains GROUP BY inutiles.
259 $trouver_table = charger_fonction('trouver_table', 'base');
260 foreach($s['champ'] as $j) {
262 $def = $trouver_table($id);
263 $jointures[] = array('',array($id,$def),end($j));
265 $jointures[0][0] = $id_table;
266 if (!array_search($id, $boucle->from
)){
267 include_spip('public/jointures');
268 fabrique_jointures($boucle, $jointures, true, $boucle->show
, $id_table, '', $echapper);
270 // trouver l'alias de la table d'arrivee qui porte le statut
271 $id = array_search($id, $boucle->from
);
275 $statut = preg_replace(',\W,','',$s['champ']); // securite
277 $mstatut = $id .'.'.$statut;
279 $arg_ignore_previsu=($ignore_previsu?
",true":'');
280 include_spip('public/quete');
281 if (isset($s['post_date']) AND $s['post_date']
282 AND $GLOBALS['meta']["post_dates"] == 'non'){
283 $date = $id.'.'.preg_replace(',\W,','',$s['post_date']); // securite
284 array_unshift($boucle->where
,
286 "\nquete_condition_postdates('$date',"._q($boucle->sql_serveur
)."$arg_ignore_previsu)"
288 quete_condition_postdates($date,$boucle->sql_serveur
,$ignore_previsu)
291 array_unshift($boucle->where
,
293 "\nquete_condition_statut('$mstatut',"
294 . _q($s['previsu']).","
295 ._q($s['publie']).","
296 ._q($boucle->sql_serveur
)."$arg_ignore_previsu)"
298 quete_condition_statut($mstatut,$s['previsu'],$s['publie'],$boucle->sql_serveur
,$ignore_previsu)
306 * Produit le corps PHP d'une boucle Spip.
308 * Ce corps remplit une variable $t0 retournée en valeur.
309 * Ici on distingue boucles recursives et boucle à requête SQL
310 * et on insère le code d'envoi au debusqueur du resultat de la fonction.
312 * @param string $id_boucle
313 * Identifiant de la boucle
314 * @param array $boucles
317 * Code PHP compilé de la boucle
319 function calculer_boucle($id_boucle, &$boucles) {
321 $boucle = &$boucles[$id_boucle];
322 instituer_boucle($boucle);
323 $boucles[$id_boucle] = pipeline('post_boucle', $boucles[$id_boucle]);
325 // en mode debug memoriser les premiers passages dans la boucle,
326 // mais pas tous, sinon ca pete.
327 if (_request('var_mode_affiche') != 'resultat')
330 $trace = $boucles[$id_boucle]->descr
['nom'] . $id_boucle;
331 $trace = "if (count(@\$GLOBALS['debug_objets']['resultat']['$trace'])<3)
332 \$GLOBALS['debug_objets']['resultat']['$trace'][] = \$t0;";
334 return ($boucles[$id_boucle]->type_requete
== TYPE_RECURSIF
)
335 ?
calculer_boucle_rec($id_boucle, $boucles, $trace)
336 : calculer_boucle_nonrec($id_boucle, $boucles, $trace);
341 * Compilation d'une boucle recursive.
344 * Il suffit (ET IL FAUT) sauvegarder les valeurs des arguments passes par
345 * reference, car par definition un tel passage ne les sauvegarde pas
347 * @param string $id_boucle
348 * Identifiant de la boucle
349 * @param array $boucles
351 * @param string $trace
352 * Code PHP (en mode debug uniquement) servant à conserver une
353 * trace des premières valeurs de la boucle afin de pouvoir
354 * les afficher dans le débugueur ultérieurement
356 * Code PHP compilé de la boucle récursive
358 function calculer_boucle_rec($id_boucle, &$boucles, $trace) {
359 $nom = $boucles[$id_boucle]->param
[0];
361 // Numrows[$nom] peut ne pas être encore defini
362 "\n\t\$save_numrows = (isset(\$Numrows['$nom']) ? \$Numrows['$nom'] : array());"
363 . "\n\t\$t0 = " . $boucles[$id_boucle]->return . ";"
364 . "\n\t\$Numrows['$nom'] = (\$save_numrows);"
366 . "\n\treturn \$t0;";
370 * Compilation d'une boucle non recursive.
372 * La constante donne le cadre systématique du code:
373 * %s1: initialisation des arguments de calculer_select
374 * %s2: appel de calculer_select en donnant un contexte pour les cas d'erreur
375 * %s3: initialisation du sous-tableau Numrows[id_boucle]
376 * %s4: sauvegarde de la langue et calcul des invariants de boucle sur elle
377 * %s5: boucle while sql_fetch ou str_repeat si corps monotone
378 * %s6: restauration de la langue
379 * %s7: liberation de la ressource, en tenant compte du serveur SQL
380 * %s8: code de trace eventuel avant le retour
382 define('CODE_CORPS_BOUCLE', '%s
383 if (defined("_BOUCLE_PROFILER")) $timer = time()+microtime();
386 $iter = IterFactory::create(
397 if (defined("_BOUCLE_PROFILER")
398 AND 1000*($timer = (time()+microtime())-$timer) > _BOUCLE_PROFILER)
399 spip_log(intval(1000*$timer)."ms %s","profiler");
404 * Compilation d'une boucle (non recursive).
406 * @param string $id_boucle
407 * Identifiant de la boucle
408 * @param array $boucles
410 * @param string $trace
411 * Code PHP (en mode debug uniquement) servant à conserver une
412 * trace des premières valeurs de la boucle afin de pouvoir
413 * les afficher dans le débugueur ultérieurement
415 * Code PHP compilé de la boucle récursive
417 function calculer_boucle_nonrec($id_boucle, &$boucles, $trace) {
419 $boucle = &$boucles[$id_boucle];
420 $return = $boucle->return;
421 $type_boucle = $boucle->type_requete
;
422 $primary = $boucle->primary
;
423 $constant = preg_match(CODE_MONOTONE
, str_replace("\\'",'', $return));
424 $flag_cpt = $boucle->mode_partie ||
$boucle->cptrows
;
427 // faudrait expanser le foreach a la compil, car y en a souvent qu'un
428 // et puis faire un [] plutot qu'un "','."
429 if ($boucle->doublons
)
430 $corps .= "\n\t\t\tforeach(" . $boucle->doublons
. ' as $k) $doublons[$k] .= "," . ' .
431 index_pile($id_boucle, $primary, $boucles)
434 // La boucle doit-elle selectionner la langue ?
435 // - par defaut, les boucles suivantes le font
436 // (sauf si forcer_lang==true ou si le titre contient <multi>).
437 // - a moins d'une demande explicite via {!lang_select}
438 if (!$constant && $boucle->lang_select
!= 'non' &&
439 (($boucle->lang_select
== 'oui') ||
440 in_array($type_boucle, array(
441 'articles', 'rubriques', 'hierarchie', 'breves'
444 // Memoriser la langue avant la boucle et la restituer apres
445 // afin que le corps de boucle affecte la globale directement
446 $init_lang = "lang_select(\$GLOBALS['spip_lang']);\n\t";
447 $fin_lang = "lang_select();\n\t";
450 "\n\t\tlang_select_public("
451 . index_pile($id_boucle, 'lang', $boucles)
452 . ", '".$boucle->lang_select
."'"
453 . (in_array($type_boucle, array(
454 'articles', 'rubriques', 'hierarchie', 'breves'
455 )) ?
', '.index_pile($id_boucle, 'titre', $boucles) : '')
461 // sortir les appels au traducteur (invariants de boucle)
462 if (strpos($return, '?php') === false
463 AND preg_match_all("/\W(_T[(]'[^']*'[)])/", $return, $r)) {
465 foreach($r[1] as $t) {
466 $init_lang .= "\n\t\$l$i = $t;";
467 $return = str_replace($t, "\$l$i", $return);
473 // gestion optimale des separateurs et des boucles constantes
474 if (count($boucle->separateur
))
475 $code_sep = ("'" . str_replace("'","\'",join('',$boucle->separateur
)) . "'");
478 ((!$boucle->separateur
) ?
479 (($constant && !$corps && !$flag_cpt) ?
$return :
480 (($return==="''") ?
'' :
481 ("\n\t\t" . '$t0 .= ' . $return . ";"))) :
483 ((strpos($return, '$t1.') === 0) ?
484 (".=" . substr($return,4)) :
487 '$t0 .= ((strlen($t1) && strlen($t0)) ? ' . $code_sep . " : '') . \$t1;"));
489 // Calculer les invalideurs si c'est une boucle non constante et si on
490 // souhaite invalider ces elements
491 if (!$constant AND $primary) {
492 include_spip('inc/invalideur');
493 if (function_exists($i = 'calcul_invalideurs'))
494 $corps = $i($corps, $primary, $boucles, $id_boucle);
497 // gerer le compteur de boucle
498 // avec ou sans son utilisation par les criteres {1/3} {1,4} {n-2,1}...
500 if ($boucle->partie
OR $boucle->cptrows
)
501 $corps = "\n\t\t\$Numrows['$id_boucle']['compteur_boucle']++;"
505 // si le corps est une constante, ne pas appeler le serveur N fois!
507 if (preg_match(CODE_MONOTONE
,str_replace("\\'",'',$corps), $r)) {
508 if (!isset($r[2]) OR (!$r[2])) {
509 if (!$boucle->numrows
)
510 return "\n\t\$t0 = '';";
514 $boucle->numrows
= true;
515 $corps = "\n\t\$t0 = str_repeat($corps, \$Numrows['$id_boucle']['total']);";
517 } else $corps = "while (\$Pile[\$SP]=\$iter->fetch()) {\n$corps\n }";
520 if (!$boucle->select
) {
521 if (!$boucle->numrows
OR $boucle->limit
OR $boucle->mode_partie
OR $boucle->group
)
523 else $count = 'count(*)';
524 $boucles[$id_boucle]->select
[]= $count;
528 $nums = "\n\t// COMPTEUR\n\t"
529 . "\$Numrows['$id_boucle']['compteur_boucle'] = 0;\n\t";
532 if ($boucle->numrows
OR $boucle->mode_partie
) {
533 $nums .= "\$Numrows['$id_boucle']['total'] = @intval(\$iter->count());"
534 . $boucle->mode_partie
538 // Ne calculer la requete que maintenant
539 // car ce qui precede appelle index_pile qui influe dessus
541 $init = (($init = $boucles[$id_boucle]->doublons
)
542 ?
("\n\t$init = array();") : '')
543 . calculer_requete_sql($boucles[$id_boucle]);
545 $contexte = memoriser_contexte_compil($boucle);
547 $a = sprintf(CODE_CORPS_BOUCLE
,
557 'BOUCLE'.$id_boucle .' @ '.($boucle->descr
['sourcefile'])
566 * Calcule le code PHP d'une boucle contenant les informations qui produiront une requête SQL
568 * Le code produit est un tableau associatif $command contenant les informations
569 * pour que la boucle produise ensuite sa requête, tel que $command['from'] = 'spip_articles';
571 * @param Boucle $boucle
574 * Code PHP compilé définissant les informations de requête
576 function calculer_requete_sql($boucle)
579 $init[] = calculer_dec('table', "'" . $boucle->id_table
."'");
580 $init[] = calculer_dec('id', "'" . $boucle->id_boucle
."'");
581 # En absence de champ c'est un decompte :
582 $init[] = calculer_dec('from', calculer_from($boucle));
583 $init[] = calculer_dec('type', calculer_from_type($boucle));
584 $init[] = calculer_dec('groupby', 'array(' . (($g=join("\",\n\t\t\"",$boucle->group
))?
'"'.$g.'"':'') . ")");
585 $init[] = calculer_dec('select', 'array("' . join("\",\n\t\t\"", $boucle->select
). "\")");
586 $init[] = calculer_dec('orderby', 'array(' . calculer_order($boucle) . ")");
587 $init[] = calculer_dec('where', calculer_dump_array($boucle->where
));
588 $init[] = calculer_dec('join', calculer_dump_join($boucle->join
));
589 $init[] = calculer_dec('limit',
590 (strpos($boucle->limit
, 'intval') === false ?
591 "'".$boucle->limit
."'"
594 $init[] = calculer_dec('having', calculer_dump_array($boucle->having
));
596 foreach ($init as $i){
598 $s .= "\n\t\t".end($i);
600 $d .= "\n\t".end($i);
603 return ($boucle->hierarchie ?
"\n\t$boucle->hierarchie" : '')
606 . "\n\t".'if (!isset($command[\'table\'])) {'
613 * Retourne une chaîne des informations du contexte de compilation
615 * Retourne la source, le nom, l'identifiant de boucle, la ligne, la langue
616 * de l'élément dans une chaîne.
618 * @see reconstruire_contexte_compil()
621 * Objet de l'AST dont on mémorise le contexte
623 * Informations du contexte séparés par des virgules,
624 * qui peut être utilisé pour la production d'un tableau array()
626 function memoriser_contexte_compil($p) {
627 return join(',', array(
628 _q($p->descr
['sourcefile']),
629 _q($p->descr
['nom']),
632 '$GLOBALS[\'spip_lang\']'));
636 * Reconstruit un contexte de compilation
638 * Pour un tableau d'information de contexte donné,
639 * retourne un objet Contexte (objet générique de l'AST)
640 * avec ces informations
642 * @see memoriser_contexte_compil()
644 * @param array $context_compil
645 * Tableau des informations du contexte
649 function reconstruire_contexte_compil($context_compil)
651 if (!is_array($context_compil)) return $context_compil;
653 $p->descr
= array('sourcefile' => $context_compil[0],
654 'nom' => $context_compil[1]);
655 $p->id_boucle
= $context_compil[2];
656 $p->ligne
= $context_compil[3];
657 $p->lang
= $context_compil[4];
661 // http://doc.spip.org/@calculer_dec
662 function calculer_dec($nom, $val)
664 $static = 'if (!isset($command[\''.$nom.'\'])) ';
665 // si une variable apparait dans le calcul de la clause
666 // il faut la re-evaluer a chaque passage
668 strpos($val, '$') !== false
670 OR strpos($val, 'sql_') !== false
672 $test = str_replace(array("array(",'\"',"\'"),array("","",""),$val) // supprimer les array( et les echappements de guillemets
673 AND strpos($test,"(")!==FALSE // si pas de parenthese ouvrante, pas de fonction, on peut sortir
674 AND $test = preg_replace(",'[^']*',UimsS","",$test) // supprimer les chaines qui peuvent contenir des fonctions SQL qui ne genent pas
675 AND preg_match(",\w+\s*\(,UimsS",$test,$regs) // tester la presence de fonctions restantes
680 return array($static,'$command[\''.$nom.'\'] = ' . $val . ';');
683 // http://doc.spip.org/@calculer_dump_array
684 function calculer_dump_array($a)
686 if (!is_array($a)) return $a ;
688 if ($a AND $a[0] == "'?'")
689 return ("(" . calculer_dump_array($a[1]) .
690 " ? " . calculer_dump_array($a[2]) .
691 " : " . calculer_dump_array($a[3]) .
694 foreach($a as $v) $res .= ", " . calculer_dump_array($v);
695 return "\n\t\t\tarray(" . substr($res,2) . ')';
699 // http://doc.spip.org/@calculer_dump_join
700 function calculer_dump_join($a)
703 foreach($a as $k => $v)
704 $res .= ", '$k' => array(".implode(',',$v).")";
705 return 'array(' . substr($res,2) . ')';
708 // http://doc.spip.org/@calculer_from
709 function calculer_from(&$boucle)
712 foreach($boucle->from
as $k => $v) $res .= ",'$k' => '$v'";
713 return 'array(' . substr($res,1) . ')';
716 // http://doc.spip.org/@calculer_from_type
717 function calculer_from_type(&$boucle)
720 foreach($boucle->from_type
as $k => $v) $res .= ",'$k' => '$v'";
721 return 'array(' . substr($res,1) . ')';
724 // http://doc.spip.org/@calculer_order
725 function calculer_order(&$boucle)
727 if (!$order = $boucle->order
728 AND !$order = $boucle->default_order
)
731 /*if (isset($boucle->modificateur['collate'])){
732 $col = "." . $boucle->modificateur['collate'];
733 foreach($order as $k=>$o)
734 if (strpos($order[$k],'COLLATE')===false)
737 return join(', ', $order);
740 // Production du code PHP a partir de la sequence livree par le phraseur
741 // $boucles est passe par reference pour affectation par index_pile.
742 // Retourne une expression PHP,
743 // (qui sera argument d'un Return ou la partie droite d'une affectation).
745 // http://doc.spip.org/@calculer_liste
746 function calculer_liste($tableau, $descr, &$boucles, $id_boucle='') {
747 if (!$tableau) return "''";
748 if (!isset($descr['niv'])) $descr['niv'] = 0;
749 $codes = compile_cas($tableau, $descr, $boucles, $id_boucle);
750 if ($codes === false) return false;
752 if (!$n) return "''";
753 $tab = str_repeat("\t", $descr['niv']);
754 if (_request('var_mode_affiche') != 'validation') {
759 foreach($codes as $code) {
760 if (!preg_match("/^'[^']*'$/", $code)
761 OR substr($res,-1,1)!=="'")
762 $res .= " .\n$tab$code";
764 $res = substr($res,0,-1) . substr($code,1);
767 return '(' . substr($res,2+
$descr['niv']) . ')';
770 $nom = $descr['nom'] . $id_boucle . ($descr['niv']?
$descr['niv']:'');
771 return "join('', array_map('array_shift', \$GLOBALS['debug_objets']['sequence']['$nom'] = array(" . join(" ,\n$tab", $codes) . ")))";
775 define('_REGEXP_COND_VIDE_NONVIDE',"/^[(](.*)[?]\s*''\s*:\s*('[^']+')\s*[)]$/");
776 define('_REGEXP_COND_NONVIDE_VIDE',"/^[(](.*)[?]\s*('[^']+')\s*:\s*''\s*[)]$/");
777 define('_REGEXP_CONCAT_NON_VIDE', "/^(.*)[.]\s*'[^']+'\s*$/");
779 // http://doc.spip.org/@compile_cas
780 function compile_cas($tableau, $descr, &$boucles, $id_boucle) {
783 // cas de la boucle recursive
784 if (is_array($id_boucle))
785 $id_boucle = $id_boucle[0];
786 $type = !$id_boucle ?
'' : $boucles[$id_boucle]->type_requete
;
787 $tab = str_repeat("\t", ++
$descr['niv']);
788 $mode = _request('var_mode_affiche');
790 // chaque commentaire introduit dans le code doit commencer
791 // par un caractere distinguant le cas, pour exploitation par debug.
792 foreach ($tableau as $p) {
797 $code = sandbox_composer_texte($p->texte
, $p);
798 $commentaire= strlen($p->texte
) . " signes";
806 foreach($p->traductions
as $k => $v) {
808 str_replace(array("\\","'"),array("\\\\","\\'"), $k) .
810 str_replace(array("\\","'"),array("\\\\","\\'"), $v) .
813 $code = "choisir_traduction(array(" .
825 $code = calculer_inclure($p, $boucles, $id_boucle);
826 if ($code === false) {
830 $commentaire = '<INCLURE ' . addslashes(str_replace("\n", ' ', $code)) . '>';
839 $nom = $p->id_boucle
;
841 $newdescr['id_mere'] = $nom;
843 $avant = calculer_liste($p->avant
,
844 $newdescr, $boucles, $id_boucle);
845 $apres = calculer_liste($p->apres
,
846 $newdescr, $boucles, $id_boucle);
848 $altern = calculer_liste($p->altern
,
849 $newdescr, $boucles, $id_boucle);
850 if (($avant === false) OR ($apres === false) OR ($altern === false)) {
855 str_replace("-","_", $nom) . $descr['nom'] .
856 '($Cache, $Pile, $doublons, $Numrows, $SP)';
857 $commentaire= "?$nom";
858 if (!$boucles[$nom]->milieu
859 AND $boucles[$nom]->type_requete
<> TYPE_RECURSIF
) {
860 if ($altern != "''") $code .= "\n. $altern";
861 if ($avant<>"''" OR $apres<>"''")
862 spip_log("boucle $nom toujours vide, code superflu dans $id");
863 $avant = $apres = $altern = "''";
864 } else if ($altern != "''") $altern = "($altern)";
871 foreach ($p->arg
as $k => $v) {
872 $_v = calculer_liste($v, $descr, $boucles, $id_boucle);
874 $l[] = _q($k) . ' => ' . $_v;
879 // Si le module n'est pas fourni, l'expliciter sauf si calculé
881 $m = $p->module
.':'.$p->nom_champ
;
882 } elseif ($p->nom_champ
) {
883 $m = MODULES_IDIOMES
.':'.$p->nom_champ
;
887 $code = (!$code ?
"'$m'" :
888 ($m ?
"'$m' . $code" :
889 ("(strpos(\$x=$code, ':') ? \$x : ('" . MODULES_IDIOMES
. ":' . \$x))")))
890 . (!$l ?
'' : (", array(" . implode(",\n", $l) . ")"));
893 $p->id_boucle
= $id_boucle;
894 $p->boucles
= &$boucles;
895 $code = compose_filtres($p, $code);
905 // cette structure pourrait etre completee des le phrase' (a faire)
906 $p->id_boucle
= $id_boucle;
907 $p->boucles
= &$boucles;
909 #$p->interdire_scripts = true;
910 $p->type_requete
= $type;
912 $code = calculer_champ($p);
913 $commentaire = '#' . $p->nom_champ
. $p->etoile
;
914 $avant = calculer_liste($p->avant
,
915 $descr, $boucles, $id_boucle);
916 $apres = calculer_liste($p->apres
,
917 $descr, $boucles, $id_boucle);
919 // Si la valeur est destinee a une comparaison a ''
920 // forcer la conversion en une chaine par strval
921 // si ca peut etre autre chose qu'une chaine
922 if (($avant != "''" OR $apres != "''")
924 # AND (strpos($code,'interdire_scripts') !== 0)
925 AND !preg_match(_REGEXP_COND_VIDE_NONVIDE
, $code)
926 AND !preg_match(_REGEXP_COND_NONVIDE_VIDE
, $code)
927 AND !preg_match(_REGEXP_CONCAT_NON_VIDE
, $code))
928 $code = "strval($code)";
932 // Erreur de construction de l'arbre de syntaxe abstraite
935 $err_e_c = _T('zbug_erreur_compilation');
936 erreur_squelette($err_e_c, $p);
940 $code = compile_retour($code, $avant, $apres, $altern, $tab, $descr['niv']);
941 $codes[]= (($mode == 'validation') ?
942 "array($code, '$commentaire', " . $p->ligne
. ")"
943 : (($mode == 'code') ?
944 "\n// $commentaire\n$code" :
949 return $err_e_c ?
false : $codes;
952 // production d'une expression conditionnelle ((v=EXP) ? (p . v .s) : a)
953 // mais si EXP est de la forme (t ? 'C' : '') on produit (t ? (p . C . s) : a)
954 // de meme si EXP est de la forme (t ? '' : 'C')
956 // http://doc.spip.org/@compile_retour
957 function compile_retour($code, $avant, $apres, $altern, $tab, $n)
959 if ($avant == "''") $avant = '';
960 if ($apres == "''") $apres = '';
961 if (!$avant AND !$apres AND ($altern==="''")) return $code;
963 if (preg_match(_REGEXP_CONCAT_NON_VIDE
, $code)) {
966 } elseif (preg_match(_REGEXP_COND_VIDE_NONVIDE
,$code, $r)) {
969 } else if (preg_match(_REGEXP_COND_NONVIDE_VIDE
,$code, $r)) {
974 $cond = "($t = $code)!==''";
977 $res = (!$avant ?
"" : "$avant . ") .
979 (!$apres ?
"" : " . $apres");
981 if ($res !== $t) $res = "($res)";
982 return !$cond ?
$res : "($cond ?\n\t$tab$res :\n\t$tab$altern)";
986 function compile_inclure_doublons($lexemes)
988 foreach($lexemes as $v)
989 if($v->type
=== 'include' AND $v->param
)
990 foreach($v->param
as $r)
991 if (trim($r[0]) === 'doublons')
996 // Prend en argument le texte d'un squelette, le nom de son fichier d'origine,
997 // sa grammaire et un nom. Retourne False en cas d'erreur,
998 // sinon retourne un tableau de fonctions PHP compilees a evaluer,
999 // notamment une fonction portant ce nom et calculant une page.
1000 // Pour appeler la fonction produite, lui fournir 2 tableaux de 1 e'le'ment:
1001 // - 1er: element 'cache' => nom (du fichier ou` mettre la page)
1002 // - 2e: element 0 contenant un environnement ('id_article => $id_article, etc)
1003 // Elle retournera alors un tableau de 5 e'le'ments:
1004 // - 'texte' => page HTML, application du squelette a` l'environnement;
1005 // - 'squelette' => le nom du squelette
1006 // - 'process_ins' => 'html' ou 'php' selon la pre'sence de PHP dynamique
1007 // - 'invalideurs' => de'pendances de cette page, pour invalider son cache.
1008 // - 'entetes' => tableau des entetes http
1009 // En cas d'erreur, elle retournera un tableau des 2 premiers elements seulement
1011 // http://doc.spip.org/@public_compiler_dist
1012 function public_compiler_dist($squelette, $nom, $gram, $sourcefile, $connect=''){
1013 // Pre-traitement : reperer le charset du squelette, et le convertir
1014 // Bonus : supprime le BOM
1015 include_spip('inc/charsets');
1016 $squelette = transcoder_page($squelette);
1018 // rendre inertes les echappements de #[](){}<>
1020 while(false !== strpos($squelette, $inerte = '-INERTE'.$i)) $i++
;
1021 $squelette = preg_replace_callback(',\\\\([#[()\]{}<>]),',
1022 create_function('$a', "return '$inerte-'.ord(\$a[1]).'-';"), $squelette, -1, $esc);
1024 $descr = array('nom' => $nom,
1026 'sourcefile' => $sourcefile,
1027 'squelette' => $squelette);
1029 // Phraser le squelette, selon sa grammaire
1032 $f = charger_fonction('phraser_' . $gram, 'public');
1034 $squelette = $f($squelette, '', $boucles, $descr);
1035 $boucles = compiler_squelette($squelette, $boucles, $nom, $descr, $sourcefile, $connect);
1037 // restituer les echappements
1039 foreach($boucles as $i=>$boucle) {
1040 $boucles[$i]->return = preg_replace_callback(",$inerte-(\d+)-,", create_function('$a', 'return chr($a[1]);'),
1042 $boucles[$i]->descr
['squelette'] = preg_replace_callback(",$inerte-(\d+)-,", create_function('$a', 'return "\\\\".chr($a[1]);'),
1043 $boucle->descr
['squelette']);
1046 $debug = ($boucles AND defined('_VAR_MODE') AND _VAR_MODE
== 'debug');
1048 include_spip('public/decompiler');
1049 foreach($boucles as $id => $boucle) {
1051 $decomp = "\n/* BOUCLE " .
1052 $boucle->type_requete
.
1054 str_replace('*/', '* /', public_decompiler($boucle, $gram, 0, 'criteres')) .
1056 else $decomp = ("\n/*\n" .
1057 str_replace('*/', '* /', public_decompiler($squelette, $gram))
1059 $boucles[$id]->return = $decomp .$boucle->return;
1060 $GLOBALS['debug_objets']['code'][$nom.$id] = $boucle->return;
1067 // Point d'entree pour arbre de syntaxe abstraite fourni en premier argument
1068 // Autres specifications comme ci-dessus
1070 function compiler_squelette($squelette, $boucles, $nom, $descr, $sourcefile, $connect=''){
1071 static $trouver_table;
1072 spip_timer('calcul_skel');
1074 if (defined('_VAR_MODE') AND _VAR_MODE
== 'debug') {
1075 $GLOBALS['debug_objets']['squelette'][$nom] = $descr['squelette'];
1076 $GLOBALS['debug_objets']['sourcefile'][$nom] = $sourcefile;
1078 if (!isset($GLOBALS['debug_objets']['principal']))
1079 $GLOBALS['debug_objets']['principal'] = $nom;
1081 foreach ($boucles as $id => $boucle) {
1082 $GLOBALS['debug_objets']['boucle'][$nom.$id] = $boucle;
1084 $descr['documents'] = compile_inclure_doublons($squelette);
1086 // Demander la description des tables une fois pour toutes
1087 // et reperer si les doublons sont demandes
1088 // pour un inclure ou une boucle document
1089 // c'est utile a la fonction champs_traitements
1090 if (!$trouver_table)
1091 $trouver_table = charger_fonction('trouver_table', 'base');
1093 foreach($boucles as $id => $boucle) {
1094 if (!($type = $boucle->type_requete
)) continue;
1095 if (!$descr['documents'] AND (
1096 (($type == 'documents') AND $boucle->doublons
) OR
1097 compile_inclure_doublons($boucle->avant
) OR
1098 compile_inclure_doublons($boucle->apres
) OR
1099 compile_inclure_doublons($boucle->milieu
) OR
1100 compile_inclure_doublons($boucle->altern
)))
1101 $descr['documents'] = true;
1102 if ($type != TYPE_RECURSIF
) {
1103 if (!$boucles[$id]->sql_serveur
AND $connect)
1104 $boucles[$id]->sql_serveur
= $connect;
1106 // chercher dans les iterateurs du repertoire iterateur/
1107 if ($g = charger_fonction(
1108 preg_replace('/\W/', '_', $boucle->type_requete
), 'iterateur', true)) {
1109 $boucles[$id] = $g($boucle);
1111 // sinon, en cas de requeteur d'un type predefini,
1112 // utiliser les informations donnees par le requeteur
1113 // cas "php:xx" et "data:xx".
1114 } else if ($boucle->sql_serveur
AND $requeteur = charger_fonction($boucle->sql_serveur
, 'requeteur', true)) {
1115 $requeteur($boucles, $boucle, $id);
1117 // utiliser la description des champs transmis
1119 $show = $trouver_table($type, $boucles[$id]->sql_serveur
);
1120 // si la table n'existe pas avec le connecteur par defaut,
1121 // c'est peut etre une table qui necessite son connecteur dedie fourni
1122 // permet une ecriture allegee (GEO) -> (geo:GEO)
1124 AND $show=$trouver_table($type, strtolower($type))) {
1125 $boucles[$id]->sql_serveur
= strtolower($type);
1128 $boucles[$id]->show
= $show;
1129 // recopie les infos les plus importantes
1130 $boucles[$id]->primary
= $show['key']["PRIMARY KEY"];
1131 $boucles[$id]->id_table
= $x = preg_replace(",^spip_,","",$show['id_table']);
1132 $boucles[$id]->from
[$x] = $nom_table = $show['table'];
1133 $boucles[$id]->iterateur
= 'SQL';
1135 $boucles[$id]->descr
= &$descr;
1136 if ((!$boucles[$id]->jointures
)
1137 AND is_array($show['tables_jointures'])
1138 AND count($x = $show['tables_jointures']))
1139 $boucles[$id]->jointures
= $x;
1140 if ($boucles[$id]->jointures_explicites
){
1141 $jointures = preg_split("/\s+/",$boucles[$id]->jointures_explicites
);
1142 while ($j=array_pop($jointures))
1143 array_unshift($boucles[$id]->jointures
,$j);
1146 // Pas une erreur si la table est optionnelle
1147 if ($boucles[$id]->table_optionnelle
)
1148 $boucles[$id]->type_requete
= '';
1150 $boucles[$id]->type_requete
= false;
1151 $boucle = $boucles[$id];
1152 $x = (!$boucle->sql_serveur ?
'' :
1153 ($boucle->sql_serveur
. ":")) .
1155 $msg = array('zbug_table_inconnue',
1156 array('table' => $x));
1157 erreur_squelette($msg, $boucle);
1164 // Commencer par reperer les boucles appelees explicitement
1165 // car elles indexent les arguments de maniere derogatoire
1166 foreach($boucles as $id => $boucle) {
1167 if ($boucle->type_requete
== TYPE_RECURSIF
AND $boucle->param
) {
1168 $boucles[$id]->descr
= &$descr;
1169 $rec = &$boucles[$boucle->param
[0]];
1171 $msg = array('zbug_boucle_recursive_undef',
1172 array('nom' => $boucle->param
[0]));
1173 erreur_squelette($msg, $boucle);
1174 $boucles[$id]->type_requete
= false;
1176 $rec->externe
= $id;
1177 $descr['id_mere'] = $id;
1178 $boucles[$id]->return =
1179 calculer_liste(array($rec),
1186 foreach($boucles as $id => $boucle) {
1187 $id = strval($id); // attention au type dans index_pile
1188 $type = $boucle->type_requete
;
1189 if ($type AND $type != TYPE_RECURSIF
) {
1191 if ($boucle->param
) {
1192 // retourne un tableau en cas d'erreur
1193 $res = calculer_criteres($id, $boucles);
1195 $descr['id_mere'] = $id;
1196 $boucles[$id]->return =
1197 calculer_liste($boucle->milieu
,
1201 // Si les criteres se sont mal compiles
1202 // ne pas tenter d'assembler le code final
1203 // (mais compiler le corps pour detection d'erreurs)
1204 if (is_array($res)) {
1205 $boucles[$id]->type_requete
= false;
1210 // idem pour la racine
1211 $descr['id_mere'] = '';
1212 $corps = calculer_liste($squelette, $descr, $boucles);
1216 // Calcul du corps de toutes les fonctions PHP,
1217 // en particulier les requetes SQL et TOTAL_BOUCLE
1218 // de'terminables seulement maintenant
1220 foreach($boucles as $id => $boucle) {
1221 $boucle = $boucles[$id] = pipeline('pre_boucle', $boucle);
1222 if ($boucle->return === false) {$corps = false; continue;}
1223 // appeler la fonction de definition de la boucle
1225 if ($req = $boucle->type_requete
) {
1226 // boucle personnalisée ?
1227 $table = strtoupper($boucle->type_requete
);
1228 $serveur = strtolower($boucle->sql_serveur
);
1230 // fonction de boucle avec serveur & table
1232 ((!function_exists($f = "boucle_".$serveur."_".$table))
1233 AND (!function_exists($f = $f."_dist"))
1236 // fonction de boucle avec table
1237 AND (!function_exists($f = "boucle_".$table))
1238 AND (!function_exists($f = $f."_dist"))
1240 // fonction de boucle standard
1241 if (!function_exists($f = 'boucle_DEFAUT')) {
1242 $f = 'boucle_DEFAUT_dist';
1246 $req = "\n\n\tstatic \$command = array();\n\t" .
1247 "static \$connect;\n\t" .
1248 "\$command['connect'] = \$connect = " .
1249 _q($boucle->sql_serveur
) .
1252 } else $req = ("\n\treturn '';");
1254 $boucles[$id]->return =
1255 "\n\nfunction BOUCLE" . strtr($id,"-","_") . $nom .
1256 '(&$Cache, &$Pile, &$doublons, &$Numrows, $SP) {' .
1261 // Au final, si le corps ou un critere au moins s'est mal compile
1262 // retourner False, sinon inserer leur decompilation
1263 if (is_bool($corps)) return false;
1265 $principal = "\nfunction " . $nom . '($Cache, $Pile, $doublons=array(), $Numrows=array(), $SP=0) {
1267 // reporter de maniere securisee les doublons inclus
1269 if (isset($Pile[0]["doublons"]) AND is_array($Pile[0]["doublons"]))
1270 $doublons = nettoyer_env_doublons($Pile[0]["doublons"]);
1275 // ATTENTION, le calcul de l'expression $corps affectera $Cache
1276 // c'est pourquoi on l'affecte a la variable auxiliaire $page.
1277 // avant de referencer $Cache
1280 return analyse_resultat_skel(".var_export($nom,true)
1281 .", \$Cache, \$page, ".var_export($sourcefile,true).");
1284 $secondes = spip_timer('calcul_skel');
1285 spip_log("COMPIL ($secondes) [$sourcefile] $nom.php");
1286 // $connect n'est pas sûr : on nettoie
1287 $connect = preg_replace(',[^\w],', '', $connect);
1289 // Assimiler la fct principale a une boucle anonyme, pour retourner un resultat simple
1291 $code->descr
= $descr;
1294 // Fonction principale du squelette ' .
1296 ($connect ?
" pour $connect" : '') .
1297 (!CODE_COMMENTE ?
'' : "\n// Temps de compilation total: $secondes") .
1301 $boucles[''] = $code;
1307 * Requeteur pour les boucles (php:nom_iterateur)
1309 * Analyse si le nom d'iterateur correspond bien a une classe PHP existante
1310 * et dans ce cas charge la boucle avec cet iterateur.
1311 * Affichera une erreur dans le cas contraire.
1313 * @param $boucles Liste des boucles
1314 * @param $boucle La boucle parcourue
1315 * @param $id L'identifiant de la boucle parcourue
1318 function requeteur_php_dist(&$boucles, &$boucle, &$id) {
1319 if (class_exists($boucle->type_requete
)) {
1320 $g = charger_fonction('php', 'iterateur');
1321 $boucles[$id] = $g($boucle, $boucle->type_requete
);
1323 $x = $boucle->type_requete
;
1324 $boucle->type_requete
= false;
1325 $msg = array('zbug_iterateur_inconnu',
1326 array('iterateur' => $x));
1327 erreur_squelette($msg, $boucle);
1333 * Requeteur pour les boucles (data:type de donnee)
1334 * note: (DATA) tout court ne passe pas par ici.
1336 * Analyse si le type de donnee peut etre traite
1337 * et dans ce cas charge la boucle avec cet iterateur.
1338 * Affichera une erreur dans le cas contraire.
1340 * @param $boucles Liste des boucles
1341 * @param $boucle La boucle parcourue
1342 * @param $id L'identifiant de la boucle parcourue
1345 function requeteur_data_dist(&$boucles, &$boucle, &$id) {
1346 include_spip('iterateur/data');
1347 if ($h = charger_fonction($boucle->type_requete
. '_to_array' , 'inc', true)) {
1348 $g = charger_fonction('data', 'iterateur');
1349 $boucles[$id] = $g($boucle);
1350 // from[0] stocke le type de data (rss, yql, ...)
1351 $boucles[$id]->from
[] = $boucle->type_requete
;
1354 $x = $boucle->type_requete
;
1355 $boucle->type_requete
= false;
1356 $msg = array('zbug_requeteur_inconnu',
1358 'requeteur' => 'data',
1361 erreur_squelette($msg, $boucle);