3 /***************************************************************************\
4 * SPIP, Systeme de publication pour l'internet *
6 * Copyright (c) 2001-2019 *
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\Core\Compilateur\Compilation
20 if (!defined('_ECRIRE_INC_VERSION')) {
24 /** Repérer un code ne calculant rien, meme avec commentaire */
25 define('CODE_MONOTONE', ",^(\n//[^\n]*\n)?\(?'([^'])*'\)?$,");
26 /** Indique s'il faut commenter le code produit */
27 define('CODE_COMMENTE', true);
29 // definition des structures de donnees
30 include_spip('public/interfaces');
32 // Definition de la structure $p, et fonctions de recherche et de reservation
33 // dans l'arborescence des boucles
34 include_spip('public/references');
36 // production du code qui peut etre securisee
37 include_spip('public/sandbox');
39 // definition des boucles
40 include_spip('public/boucles');
42 // definition des criteres
43 include_spip('public/criteres');
45 // definition des balises
46 include_spip('public/balises');
48 // Gestion des jointures
49 include_spip('public/jointures');
51 // Les 2 ecritures INCLURE{A1,A2,A3...} et INCLURE(A1){A2}{A3}... sont admises
52 // Preferer la premiere.
53 // Les Ai sont de la forme Vi=Ei ou bien Vi qui veut alors dire Vi=Vi
54 // Le resultat est un tableau indexe par les Vi
55 // Toutefois, si le premier argument n'est pas de la forme Vi=Ei
56 // il est conventionnellement la valeur de l'index 1.
57 // pour la balise #INCLURE
58 // mais pas pour <INCLURE> dont le fond est defini explicitement.
61 // http://code.spip.net/@argumenter_inclure
62 function argumenter_inclure(
74 if (!is_array($params)) {
77 foreach ($params as $k => $couple) {
78 // la liste d'arguments d'inclusion peut se terminer par un filtre
79 $filtre = array_shift($couple);
83 foreach ($couple as $n => $val) {
85 if ($var->type
!= 'texte') {
86 if ($n or $k or $fond1) {
87 $erreur_p_i_i = array(
88 'zbug_parametres_inclus_incorrects',
89 array('param' => $var->nom_champ
)
91 erreur_squelette($erreur_p_i_i, $p);
94 $l[1] = calculer_liste($val, $p->descr
, $boucles, $id_boucle);
97 preg_match(",^([^=]*)(=?)(.*)$,m", $var->texte
, $m);
98 $m = array_pad($m, 3, null);
103 if (preg_match(',^[\'"](.*)[\'"]$,', $v, $m)) {
108 } elseif ($k or $n or $fond1) {
114 if ($var == 'lang') {
116 ?
calculer_liste($val, $p->descr
, $boucles, $id_boucle)
117 : '$GLOBALS["spip_lang"]';
120 ?
index_pile($id_boucle, $var, $boucles)
121 : calculer_liste($val, $p->descr
, $boucles, $id_boucle);
123 $val = ($echap ?
"\'$var\' => ' . argumenter_squelette(" : "'$var' => ")
124 . $val . ($echap ?
") . '" : " ");
126 $val = $echap ?
"'.$val.'" : $val;
136 // Cas particulier de la langue : si {lang=xx} est definie, on
137 // la passe, sinon on passe la langue courante au moment du calcul
138 // sauf si on n'en veut pas
139 if ($lang === false) {
143 $lang = '$GLOBALS["spip_lang"]';
145 $l['lang'] = ($echap ?
"\'lang\' => ' . argumenter_squelette(" : "'lang' => ") . $lang . ($echap ?
") . '" : " ");
151 * Code d'appel à un <INCLURE()>
153 * Code PHP pour un squelette (aussi pour #INCLURE, #MODELE #LES_AUTEURS)
155 define('CODE_RECUPERER_FOND', 'recuperer_fond(%s, %s, array(%s), %s)');
158 * Compile une inclusion <INCLURE> ou #INCLURE
161 * Description de l'inclusion (AST au niveau de l'inclure)
162 * @param array $boucles
164 * @param string $id_boucle
165 * Identifiant de la boucle contenant l'inclure
167 * Code PHP appelant l'inclusion
169 function calculer_inclure($p, &$boucles, $id_boucle) {
171 $_contexte = argumenter_inclure($p->param
, false, $p, $boucles, $id_boucle, true, '', true);
172 if (is_string($p->texte
)) {
173 $fichier = $p->texte
;
174 $code = "\"".str_replace('"','\"',$fichier)."\"";
177 $code = calculer_liste($p->texte
, $p->descr
, $boucles, $id_boucle);
178 if ($code and preg_match("/^'([^']*)'/s", $code, $r)) {
184 if (!$code or $code === '""') {
185 $erreur_p_i_i = array(
186 'zbug_parametres_inclus_incorrects',
187 array('param' => $code)
189 erreur_squelette($erreur_p_i_i, $p);
193 $compil = texte_script(memoriser_contexte_compil($p));
195 if (is_array($_contexte)) {
196 // Critere d'inclusion {env} (et {self} pour compatibilite ascendante)
197 if ($env = (isset($_contexte['env']) ||
isset($_contexte['self']))) {
198 unset($_contexte['env']);
201 // noter les doublons dans l'appel a public.php
202 if (isset($_contexte['doublons'])) {
203 $_contexte['doublons'] = "\\'doublons\\' => '.var_export(\$doublons,true).'";
206 if ($ajax = isset($_contexte['ajax'])) {
207 $ajax = preg_replace(",=>(.*)$,ims", '=> ($v=(\\1))?$v:true', $_contexte['ajax']);
208 unset($_contexte['ajax']);
211 $_contexte = join(",\n\t", $_contexte);
214 } // j'aurais voulu toucher le fond ...
216 $contexte = 'array(' . $_contexte . ')';
219 $contexte = "array_merge('.var_export(\$Pile[0],1).',$contexte)";
222 // s'il y a une extension .php, ce n'est pas un squelette
223 if ($fichier and preg_match('/^.+[.]php$/s', $fichier)) {
224 $code = sandbox_composer_inclure_php($fichier, $p, $contexte);
226 $_options[] = "\"compil\"=>array($compil)";
230 $code = " ' . argumenter_squelette($code) . '";
231 $code = "echo " . sprintf(CODE_RECUPERER_FOND
, $code, $contexte, implode(',', $_options),
232 "_request(\"connect\")") . ';';
235 return "\n'<'.'" . "?php " . $code . "\n?'." . "'>'";
240 * Gérer les statuts declarés pour cette table
242 * S'il existe des statuts sur cette table, déclarés dans la description
243 * d'un objet éditorial, applique leurs contraintes
245 * @param Boucle $boucle
246 * Descrition de la boucle
247 * @param bool $echapper
248 * true pour échapper le code créé
249 * @param bool $ignore_previsu
250 * true pour ne tester que le cas publie et ignorer l'eventuel var_mode=preview de la page
252 function instituer_boucle(&$boucle, $echapper = true, $ignore_previsu = false) {
254 $show['statut'][] = array(
255 'champ'=>'statut', // champ de la table sur lequel porte le filtrage par le statut
256 'publie'=>'publie', // valeur ou liste de valeurs, qui definissent l'objet comme publie.
257 'previsu'=>'publie,prop', // valeur ou liste de valeurs qui sont visibles en previsu
258 'post_date'=>'date', // un champ de date pour la prise en compte des post_dates, ou rien sinon
259 'exception'=>'statut', // liste des modificateurs qui annulent le filtrage par statut
260 // si plusieurs valeurs : array('statut','tout','lien')
263 Pour 'publier' ou 'previsu', si la chaine commence par un "!" on exclu au lieu de filtrer sur les valeurs donnees
264 si la chaine est vide, on ne garde rien si elle est seulement "!" on n'exclu rien
266 Si le statut repose sur une jointure, 'champ' est alors un tableau du format suivant :
274 champstatut est alors le champ statut sur la tablen
275 dans les jointures, clen peut etre un tableau pour une jointure complexe : array('id_objet','id_article','objet','article')
277 $id_table = $boucle->id_table
;
278 $show = $boucle->show
;
279 if (isset($show['statut']) and $show['statut']) {
280 foreach ($show['statut'] as $k => $s) {
281 // Restreindre aux elements publies si pas de {statut} ou autre dans les criteres
283 if (isset($s['exception'])) {
284 foreach (is_array($s['exception']) ?
$s['exception'] : array($s['exception']) as $m) {
285 if (isset($boucle->modificateur
[$m]) or isset($boucle->modificateur
['criteres'][$m])) {
293 if (is_array($s['champ'])) {
294 $statut = preg_replace(',\W,', '', array_pop($s['champ'])); // securite
295 $jointures = array();
296 // indiquer la description de chaque table dans le tableau de jointures,
297 // ce qui permet d'eviter certains GROUP BY inutiles.
298 $trouver_table = charger_fonction('trouver_table', 'base');
299 foreach ($s['champ'] as $j) {
301 $def = $trouver_table($id);
302 $jointures[] = array('', array($id, $def), end($j));
304 $jointures[0][0] = $id_table;
305 if (!array_search($id, $boucle->from
)) {
306 include_spip('public/jointures');
307 fabrique_jointures($boucle, $jointures, true, $boucle->show
, $id_table, '', $echapper);
309 // trouver l'alias de la table d'arrivee qui porte le statut
310 $id = array_search($id, $boucle->from
);
313 $statut = preg_replace(',\W,', '', $s['champ']); // securite
315 $mstatut = $id . '.' . $statut;
317 $arg_ignore_previsu = ($ignore_previsu ?
",true" : '');
318 include_spip('public/quete');
319 if (isset($s['post_date']) and $s['post_date']
320 and $GLOBALS['meta']["post_dates"] == 'non'
322 $date = $id . '.' . preg_replace(',\W,', '', $s['post_date']); // securite
323 array_unshift($boucle->where
,
325 "\nquete_condition_postdates('$date'," . _q($boucle->sql_serveur
) . "$arg_ignore_previsu)"
327 quete_condition_postdates($date, $boucle->sql_serveur
, $ignore_previsu)
330 array_unshift($boucle->where
,
332 "\nquete_condition_statut('$mstatut',"
333 . _q($s['previsu']) . ","
334 . _q($s['publie']) . ","
335 . _q($boucle->sql_serveur
) . "$arg_ignore_previsu)"
337 quete_condition_statut($mstatut, $s['previsu'], $s['publie'], $boucle->sql_serveur
, $ignore_previsu)
345 * Produit le corps PHP d'une boucle Spip.
347 * Ce corps remplit une variable $t0 retournée en valeur.
348 * Ici on distingue boucles recursives et boucle à requête SQL
349 * et on insère le code d'envoi au debusqueur du resultat de la fonction.
351 * @param string $id_boucle
352 * Identifiant de la boucle
353 * @param array $boucles
356 * Code PHP compilé de la boucle
358 function calculer_boucle($id_boucle, &$boucles) {
360 $boucle = &$boucles[$id_boucle];
361 instituer_boucle($boucle);
362 $boucles[$id_boucle] = pipeline('post_boucle', $boucles[$id_boucle]);
364 // en mode debug memoriser les premiers passages dans la boucle,
365 // mais pas tous, sinon ca pete.
366 if (_request('var_mode_affiche') != 'resultat') {
369 $trace = $boucles[$id_boucle]->descr
['nom'] . $id_boucle;
370 $trace = "if (count(@\$GLOBALS['debug_objets']['resultat']['$trace'])<3)
371 \$GLOBALS['debug_objets']['resultat']['$trace'][] = \$t0;";
374 return ($boucles[$id_boucle]->type_requete
== TYPE_RECURSIF
)
375 ?
calculer_boucle_rec($id_boucle, $boucles, $trace)
376 : calculer_boucle_nonrec($id_boucle, $boucles, $trace);
381 * Compilation d'une boucle recursive.
384 * Il suffit (ET IL FAUT) sauvegarder les valeurs des arguments passes par
385 * reference, car par definition un tel passage ne les sauvegarde pas
387 * @param string $id_boucle
388 * Identifiant de la boucle
389 * @param array $boucles
391 * @param string $trace
392 * Code PHP (en mode debug uniquement) servant à conserver une
393 * trace des premières valeurs de la boucle afin de pouvoir
394 * les afficher dans le débugueur ultérieurement
396 * Code PHP compilé de la boucle récursive
398 function calculer_boucle_rec($id_boucle, &$boucles, $trace) {
399 $nom = $boucles[$id_boucle]->param
[0];
402 // Numrows[$nom] peut ne pas être encore defini
403 "\n\t\$save_numrows = (isset(\$Numrows['$nom']) ? \$Numrows['$nom'] : array());"
404 . "\n\t\$t0 = " . $boucles[$id_boucle]->return . ";"
405 . "\n\t\$Numrows['$nom'] = (\$save_numrows);"
407 . "\n\treturn \$t0;";
411 * Compilation d'une boucle non recursive.
413 * La constante donne le cadre systématique du code:
415 * - %s1: initialisation des arguments de calculer_select
416 * - %s2: appel de calculer_select en donnant un contexte pour les cas d'erreur
417 * - %s3: initialisation du sous-tableau Numrows[id_boucle]
418 * - %s4: sauvegarde de la langue et calcul des invariants de boucle sur elle
419 * - %s5: boucle while sql_fetch ou str_repeat si corps monotone
420 * - %s6: restauration de la langue
421 * - %s7: liberation de la ressource, en tenant compte du serveur SQL
422 * - %s8: code de trace eventuel avant le retour
424 define('CODE_CORPS_BOUCLE', '%s
425 if (defined("_BOUCLE_PROFILER")) $timer = time()+(float)microtime();
428 $iter = IterFactory::create(
439 if (defined("_BOUCLE_PROFILER")
440 AND 1000*($timer = (time()+(float)microtime())-$timer) > _BOUCLE_PROFILER)
441 spip_log(intval(1000*$timer)."ms %s","profiler"._LOG_AVERTISSEMENT);
446 * Compilation d'une boucle (non recursive).
448 * @param string $id_boucle
449 * Identifiant de la boucle
450 * @param array $boucles
452 * @param string $trace
453 * Code PHP (en mode debug uniquement) servant à conserver une
454 * trace des premières valeurs de la boucle afin de pouvoir
455 * les afficher dans le débugueur ultérieurement
457 * Code PHP compilé de la boucle récursive
459 function calculer_boucle_nonrec($id_boucle, &$boucles, $trace) {
461 $boucle = &$boucles[$id_boucle];
462 $return = $boucle->return;
463 $type_boucle = $boucle->type_requete
;
464 $primary = $boucle->primary
;
465 $constant = preg_match(CODE_MONOTONE
, str_replace("\\'", '', $return));
466 $flag_cpt = $boucle->mode_partie ||
$boucle->cptrows
;
469 // faudrait expanser le foreach a la compil, car y en a souvent qu'un
470 // et puis faire un [] plutot qu'un "','."
471 if ($boucle->doublons
) {
472 $corps .= "\n\t\t\tforeach(" . $boucle->doublons
. ' as $k) $doublons[$k] .= "," . ' .
473 index_pile($id_boucle, $primary, $boucles)
477 // La boucle doit-elle selectionner la langue ?
478 // - par defaut, les boucles suivantes le font
479 // (sauf si forcer_lang==true ou si le titre contient <multi>).
480 // - a moins d'une demande explicite via {!lang_select}
481 if (!$constant && $boucle->lang_select
!= 'non' &&
482 (($boucle->lang_select
== 'oui') ||
483 in_array($type_boucle, array(
490 // Memoriser la langue avant la boucle et la restituer apres
491 // afin que le corps de boucle affecte la globale directement
492 $init_lang = "lang_select(\$GLOBALS['spip_lang']);\n\t";
493 $fin_lang = "lang_select();\n\t";
494 $fin_lang_select_public = "\n\t\tlang_select();";
497 "\n\t\tlang_select_public("
498 . index_pile($id_boucle, 'lang', $boucles)
499 . ", '" . $boucle->lang_select
. "'"
500 . (in_array($type_boucle, array(
505 )) ?
', ' . index_pile($id_boucle, 'titre', $boucles) : '')
510 $fin_lang_select_public = '';
511 // sortir les appels au traducteur (invariants de boucle)
512 if (strpos($return, '?php') === false
513 and preg_match_all("/\W(_T[(]'[^']*'[)])/", $return, $r)
516 foreach ($r[1] as $t) {
517 $init_lang .= "\n\t\$l$i = $t;";
518 $return = str_replace($t, "\$l$i", $return);
524 // gestion optimale des separateurs et des boucles constantes
525 if (count($boucle->separateur
)) {
526 $code_sep = ("'" . str_replace("'", "\'", join('', $boucle->separateur
)) . "'");
530 ((!$boucle->separateur
) ?
531 (($constant && !$corps && !$flag_cpt) ?
$return :
532 (($return === "''") ?
'' :
533 ("\n\t\t" . '$t0 .= ' . $return . ";"))) :
535 ((strpos($return, '$t1.') === 0) ?
536 (".=" . substr($return, 4)) :
539 '$t0 .= ((strlen($t1) && strlen($t0)) ? ' . $code_sep . " : '') . \$t1;"));
541 // Calculer les invalideurs si c'est une boucle non constante et si on
542 // souhaite invalider ces elements
543 if (!$constant and $primary) {
544 include_spip('inc/invalideur');
545 if (function_exists($i = 'calcul_invalideurs')) {
546 $corps = $i($corps, $primary, $boucles, $id_boucle);
550 // gerer le compteur de boucle
551 // avec ou sans son utilisation par les criteres {1/3} {1,4} {n-2,1}...
553 if ($boucle->partie
or $boucle->cptrows
) {
554 $corps = "\n\t\t\$Numrows['$id_boucle']['compteur_boucle']++;"
559 // depiler la lang de la boucle si besoin
560 $corps .= $fin_lang_select_public;
562 // si le corps est une constante, ne pas appeler le serveur N fois!
564 if (preg_match(CODE_MONOTONE
, str_replace("\\'", '', $corps), $r)) {
565 if (!isset($r[2]) or (!$r[2])) {
566 if (!$boucle->numrows
) {
567 return "\n\t\$t0 = '';";
572 $boucle->numrows
= true;
573 $corps = "\n\t\$t0 = str_repeat($corps, \$Numrows['$id_boucle']['total']);";
576 $corps = "while (\$Pile[\$SP]=\$iter->fetch()) {\n$corps\n }";
580 if (!$boucle->select
) {
581 if (!$boucle->numrows
or $boucle->limit
or $boucle->mode_partie
or $boucle->group
) {
586 $boucles[$id_boucle]->select
[] = $count;
590 $nums = "\n\t// COMPTEUR\n\t"
591 . "\$Numrows['$id_boucle']['compteur_boucle'] = 0;\n\t";
596 if ($boucle->numrows
or $boucle->mode_partie
) {
597 $nums .= "\$Numrows['$id_boucle']['total'] = @intval(\$iter->count());"
598 . $boucle->mode_partie
602 // Ne calculer la requete que maintenant
603 // car ce qui precede appelle index_pile qui influe dessus
605 $init = (($init = $boucles[$id_boucle]->doublons
)
606 ?
("\n\t$init = array();") : '')
607 . calculer_requete_sql($boucles[$id_boucle]);
609 $contexte = memoriser_contexte_compil($boucle);
611 $a = sprintf(CODE_CORPS_BOUCLE
,
621 'BOUCLE' . $id_boucle . ' @ ' . ($boucle->descr
['sourcefile'])
630 * Calcule le code PHP d'une boucle contenant les informations qui produiront une requête SQL
632 * Le code produit est un tableau associatif $command contenant les informations
633 * pour que la boucle produise ensuite sa requête, tel que `$command['from'] = 'spip_articles';`
635 * @param Boucle $boucle
638 * Code PHP compilé définissant les informations de requête
640 function calculer_requete_sql($boucle) {
642 $init[] = calculer_dec('table', "'" . $boucle->id_table
. "'");
643 $init[] = calculer_dec('id', "'" . $boucle->id_boucle
. "'");
644 # En absence de champ c'est un decompte :
645 $init[] = calculer_dec('from', calculer_from($boucle));
646 $init[] = calculer_dec('type', calculer_from_type($boucle));
647 $init[] = calculer_dec('groupby',
648 'array(' . (($g = join("\",\n\t\t\"", $boucle->group
)) ?
'"' . $g . '"' : '') . ")");
649 $init[] = calculer_dec('select', 'array("' . join("\",\n\t\t\"", $boucle->select
) . "\")");
650 $init[] = calculer_dec('orderby', 'array(' . calculer_order($boucle) . ")");
651 $init[] = calculer_dec('where', calculer_dump_array($boucle->where
));
652 $init[] = calculer_dec('join', calculer_dump_join($boucle->join
));
653 $init[] = calculer_dec('limit',
654 (strpos($boucle->limit
, 'intval') === false ?
655 "'" . $boucle->limit
. "'"
658 $init[] = calculer_dec('having', calculer_dump_array($boucle->having
));
660 // l'index 0 de $i indique si l'affectation est statique (contenu)
661 // ou recalculée à chaque passage (vide)
662 foreach ($init as $i) {
664 $s .= "\n\t\t" . end($i);
667 $d .= "\n\t" . end($i);
671 return ($boucle->hierarchie ?
"\n\t$boucle->hierarchie" : '')
674 . "\n\t" . 'if (!isset($command[\'table\'])) {'
681 * Retourne une chaîne des informations du contexte de compilation
683 * Retourne la source, le nom, l'identifiant de boucle, la ligne, la langue
684 * de l'élément dans une chaîne.
686 * @see reconstruire_contexte_compil()
689 * Objet de l'AST dont on mémorise le contexte
691 * Informations du contexte séparés par des virgules,
692 * qui peut être utilisé pour la production d'un tableau array()
694 function memoriser_contexte_compil($p) {
695 return join(',', array(
696 _q(isset($p->descr
['sourcefile']) ?
$p->descr
['sourcefile'] : ''),
697 _q(isset($p->descr
['nom']) ?
$p->descr
['nom'] : ''),
698 _q(isset($p->id_boucle
) ?
$p->id_boucle
: null),
700 '$GLOBALS[\'spip_lang\']'
705 * Reconstruit un contexte de compilation
707 * Pour un tableau d'information de contexte donné,
708 * retourne un objet Contexte (objet générique de l'AST)
709 * avec ces informations
711 * @see memoriser_contexte_compil()
713 * @param array $context_compil
714 * Tableau des informations du contexte
718 function reconstruire_contexte_compil($context_compil) {
719 if (!is_array($context_compil)) {
720 return $context_compil;
724 'sourcefile' => $context_compil[0],
725 'nom' => $context_compil[1]
727 $p->id_boucle
= $context_compil[2];
728 $p->ligne
= $context_compil[3];
729 $p->lang
= $context_compil[4];
735 * Calcule le code d'affectation d'une valeur à une commande de boucle
737 * Décrit le code qui complète le tableau $command qui servira entre autres
738 * à l'itérateur. Pour un nom de commande donnée et un code PHP décrivant
739 * ou récupérant une valeur, on retourne le code PHP qui fait l'affectation.
741 * L'index 0 du tableau retourné indique, lorsqu'il n'est pas vide, que l'affectation
742 * de la variable pourra être statique (c'est à dire qu'il ne dépend
743 * pas d'une quelconque variable PHP), et donc attribué une fois pour toutes
744 * quelque soit le nombre d'appels de la boucle.
749 * Code PHP décrivant la valeur à affecter
752 * - index 0 : Code pour une affectation statique. Si non rempli, la propriété devra
753 * être ré-affectée à chaque appel de la boucle.
754 * - index 1 : Code de l'affectation
756 function calculer_dec($nom, $val) {
757 $static = 'if (!isset($command[\'' . $nom . '\'])) ';
758 // si une variable apparait dans le calcul de la clause
759 // il faut la re-evaluer a chaque passage
761 strpos($val, '$') !== false
763 OR strpos($val, 'sql_') !== false
765 $test = str_replace(array("array(",'\"',"\'"),array("","",""),$val) // supprimer les array( et les echappements de guillemets
766 AND strpos($test,"(")!==FALSE // si pas de parenthese ouvrante, pas de fonction, on peut sortir
767 AND $test = preg_replace(",'[^']*',UimsS","",$test) // supprimer les chaines qui peuvent contenir des fonctions SQL qui ne genent pas
768 AND preg_match(",\w+\s*\(,UimsS",$test,$regs) // tester la presence de fonctions restantes
774 return array($static, '$command[\'' . $nom . '\'] = ' . $val . ';');
778 * Calcule l'expression PHP décrivant un tableau complexe (ou une chaîne)
780 * Lorsqu'un tableau est transmis, reconstruit de quoi créer le tableau
781 * en code PHP (une sorte de var_export) en appelant pour chaque valeur
782 * cette fonction de manière récursive.
784 * Si le premier index (0) du tableau est "'?'", retourne un code
785 * de test entre les 3 autres valeurs (v1 ? v2 : v3). Les valeurs
786 * pouvant être des tableaux aussi.
789 * Les données dont on veut construire un équivalent de var_export
791 * Expression PHP décrivant un texte ou un tableau
793 function calculer_dump_array($a) {
798 if ($a and $a[0] == "'?'") {
799 return ("(" . calculer_dump_array($a[1]) .
800 " ? " . calculer_dump_array($a[2]) .
801 " : " . calculer_dump_array($a[3]) .
805 $res .= ", " . calculer_dump_array($v);
808 return "\n\t\t\tarray(" . substr($res, 2) . ')';
812 // http://code.spip.net/@calculer_dump_join
813 function calculer_dump_join($a) {
815 foreach ($a as $k => $v) {
816 $res .= ", '$k' => array(" . implode(',', $v) . ")";
819 return 'array(' . substr($res, 2) . ')';
823 * Calcule l'expression PHP décrivant les informations FROM d'une boucle
825 * @param Boucle $boucle
826 * Description de la boucle
828 * Code PHP construisant un tableau des alias et noms des tables du FROM
830 function calculer_from(&$boucle) {
832 foreach ($boucle->from
as $k => $v) {
833 $res .= ",'$k' => '$v'";
836 return 'array(' . substr($res, 1) . ')';
840 * Calcule l'expression PHP décrivant des informations de type de jointure
841 * pour un alias de table connu dans le FROM
843 * @param Boucle $boucle
844 * Description de la boucle
846 * Code PHP construisant un tableau des alias et type de jointure du FROM
848 function calculer_from_type(&$boucle) {
850 foreach ($boucle->from_type
as $k => $v) {
851 $res .= ",'$k' => '$v'";
854 return 'array(' . substr($res, 1) . ')';
857 // http://code.spip.net/@calculer_order
858 function calculer_order(&$boucle) {
859 if (!$order = $boucle->order
860 and !$order = $boucle->default_order
865 /*if (isset($boucle->modificateur['collate'])){
866 $col = "." . $boucle->modificateur['collate'];
867 foreach($order as $k=>$o)
868 if (strpos($order[$k],'COLLATE')===false)
872 return join(', ', $order);
875 // Production du code PHP a partir de la sequence livree par le phraseur
876 // $boucles est passe par reference pour affectation par index_pile.
877 // Retourne une expression PHP,
878 // (qui sera argument d'un Return ou la partie droite d'une affectation).
880 // http://code.spip.net/@calculer_liste
881 function calculer_liste($tableau, $descr, &$boucles, $id_boucle = '') {
885 if (!isset($descr['niv'])) {
888 $codes = compile_cas($tableau, $descr, $boucles, $id_boucle);
889 if ($codes === false) {
896 $tab = str_repeat("\t", $descr['niv']);
897 if (_request('var_mode_affiche') != 'validation') {
902 foreach ($codes as $code) {
903 if (!preg_match("/^'[^']*'$/", $code)
904 or substr($res, -1, 1) !== "'"
906 $res .= " .\n$tab$code";
908 $res = substr($res, 0, -1) . substr($code, 1);
912 return '(' . substr($res, 2 +
$descr['niv']) . ')';
915 $nom = $descr['nom'] . $id_boucle . ($descr['niv'] ?
$descr['niv'] : '');
917 return "join('', array_map('array_shift', \$GLOBALS['debug_objets']['sequence']['$nom'] = array(" . join(" ,\n$tab",
922 define('_REGEXP_COND_VIDE_NONVIDE', "/^[(](.*)[?]\s*''\s*:\s*('[^']+')\s*[)]$/");
923 define('_REGEXP_COND_NONVIDE_VIDE', "/^[(](.*)[?]\s*('[^']+')\s*:\s*''\s*[)]$/");
924 define('_REGEXP_CONCAT_NON_VIDE', "/^(.*)[.]\s*'[^']+'\s*$/");
926 // http://code.spip.net/@compile_cas
927 function compile_cas($tableau, $descr, &$boucles, $id_boucle) {
930 // cas de la boucle recursive
931 if (is_array($id_boucle)) {
932 $id_boucle = $id_boucle[0];
934 $type = !$id_boucle ?
'' : $boucles[$id_boucle]->type_requete
;
935 $tab = str_repeat("\t", ++
$descr['niv']);
936 $mode = _request('var_mode_affiche');
938 // chaque commentaire introduit dans le code doit commencer
939 // par un caractere distinguant le cas, pour exploitation par debug.
940 foreach ($tableau as $p) {
945 $code = sandbox_composer_texte($p->texte
, $p);
946 $commentaire = strlen($p->texte
) . " signes";
954 foreach ($p->traductions
as $k => $v) {
956 str_replace(array("\\", "'"), array("\\\\", "\\'"), $k) .
958 str_replace(array("\\", "'"), array("\\\\", "\\'"), $v) .
961 $code = "choisir_traduction(array(" .
973 $code = calculer_inclure($p, $boucles, $id_boucle);
974 if ($code === false) {
978 $commentaire = '<INCLURE ' . addslashes(str_replace("\n", ' ', $code)) . '>';
987 $nom = $p->id_boucle
;
989 $newdescr['id_mere'] = $nom;
991 $avant = calculer_liste($p->avant
,
992 $newdescr, $boucles, $id_boucle);
993 $apres = calculer_liste($p->apres
,
994 $newdescr, $boucles, $id_boucle);
996 $altern = calculer_liste($p->altern
,
997 $newdescr, $boucles, $id_boucle);
998 if (($avant === false) or ($apres === false) or ($altern === false)) {
1003 str_replace("-", "_", $nom) . $descr['nom'] .
1004 '($Cache, $Pile, $doublons, $Numrows, $SP)';
1005 $commentaire = "?$nom";
1006 if (!$boucles[$nom]->milieu
1007 and $boucles[$nom]->type_requete
<> TYPE_RECURSIF
1009 if ($altern != "''") {
1010 $code .= "\n. $altern";
1012 if ($avant <> "''" or $apres <> "''") {
1013 spip_log("boucle $nom toujours vide, code superflu dans $descr[sourcefile]");
1015 $avant = $apres = $altern = "''";
1017 if ($altern != "''") {
1018 $altern = "($altern)";
1027 foreach ($p->arg
as $k => $v) {
1028 $_v = calculer_liste($v, $descr, $boucles, $id_boucle);
1030 $l[] = _q($k) . ' => ' . $_v;
1035 // Si le module n'est pas fourni, l'expliciter sauf si calculé
1037 $m = $p->module
. ':' . $p->nom_champ
;
1038 } elseif ($p->nom_champ
) {
1039 $m = MODULES_IDIOMES
. ':' . $p->nom_champ
;
1044 $code = (!$code ?
"'$m'" :
1045 ($m ?
"'$m' . $code" :
1046 ("(strpos(\$x=$code, ':') ? \$x : ('" . MODULES_IDIOMES
. ":' . \$x))")))
1047 . (!$l ?
'' : (", array(" . implode(",\n", $l) . ")"));
1048 $code = "_T($code)";
1050 $p->id_boucle
= $id_boucle;
1051 $p->boucles
= &$boucles;
1052 $code = compose_filtres($p, $code);
1062 // cette structure pourrait etre completee des le phrase' (a faire)
1063 $p->id_boucle
= $id_boucle;
1064 $p->boucles
= &$boucles;
1066 #$p->interdire_scripts = true;
1067 $p->type_requete
= $type;
1069 $code = calculer_champ($p);
1070 $commentaire = '#' . $p->nom_champ
. $p->etoile
;
1071 $avant = calculer_liste($p->avant
,
1072 $descr, $boucles, $id_boucle);
1073 $apres = calculer_liste($p->apres
,
1074 $descr, $boucles, $id_boucle);
1076 // Si la valeur est destinee a une comparaison a ''
1077 // forcer la conversion en une chaine par strval
1078 // si ca peut etre autre chose qu'une chaine
1079 if (($avant != "''" or $apres != "''")
1081 # AND (strpos($code,'interdire_scripts') !== 0)
1082 and !preg_match(_REGEXP_COND_VIDE_NONVIDE
, $code)
1083 and !preg_match(_REGEXP_COND_NONVIDE_VIDE
, $code)
1084 and !preg_match(_REGEXP_CONCAT_NON_VIDE
, $code)
1086 $code = "strval($code)";
1091 // Erreur de construction de l'arbre de syntaxe abstraite
1094 $err_e_c = _T('zbug_erreur_compilation');
1095 erreur_squelette($err_e_c, $p);
1098 if ($code != "''") {
1099 $code = compile_retour($code, $avant, $apres, $altern, $tab, $descr['niv']);
1100 $codes[] = (($mode == 'validation') ?
1101 "array($code, '$commentaire', " . $p->ligne
. ")"
1102 : (($mode == 'code') ?
1103 "\n// $commentaire\n$code" :
1108 return $err_e_c ?
false : $codes;
1111 // production d'une expression conditionnelle ((v=EXP) ? (p . v .s) : a)
1112 // mais si EXP est de la forme (t ? 'C' : '') on produit (t ? (p . C . s) : a)
1113 // de meme si EXP est de la forme (t ? '' : 'C')
1115 // http://code.spip.net/@compile_retour
1116 function compile_retour($code, $avant, $apres, $altern, $tab, $n) {
1117 if ($avant == "''") {
1120 if ($apres == "''") {
1123 if (!$avant and !$apres and ($altern === "''")) {
1127 if (preg_match(_REGEXP_CONCAT_NON_VIDE
, $code)) {
1130 } elseif (preg_match(_REGEXP_COND_VIDE_NONVIDE
, $code, $r)) {
1132 $cond = '!' . $r[1];
1134 if (preg_match(_REGEXP_COND_NONVIDE_VIDE
, $code, $r)) {
1139 $cond = "($t = $code)!==''";
1143 $res = (!$avant ?
"" : "$avant . ") .
1145 (!$apres ?
"" : " . $apres");
1151 return !$cond ?
$res : "($cond ?\n\t$tab$res :\n\t$tab$altern)";
1155 function compile_inclure_doublons($lexemes) {
1156 foreach ($lexemes as $v) {
1157 if ($v->type
=== 'include' and $v->param
) {
1158 foreach ($v->param
as $r) {
1159 if (trim($r[0]) === 'doublons') {
1169 // Prend en argument le texte d'un squelette, le nom de son fichier d'origine,
1170 // sa grammaire et un nom. Retourne False en cas d'erreur,
1171 // sinon retourne un tableau de fonctions PHP compilees a evaluer,
1172 // notamment une fonction portant ce nom et calculant une page.
1173 // Pour appeler la fonction produite, lui fournir 2 tableaux de 1 e'le'ment:
1174 // - 1er: element 'cache' => nom (du fichier ou` mettre la page)
1175 // - 2e: element 0 contenant un environnement ('id_article => $id_article, etc)
1176 // Elle retournera alors un tableau de 5 e'le'ments:
1177 // - 'texte' => page HTML, application du squelette a` l'environnement;
1178 // - 'squelette' => le nom du squelette
1179 // - 'process_ins' => 'html' ou 'php' selon la pre'sence de PHP dynamique
1180 // - 'invalideurs' => de'pendances de cette page, pour invalider son cache.
1181 // - 'entetes' => tableau des entetes http
1182 // En cas d'erreur, elle retournera un tableau des 2 premiers elements seulement
1184 // http://code.spip.net/@public_compiler_dist
1185 function public_compiler_dist($squelette, $nom, $gram, $sourcefile, $connect = '') {
1186 // Pre-traitement : reperer le charset du squelette, et le convertir
1187 // Bonus : supprime le BOM
1188 include_spip('inc/charsets');
1189 $squelette = transcoder_page($squelette);
1191 // rendre inertes les echappements de #[](){}<>
1193 while (false !== strpos($squelette, $inerte = '-INERTE' . $i)) {
1196 $squelette = preg_replace_callback(',\\\\([#[()\]{}<>]),',
1197 function($a) use ($inerte) {
1198 return "$inerte-" . ord($a[1]) . '-';
1208 'sourcefile' => $sourcefile,
1209 'squelette' => $squelette
1212 // Phraser le squelette, selon sa grammaire
1215 $f = charger_fonction('phraser_' . $gram, 'public');
1217 $squelette = $f($squelette, '', $boucles, $descr);
1219 $boucles = compiler_squelette($squelette, $boucles, $nom, $descr, $sourcefile, $connect);
1221 // restituer les echappements
1223 foreach ($boucles as $i => $boucle) {
1224 $boucles[$i]->return = preg_replace_callback(
1231 $boucles[$i]->descr
['squelette'] = preg_replace_callback(
1234 return "\\\\" . chr($a[1]);
1236 $boucle->descr
['squelette']
1241 $debug = ($boucles and defined('_VAR_MODE') and _VAR_MODE
== 'debug');
1243 include_spip('public/decompiler');
1244 foreach ($boucles as $id => $boucle) {
1246 $decomp = "\n/* BOUCLE " .
1247 $boucle->type_requete
.
1249 str_replace('*/', '* /', public_decompiler($boucle, $gram, 0, 'criteres')) .
1252 $decomp = ("\n/*\n" .
1253 str_replace('*/', '* /', public_decompiler($squelette, $gram))
1256 $boucles[$id]->return = $decomp . $boucle->return;
1257 $GLOBALS['debug_objets']['code'][$nom . $id] = $boucle->return;
1264 // Point d'entree pour arbre de syntaxe abstraite fourni en premier argument
1265 // Autres specifications comme ci-dessus
1267 function compiler_squelette($squelette, $boucles, $nom, $descr, $sourcefile, $connect = '') {
1268 static $trouver_table;
1269 spip_timer('calcul_skel');
1271 if (defined('_VAR_MODE') and _VAR_MODE
== 'debug') {
1272 $GLOBALS['debug_objets']['squelette'][$nom] = $descr['squelette'];
1273 $GLOBALS['debug_objets']['sourcefile'][$nom] = $sourcefile;
1275 if (!isset($GLOBALS['debug_objets']['principal'])) {
1276 $GLOBALS['debug_objets']['principal'] = $nom;
1279 foreach ($boucles as $id => $boucle) {
1280 $GLOBALS['debug_objets']['boucle'][$nom . $id] = $boucle;
1282 $descr['documents'] = compile_inclure_doublons($squelette);
1284 // Demander la description des tables une fois pour toutes
1285 if (!$trouver_table) {
1286 $trouver_table = charger_fonction('trouver_table', 'base');
1289 // reperer si les doublons sont demandes
1290 // pour un inclure ou une boucle document
1291 // c'est utile a la fonction champs_traitements
1292 foreach ($boucles as $id => $boucle) {
1293 if (!($type = $boucle->type_requete
)) {
1296 if (!$descr['documents'] and (
1297 (($type == 'documents') and $boucle->doublons
) or
1298 compile_inclure_doublons($boucle->avant
) or
1299 compile_inclure_doublons($boucle->apres
) or
1300 compile_inclure_doublons($boucle->milieu
) or
1301 compile_inclure_doublons($boucle->altern
))
1303 $descr['documents'] = true;
1305 if ($type != TYPE_RECURSIF
) {
1306 if (!$boucles[$id]->sql_serveur
and $connect) {
1307 $boucles[$id]->sql_serveur
= $connect;
1310 // chercher dans les iterateurs du repertoire iterateur/
1311 if ($g = charger_fonction(
1312 preg_replace('/\W/', '_', $boucle->type_requete
), 'iterateur', true)
1314 $boucles[$id] = $g($boucle);
1316 // sinon, en cas de requeteur d'un type predefini,
1317 // utiliser les informations donnees par le requeteur
1318 // cas "php:xx" et "data:xx".
1320 if ($boucle->sql_serveur
and $requeteur = charger_fonction($boucle->sql_serveur
, 'requeteur', true)) {
1321 $requeteur($boucles, $boucle, $id);
1323 // utiliser la description des champs transmis
1325 $show = $trouver_table($type, $boucles[$id]->sql_serveur
);
1326 // si la table n'existe pas avec le connecteur par defaut,
1327 // c'est peut etre une table qui necessite son connecteur dedie fourni
1328 // permet une ecriture allegee (GEO) -> (geo:GEO)
1330 and $show = $trouver_table($type, strtolower($type))
1332 $boucles[$id]->sql_serveur
= strtolower($type);
1335 $boucles[$id]->show
= $show;
1336 // recopie les infos les plus importantes
1337 $boucles[$id]->primary
= isset($show['key']["PRIMARY KEY"]) ?
$show['key']["PRIMARY KEY"] : '';
1338 $boucles[$id]->id_table
= $x = preg_replace(",^spip_,", "", $show['id_table']);
1339 $boucles[$id]->from
[$x] = $nom_table = $show['table'];
1340 $boucles[$id]->iterateur
= 'SQL';
1342 $boucles[$id]->descr
= &$descr;
1343 if ((!$boucles[$id]->jointures
)
1344 and is_array($show['tables_jointures'])
1345 and count($x = $show['tables_jointures'])
1347 $boucles[$id]->jointures
= $x;
1349 if ($boucles[$id]->jointures_explicites
) {
1350 $jointures = preg_split("/\s+/", $boucles[$id]->jointures_explicites
);
1351 while ($j = array_pop($jointures)) {
1352 array_unshift($boucles[$id]->jointures
, $j);
1356 // Pas une erreur si la table est optionnelle
1357 if ($boucles[$id]->table_optionnelle
) {
1358 $boucles[$id]->type_requete
= '';
1360 $boucles[$id]->type_requete
= false;
1361 $boucle = $boucles[$id];
1362 $x = (!$boucle->sql_serveur ?
'' :
1363 ($boucle->sql_serveur
. ":")) .
1366 'zbug_table_inconnue',
1367 array('table' => $x)
1369 erreur_squelette($msg, $boucle);
1377 // Commencer par reperer les boucles appelees explicitement
1378 // car elles indexent les arguments de maniere derogatoire
1379 foreach ($boucles as $id => $boucle) {
1380 if ($boucle->type_requete
== TYPE_RECURSIF
and $boucle->param
) {
1381 $boucles[$id]->descr
= &$descr;
1382 $rec = &$boucles[$boucle->param
[0]];
1385 'zbug_boucle_recursive_undef',
1386 array('nom' => $boucle->param
[0])
1388 erreur_squelette($msg, $boucle);
1389 $boucles[$id]->type_requete
= false;
1391 $rec->externe
= $id;
1392 $descr['id_mere'] = $id;
1393 $boucles[$id]->return =
1394 calculer_liste(array($rec),
1401 foreach ($boucles as $id => $boucle) {
1402 $id = strval($id); // attention au type dans index_pile
1403 $type = $boucle->type_requete
;
1404 if ($type and $type != TYPE_RECURSIF
) {
1406 if ($boucle->param
) {
1407 // retourne un tableau en cas d'erreur
1408 $res = calculer_criteres($id, $boucles);
1410 $descr['id_mere'] = $id;
1411 $boucles[$id]->return =
1412 calculer_liste($boucle->milieu
,
1416 // Si les criteres se sont mal compiles
1417 // ne pas tenter d'assembler le code final
1418 // (mais compiler le corps pour detection d'erreurs)
1419 if (is_array($res)) {
1420 $boucles[$id]->type_requete
= false;
1425 // idem pour la racine
1426 $descr['id_mere'] = '';
1427 $corps = calculer_liste($squelette, $descr, $boucles);
1430 // Calcul du corps de toutes les fonctions PHP,
1431 // en particulier les requetes SQL et TOTAL_BOUCLE
1432 // de'terminables seulement maintenant
1434 foreach ($boucles as $id => $boucle) {
1435 $boucle = $boucles[$id] = pipeline('pre_boucle', $boucle);
1436 if ($boucle->return === false) {
1440 // appeler la fonction de definition de la boucle
1442 if ($req = $boucle->type_requete
) {
1443 // boucle personnalisée ?
1444 $table = strtoupper($boucle->type_requete
);
1445 $serveur = strtolower($boucle->sql_serveur
);
1447 // fonction de boucle avec serveur & table
1449 ((!function_exists($f = "boucle_" . $serveur . "_" . $table))
1450 and (!function_exists($f = $f . "_dist"))
1453 // fonction de boucle avec table
1454 and (!function_exists($f = "boucle_" . $table))
1455 and (!function_exists($f = $f . "_dist"))
1457 // fonction de boucle standard
1458 if (!function_exists($f = 'boucle_DEFAUT')) {
1459 $f = 'boucle_DEFAUT_dist';
1463 $req = "\n\n\tstatic \$command = array();\n\t" .
1464 "static \$connect;\n\t" .
1465 "\$command['connect'] = \$connect = " .
1466 _q($boucle->sql_serveur
) .
1470 $req = ("\n\treturn '';");
1473 $boucles[$id]->return =
1474 "\n\nfunction BOUCLE" . strtr($id, "-", "_") . $nom .
1475 '(&$Cache, &$Pile, &$doublons, &$Numrows, $SP) {' .
1480 // Au final, si le corps ou un critere au moins s'est mal compile
1481 // retourner False, sinon inserer leur decompilation
1482 if (is_bool($corps)) {
1486 $principal = "\nfunction " . $nom . '($Cache, $Pile, $doublons = array(), $Numrows = array(), $SP = 0) {
1488 // reporter de maniere securisee les doublons inclus
1490 if (isset($Pile[0]["doublons"]) AND is_array($Pile[0]["doublons"]))
1491 $doublons = nettoyer_env_doublons($Pile[0]["doublons"]);
1496 // ATTENTION, le calcul de l'expression $corps affectera $Cache
1497 // c'est pourquoi on l'affecte a la variable auxiliaire $page.
1498 // avant de referencer $Cache
1501 return analyse_resultat_skel(" . var_export($nom, true)
1502 . ", \$Cache, \$page, " . var_export($sourcefile, true) . ");
1505 $secondes = spip_timer('calcul_skel');
1506 spip_log("COMPIL ($secondes) [$sourcefile] $nom.php");
1507 // $connect n'est pas sûr : on nettoie
1508 $connect = preg_replace(',[^\w],', '', $connect);
1510 // Assimiler la fct principale a une boucle anonyme, pour retourner un resultat simple
1512 $code->descr
= $descr;
1515 // Fonction principale du squelette ' .
1517 ($connect ?
" pour $connect" : '') .
1518 (!CODE_COMMENTE ?
'' : "\n// Temps de compilation total: $secondes") .
1522 $boucles[''] = $code;
1529 * Requeteur pour les boucles (php:nom_iterateur)
1531 * Analyse si le nom d'iterateur correspond bien a une classe PHP existante
1532 * et dans ce cas charge la boucle avec cet iterateur.
1533 * Affichera une erreur dans le cas contraire.
1535 * @param $boucles Liste des boucles
1536 * @param $boucle La boucle parcourue
1537 * @param $id L'identifiant de la boucle parcourue
1540 function requeteur_php_dist(&$boucles, &$boucle, &$id) {
1541 if (class_exists($boucle->type_requete
)) {
1542 $g = charger_fonction('php', 'iterateur');
1543 $boucles[$id] = $g($boucle, $boucle->type_requete
);
1545 $x = $boucle->type_requete
;
1546 $boucle->type_requete
= false;
1548 'zbug_iterateur_inconnu',
1549 array('iterateur' => $x)
1551 erreur_squelette($msg, $boucle);
1557 * Requeteur pour les boucles (data:type de donnee)
1558 * note: (DATA) tout court ne passe pas par ici.
1560 * Analyse si le type de donnee peut etre traite
1561 * et dans ce cas charge la boucle avec cet iterateur.
1562 * Affichera une erreur dans le cas contraire.
1564 * @param $boucles Liste des boucles
1565 * @param $boucle La boucle parcourue
1566 * @param $id L'identifiant de la boucle parcourue
1569 function requeteur_data_dist(&$boucles, &$boucle, &$id) {
1570 include_spip('iterateur/data');
1571 if ($h = charger_fonction($boucle->type_requete
. '_to_array', 'inc', true)) {
1572 $g = charger_fonction('data', 'iterateur');
1573 $boucles[$id] = $g($boucle);
1574 // from[0] stocke le type de data (rss, yql, ...)
1575 $boucles[$id]->from
[] = $boucle->type_requete
;
1578 $x = $boucle->type_requete
;
1579 $boucle->type_requete
= false;
1581 'zbug_requeteur_inconnu',
1583 'requeteur' => 'data',
1587 erreur_squelette($msg, $boucle);