3 /***************************************************************************\
4 * SPIP, Systeme de publication pour l'internet *
6 * Copyright (c) 2001-2014 *
7 * Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
9 * Ce programme est un logiciel libre distribue sous licence GNU/GPL. *
10 * Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne. *
11 \***************************************************************************/
14 // Fichier principal du compilateur de squelettes
17 if (!defined('_ECRIRE_INC_VERSION')) return;
19 // reperer un code ne calculant rien, meme avec commentaire
20 define('CODE_MONOTONE', ",^(\n//[^\n]*\n)?\(?'([^'])*'\)?$,");
21 // s'il faut commenter le code produit
22 define('CODE_COMMENTE', true);
24 // definition des structures de donnees
25 include_spip('public/interfaces');
27 // Definition de la structure $p, et fonctions de recherche et de reservation
28 // dans l'arborescence des boucles
29 include_spip('public/references');
31 // definition des boucles
32 include_spip('public/boucles');
34 // definition des criteres
35 include_spip('public/criteres');
37 // definition des balises
38 include_spip('public/balises');
40 // Gestion des jointures
41 include_spip('public/jointures');
43 // Les 2 ecritures INCLURE{A1,A2,A3...} et INCLURE(A1){A2}{A3}... sont admises
44 // Preferer la premiere.
45 // Les Ai sont de la forme Vi=Ei ou bien Vi qui veut alors dire Vi=Vi
46 // Le resultat est un tableau indexe par les Vi
47 // Toutefois, si le premier argument n'est pas de la forme Vi=Ei
48 // il est conventionnellement la valeur de l'index 1.
49 // pour la balise #INCLURE
50 // mais pas pour <INCLURE> dont le fond est defini explicitement.
53 // http://doc.spip.org/@argumenter_inclure
54 function argumenter_inclure($params, $rejet_filtres, $p, &$boucles, $id_boucle, $echap = true, $lang = '', $fond1 = false){
57 if (!is_array($params)) return $l;
58 foreach ($params as $k => $couple){
59 // la liste d'arguments d'inclusion peut se terminer par un filtre
60 $filtre = array_shift($couple);
62 foreach ($couple as $n => $val){
64 if ($var->type
!='texte'){
65 if ($n OR $k OR $fond1){
66 $erreur_p_i_i = array('zbug_parametres_inclus_incorrects',
67 array('param' => $var->nom_champ
));
68 erreur_squelette($erreur_p_i_i, $p);
69 } else $l[1] = calculer_liste($val, $p->descr
, $boucles, $id_boucle);
72 preg_match(",^([^=]*)(=?)(.*)$,", $var->texte
, $m);
78 if (preg_match(',^[\'"](.*)[\'"]$,', $v, $m)) $v = $m[1];
81 } elseif ($k OR $n OR $fond1) {
87 ?
calculer_liste($val, $p->descr
, $boucles, $id_boucle)
88 : '$GLOBALS["spip_lang"]';
91 ?
index_pile($id_boucle, $var, $boucles)
92 : calculer_liste($val, $p->descr
, $boucles, $id_boucle);
94 $val = ($echap ?
"\'$var\' => ' . argumenter_squelette(" : "'$var' => ")
95 . $val . ($echap ?
") . '" : " ");
96 else $val = $echap ?
"'.$val.'" : $val;
102 if ($erreur_p_i_i) return false;
103 // Cas particulier de la langue : si {lang=xx} est definie, on
104 // la passe, sinon on passe la langue courante au moment du calcul
105 // sauf si on n'en veut pas
106 if ($lang===false) return $l;
107 if (!$lang) $lang = '$GLOBALS["spip_lang"]';
108 $l['lang'] = ($echap ?
"\'lang\' => ' . argumenter_squelette(" : "'lang' => ") . $lang . ($echap ?
") . '" : " ");
114 // Calculer un <INCLURE()>
115 // La constante ci-dessous donne le code general quand il s'agit d'un script.
117 define('CODE_INCLURE_SCRIPT', 'if (($path = %s) AND is_readable($path))
119 else erreur_squelette(array("fichier_introuvable", array("fichier" => "%s")), array(%s));'
122 // // et celle-ci pour un squelette (aussi pour #INCLURE, #MODELE #LES_AUTEURS)
124 define('CODE_RECUPERER_FOND', 'recuperer_fond(%s, %s, array(%s), %s)');
126 // http://doc.spip.org/@calculer_inclure
127 function calculer_inclure($p, &$boucles, $id_boucle){
129 $_contexte = argumenter_inclure($p->param
, false, $p, $boucles, $id_boucle, true, '', true);
130 if (is_string($p->texte
)){
131 $fichier = $p->texte
;
132 $code = "\"$fichier\"";
135 $code = calculer_liste($p->texte
, $p->descr
, $boucles, $id_boucle);
136 if ($code AND preg_match("/^'([^']*)'/s", $code, $r))
140 if (!$code OR $code==='""'){
141 $erreur_p_i_i = array('zbug_parametres_inclus_incorrects',
142 array('param' => $code));
143 erreur_squelette($erreur_p_i_i, $p);
146 $compil = texte_script(memoriser_contexte_compil($p));
148 if (is_array($_contexte)){
149 // Critere d'inclusion {env} (et {self} pour compatibilite ascendante)
150 if ($env = (isset($_contexte['env']) ||
isset($_contexte['self']))){
151 unset($_contexte['env']);
154 // noter les doublons dans l'appel a public.php
155 if (isset($_contexte['doublons'])){
156 $_contexte['doublons'] = "\\'doublons\\' => '.var_export(\$doublons,true).'";
159 if ($ajax = isset($_contexte['ajax']))
160 unset($_contexte['ajax']);
162 $_contexte = join(",\n\t", $_contexte);
165 return false; // j'aurais voulu toucher le fond ...
167 $contexte = 'array(' . $_contexte . ')';
170 $contexte = "array_merge('.var_export(\$Pile[0],1).',$contexte)";
173 // s'il y a une extension .php, ce n'est pas un squelette
174 if (preg_match('/^.+[.]php$/s', $fichier)){
175 // si inexistant, on essaiera a l'execution
176 if ($path = find_in_path($fichier))
178 else $path = "find_in_path(\"$fichier\")";
180 $code = sprintf(CODE_INCLURE_SCRIPT
, $path, $fichier, $compil);
182 $_options[] = "\"compil\"=>array($compil)";
184 $_options[] = "\"ajax\"=>true";
185 $code = " ' . argumenter_squelette($code) . '";
186 $code = "echo " . sprintf(CODE_RECUPERER_FOND
, $code, $contexte, implode(',', $_options), "_request(\"connect\")") . ';';
189 return "\n'<'.'" . "?php " . $code . "\n?'." . "'>'";
193 // calculer_boucle() produit le corps PHP d'une boucle Spip.
194 // ce corps remplit une variable $t0 retournee en valeur.
195 // Ici on distingue boucles recursives et boucle a requete SQL
196 // et on insere le code d'envoi au debusqueur du resultat de la fonction.
198 // http://doc.spip.org/@calculer_boucle
199 function calculer_boucle($id_boucle, &$boucles){
201 $boucles[$id_boucle] = pipeline('post_boucle', $boucles[$id_boucle]);
203 // en mode debug memoriser les premiers passages dans la boucle,
204 // mais pas tous, sinon ca pete.
205 if (_request('var_mode_affiche')!='resultat')
208 $trace = $boucles[$id_boucle]->descr
['nom'] . $id_boucle;
209 $trace = "if (count(@\$GLOBALS['debug_objets']['resultat']['$trace'])<3)
210 \$GLOBALS['debug_objets']['resultat']['$trace'][] = \$t0;";
212 return ($boucles[$id_boucle]->type_requete
=='boucle')
213 ?
calculer_boucle_rec($id_boucle, $boucles, $trace)
214 : calculer_boucle_nonrec($id_boucle, $boucles, $trace);
217 // compil d'une boucle recursive.
218 // il suffit (ET IL FAUT) sauvegarder les valeurs des arguments passes par
219 // reference, car par definition un tel passage ne les sauvegarde pas
221 // http://doc.spip.org/@calculer_boucle_rec
222 function calculer_boucle_rec($id_boucle, &$boucles, $trace){
223 $nom = $boucles[$id_boucle]->param
[0];
224 return "\n\t\$save_numrows = (\$Numrows['$nom']);"
225 . "\n\t\$t0 = " . $boucles[$id_boucle]->return . ";"
226 . "\n\t\$Numrows['$nom'] = (\$save_numrows);"
228 . "\n\treturn \$t0;";
231 // Compilation d'une boucle non recursive.
232 // Ci-dessous la constante donnant le cadre systematique du code:
233 // %s1: initialisation des arguments de calculer_select
234 // %s2: appel de calculer_select en donnant un contexte pour les cas d'erreur
235 // %s3: initialisation du sous-tableau Numrows[id_boucle]
236 // %s4: sauvegarde de la langue et calcul des invariants de boucle sur elle
237 // %s5: boucle while sql_fetch ou str_repeat si corps monotone
238 // %s6: restauration de la langue
239 // %s7: liberation de la ressource, en tenant compte du serveur SQL
240 // %s8: code de trace eventuel avant le retour
242 define('CODE_CORPS_BOUCLE', '%s
245 $result = calculer_select($select, $from, $type, $where, $join, $groupby, $orderby, $limit, $having, $table, $id, $connect,
251 %s@sql_free($result%s);
256 // http://doc.spip.org/@calculer_boucle_nonrec
257 function calculer_boucle_nonrec($id_boucle, &$boucles, $trace){
259 $boucle = &$boucles[$id_boucle];
260 $return = $boucle->return;
261 $type_boucle = $boucle->type_requete
;
262 $primary = $boucle->primary
;
263 $constant = preg_match(CODE_MONOTONE
, str_replace("\\'", '', $return));
264 $flag_cpt = $boucle->mode_partie ||
$boucle->cptrows
;
267 // faudrait expanser le foreach a la compil, car y en a souvent qu'un
268 // et puis faire un [] plutot qu'un "','."
269 if ($boucle->doublons
)
270 $corps .= "\n\t\t\tforeach(" . $boucle->doublons
. ' as $k) $doublons[$k] .= "," . ' .
271 index_pile($id_boucle, $primary, $boucles)
274 // La boucle doit-elle selectionner la langue ?
275 // -. par defaut, les boucles suivantes le font
276 // (sauf si forcer_lang==true ou si le titre contient <multi>).
277 // - . a moins d'une demande explicite via {!lang_select}
278 if (!$constant && $boucle->lang_select
!='non' &&
279 (($boucle->lang_select
=='oui') ||
280 in_array($type_boucle, array(
281 'articles', 'rubriques', 'hierarchie', 'breves'
284 // Memoriser la langue avant la boucle et la restituer apres
285 // afin que le corps de boucle affecte la globale directement
286 $init_lang = "lang_select(\$GLOBALS['spip_lang']);\n\t";
287 $fin_lang = "lang_select();\n\t";
290 "\n\t\tlang_select_public("
291 . index_pile($id_boucle, 'lang', $boucles)
292 . ", '" . $boucle->lang_select
. "'"
293 . (in_array($type_boucle, array(
294 'articles', 'rubriques', 'hierarchie', 'breves'
295 )) ?
', ' . index_pile($id_boucle, 'titre', $boucles) : '')
301 // sortir les appels au traducteur (invariants de boucle)
302 if (strpos($return, '?php')===false
303 AND preg_match_all("/\W(_T[(]'[^']*'[)])/", $return, $r)
306 foreach ($r[1] as $t){
307 $init_lang .= "\n\t\$l$i = $t;";
308 $return = str_replace($t, "\$l$i", $return);
314 // gestion optimale des separateurs et des boucles constantes
315 if (count($boucle->separateur
))
316 $code_sep = ("'" . str_replace("'", "\'", join('', $boucle->separateur
)) . "'");
319 ((!$boucle->separateur
) ?
320 (($constant && !$corps && !$flag_cpt) ?
$return :
321 (($return==="''") ?
'' :
322 ("\n\t\t" . '$t0 .= ' . $return . ";"))) :
324 ((strpos($return, '$t1.')===0) ?
325 (".=" . substr($return, 4)) :
328 '$t0 .= (($t1 && $t0) ? ' . $code_sep . " : '') . \$t1;"));
330 // Calculer les invalideurs si c'est une boucle non constante et si on
331 // souhaite invalider ces elements
332 if (!$constant AND $primary){
333 include_spip('inc/invalideur');
334 if (function_exists($i = 'calcul_invalideurs'))
335 $corps = $i($corps, $primary, $boucles, $id_boucle);
338 // gerer le compteur de boucle
339 // avec ou sans son utilisation par les criteres {1/3} {1,4} {n-2,1}...
341 if ($boucle->partie
OR $boucle->cptrows
)
342 $corps = "\n\t\t\$Numrows['$id_boucle']['compteur_boucle']++;"
346 $serveur = !$boucle->sql_serveur ?
''
347 : (', ' . _q($boucle->sql_serveur
));
349 // si le corps est une constante, ne pas appeler le serveur N fois!
351 if (preg_match(CODE_MONOTONE
, str_replace("\\'", '', $corps), $r)){
352 if (!isset($r[2]) OR (!$r[2])){
353 if (!$boucle->numrows
)
354 return "\n\t\$t0 = '';";
358 $boucle->numrows
= true;
359 $corps = "\n\t\$t0 = str_repeat($corps, \$Numrows['$id_boucle']['total']);";
361 } else $corps = "while (\$Pile[\$SP] = @sql_fetch(\$result$serveur)) {\n$corps\n }";
364 if (!$boucle->select
){
365 if (!$boucle->numrows
OR $boucle->limit
OR $boucle_mode_partie OR $boucle->group
)
367 else $count = 'count(*)';
368 $boucles[$id_boucle]->select
[] = $count;
372 $nums = "\n\t// COMPTEUR\n\t"
373 . "\$Numrows['$id_boucle']['compteur_boucle'] = 0;\n\t";
376 if ($boucle->numrows
OR $boucle->mode_partie
){
377 if ($count=='count(*)')
378 $count = "(\$cc=sql_fetch(\$result$serveur))?array_shift(\$cc):0";
380 $count = "sql_count(\$result$serveur)";
381 $nums .= "\$Numrows['$id_boucle']['total'] = @intval($count);"
382 . $boucle->mode_partie
386 // Ne calculer la requete que maintenant
387 // car ce qui precede appelle index_pile qui influe dessus
389 $init = (($init = $boucles[$id_boucle]->doublons
)
390 ?
("\n\t$init = array();") : '')
391 . calculer_requete_sql($boucles[$id_boucle]);
393 $contexte = memoriser_contexte_compil($boucle);
395 return sprintf(CODE_CORPS_BOUCLE
, $init, $contexte, $nums, $init_lang, $corps, $fin_lang, $serveur, $trace);
399 // http://doc.spip.org/@calculer_requete_sql
400 function calculer_requete_sql($boucle){
401 return ($boucle->hierarchie ?
"\n\t$boucle->hierarchie" : '')
404 . calculer_dec('$table', "'" . $boucle->id_table
. "'")
405 . calculer_dec('$id', "'" . $boucle->id_boucle
. "'")
406 # En absence de champ c'est un decompte :
407 . calculer_dec('$from', calculer_from($boucle))
408 . calculer_dec('$type', calculer_from_type($boucle))
409 . calculer_dec('$groupby', 'array(' . (($g = join("\",\n\t\t\"", $boucle->group
)) ?
'"' . $g . '"' : '') . ")")
410 . calculer_dec('$select', 'array("' . join("\",\n\t\t\"", $boucle->select
) . "\")")
411 . calculer_dec('$orderby', 'array(' . calculer_order($boucle) . ")")
412 . calculer_dec('$where', calculer_dump_array($boucle->where
))
413 . calculer_dec('$join', calculer_dump_join($boucle->join
))
414 . calculer_dec('$limit', (strpos($boucle->limit
, 'intval')===false ?
415 "'" . $boucle->limit
. "'" :
417 . calculer_dec('$having', calculer_dump_array($boucle->having
));
420 function memoriser_contexte_compil($p){
421 return join(',', array(
422 _q($p->descr
['sourcefile']),
423 _q($p->descr
['nom']),
426 '$GLOBALS[\'spip_lang\']'));
429 function reconstruire_contexte_compil($context_compil){
430 if (!is_array($context_compil)) return $context_compil;
431 include_spip('public/interfaces');
433 $p->descr
= array('sourcefile' => $context_compil[0],
434 'nom' => $context_compil[1]);
435 $p->id_boucle
= $context_compil[2];
436 $p->ligne
= $context_compil[3];
437 $p->lang
= $context_compil[4];
441 // http://doc.spip.org/@calculer_dec
442 function calculer_dec($nom, $val){
445 strpos($val, '$')!==false
446 OR strpos($val, 'sql_')!==false
448 $test = str_replace(array("array(", '\"', "\'"), array("", "", ""), $val) // supprimer les array( et les echappements de guillemets
449 AND strpos($test, "(")!==FALSE // si pas de parenthese ouvrante, pas de fonction, on peut sortir
450 AND $test = preg_replace(",'[^']*',UimsS", "", $test) // supprimer les chaines qui peuvent contenir des fonctions SQL qui ne genent pas
451 AND preg_match(",\w+\s*\(,UimsS", $test, $regs) // tester la presence de fonctions restantes
456 return "\n\t" . $static . $nom . ' = ' . $val . ';';
459 // http://doc.spip.org/@calculer_dump_array
460 function calculer_dump_array($a){
461 if (!is_array($a)) return $a;
463 if ($a AND $a[0]=="'?'")
464 return ("(" . calculer_dump_array($a[1]) .
465 " ? " . calculer_dump_array($a[2]) .
466 " : " . calculer_dump_array($a[3]) .
469 foreach ($a as $v) $res .= ", " . calculer_dump_array($v);
470 return "\n\t\t\tarray(" . substr($res, 2) . ')';
474 // http://doc.spip.org/@calculer_dump_join
475 function calculer_dump_join($a){
477 foreach ($a as $k => $v)
478 $res .= ", '$k' => array(" . implode(',', $v) . ")";
479 return 'array(' . substr($res, 2) . ')';
482 // http://doc.spip.org/@calculer_from
483 function calculer_from(&$boucle){
485 foreach ($boucle->from
as $k => $v) $res .= ",'$k' => '$v'";
486 return 'array(' . substr($res, 1) . ')';
489 // http://doc.spip.org/@calculer_from_type
490 function calculer_from_type(&$boucle){
492 foreach ($boucle->from_type
as $k => $v) $res .= ",'$k' => '$v'";
493 return 'array(' . substr($res, 1) . ')';
496 // http://doc.spip.org/@calculer_order
497 function calculer_order(&$boucle){
498 if (!$order = $boucle->order
499 AND !$order = $boucle->default_order
503 /*if (isset($boucle->modificateur['collate'])){
504 $col = "." . $boucle->modificateur['collate'];
505 foreach($order as $k=>$o)
506 if (strpos($order[$k],'COLLATE')===false)
509 return join(', ', $order);
512 // Production du code PHP a partir de la sequence livree par le phraseur
513 // $boucles est passe par reference pour affectation par index_pile.
514 // Retourne une expression PHP,
515 // (qui sera argument d'un Return ou la partie droite d'une affectation).
517 // http://doc.spip.org/@calculer_liste
518 function calculer_liste($tableau, $descr, &$boucles, $id_boucle = ''){
519 if (!$tableau) return "''";
520 if (!isset($descr['niv'])) $descr['niv'] = 0;
521 $codes = compile_cas($tableau, $descr, $boucles, $id_boucle);
522 if ($codes===false) return false;
524 if (!$n) return "''";
525 $tab = str_repeat("\t", $descr['niv']);
526 if (_request('var_mode_affiche')!='validation'){
531 foreach ($codes as $code){
532 if (!preg_match("/^'[^']*'$/", $code)
533 OR substr($res, -1, 1)!=="'"
535 $res .= " .\n$tab$code";
537 $res = substr($res, 0, -1) . substr($code, 1);
540 return '(' . substr($res, 2+
$descr['niv']) . ')';
543 $nom = $descr['nom'] . $id_boucle . ($descr['niv'] ?
$descr['niv'] : '');
544 return "join('', array_map('array_shift', \$GLOBALS['debug_objets']['sequence']['$nom'] = array(" . join(" ,\n$tab", $codes) . ")))";
548 define('_REGEXP_COND_VIDE_NONVIDE', "/^[(](.*)[?]\s*''\s*:\s*('[^']+')\s*[)]$/");
549 define('_REGEXP_COND_NONVIDE_VIDE', "/^[(](.*)[?]\s*('[^']+')\s*:\s*''\s*[)]$/");
550 define('_REGEXP_CONCAT_NON_VIDE', "/^(.*)[.]\s*'[^']+'\s*$/");
552 // http://doc.spip.org/@compile_cas
553 function compile_cas($tableau, $descr, &$boucles, $id_boucle){
556 // cas de la boucle recursive
557 if (is_array($id_boucle))
558 $id_boucle = $id_boucle[0];
559 $type = !$id_boucle ?
'' : $boucles[$id_boucle]->type_requete
;
560 $tab = str_repeat("\t", ++
$descr['niv']);
561 $mode = _request('var_mode_affiche');
563 // chaque commentaire introduit dans le code doit commencer
564 // par un caractere distinguant le cas, pour exploitation par debug.
565 foreach ($tableau as $p){
570 $code = "'" . str_replace(array("\\", "'"), array("\\\\", "\\'"), $p->texte
) . "'";
572 $commentaire = strlen($p->texte
) . " signes";
580 foreach ($p->traductions
as $k => $v){
582 str_replace(array("\\", "'"), array("\\\\", "\\'"), $k) .
584 str_replace(array("\\", "'"), array("\\\\", "\\'"), $v) .
587 $code = "choisir_traduction(array(" .
599 $code = calculer_inclure($p, $boucles, $id_boucle);
604 $commentaire = '<INCLURE ' . addslashes(str_replace("\n", ' ', $code)) . '>';
613 $nom = $p->id_boucle
;
615 $newdescr['id_mere'] = $nom;
617 $avant = calculer_liste($p->avant
,
618 $newdescr, $boucles, $id_boucle);
619 $apres = calculer_liste($p->apres
,
620 $newdescr, $boucles, $id_boucle);
622 $altern = calculer_liste($p->altern
,
623 $newdescr, $boucles, $id_boucle);
624 if (($avant===false) OR ($apres===false) OR ($altern===false)){
629 str_replace("-", "_", $nom) . $descr['nom'] .
630 '($Cache, $Pile, $doublons, $Numrows, $SP)';
631 $commentaire = "?$nom";
632 if (!$boucles[$nom]->milieu
633 AND $boucles[$nom]->type_requete
<>'boucle'
635 if ($altern!="''") $code .= "\n. $altern";
636 if ($avant<>"''" OR $apres<>"''")
637 spip_log("boucle $nom toujours vide, code superflu dans $id");
638 $avant = $apres = $altern = "''";
639 } else if ($altern!="''") $altern = "($altern)";
646 foreach ($p->arg
as $k => $v){
647 $_v = calculer_liste($v, $descr, $boucles, $id_boucle);
649 $l[] = _q($k) . ' => ' . $_v;
652 /// Si le module n'est pas fourni,
653 /// l'expliciter sauf si calcule
655 $m = $p->module
.':'.$p->nom_champ
;
656 } elseif ($p->nom_champ
) {
657 $m = MODULES_IDIOMES
.':'.$p->nom_champ
;
660 $code = (!$code ?
"'$m'" :
661 ($m ?
"'$m' . $code" :
662 ("(strpos(\$x=$code, ':') ? \$x : ('" . MODULES_IDIOMES
. ":' . \$x))")))
663 . (!$l ?
'' : (", array(" . implode(",\n", $l) . ")"));
666 $p->id_boucle
= $id_boucle;
667 $p->boucles
= &$boucles;
668 $code = compose_filtres($p, $code);
678 // cette structure pourrait etre completee des le phrase' (a faire)
679 $p->id_boucle
= $id_boucle;
680 $p->boucles
= &$boucles;
682 #$p->interdire_scripts = true;
683 $p->type_requete
= $type;
685 $code = calculer_champ($p);
686 $commentaire = '#' . $p->nom_champ
. $p->etoile
;
687 $avant = calculer_liste($p->avant
,
688 $descr, $boucles, $id_boucle);
689 $apres = calculer_liste($p->apres
,
690 $descr, $boucles, $id_boucle);
692 // Si la valeur est destinee a une comparaison a ''
693 // forcer la conversion en une chaine par strval
694 // si ca peut etre autre chose qu'une chaine
695 if (($avant!="''" OR $apres!="''")
697 # AND (strpos($code,'interdire_scripts') !== 0)
698 AND !preg_match(_REGEXP_COND_VIDE_NONVIDE
, $code)
699 AND !preg_match(_REGEXP_COND_NONVIDE_VIDE
, $code)
700 AND !preg_match(_REGEXP_CONCAT_NON_VIDE
, $code)
702 $code = "strval($code)";
706 // Erreur de construction de l'arbre de syntaxe abstraite
709 $err_e_c = array('zbug_erreur_compilation');
710 erreur_squelette($err_e_c, $p);
714 $code = compile_retour($code, $avant, $apres, $altern, $tab, $descr['niv']);
715 $codes[] = (($mode=='validation') ?
716 "array($code, '$commentaire', " . $p->ligne
. ")"
718 "\n// $commentaire\n$code" :
723 return $err_e_c ?
false : $codes;
726 // production d'une expression conditionnelle ((v=EXP) ? (p . v .s) : a)
727 // mais si EXP est de la forme (t ? 'C' : '') on produit (t ? (p . C . s) : a)
728 // de meme si EXP est de la forme (t ? '' : 'C')
730 // http://doc.spip.org/@compile_retour
731 function compile_retour($code, $avant, $apres, $altern, $tab, $n){
732 if ($avant=="''") $avant = '';
733 if ($apres=="''") $apres = '';
734 if (!$avant AND !$apres AND ($altern==="''")) return $code;
736 if (preg_match(_REGEXP_CONCAT_NON_VIDE
, $code)){
739 } elseif (preg_match(_REGEXP_COND_VIDE_NONVIDE
, $code, $r)) {
742 } else if (preg_match(_REGEXP_COND_NONVIDE_VIDE
, $code, $r)){
747 $cond = "($t = $code)!==''";
750 $res = (!$avant ?
"" : "$avant . ") .
752 (!$apres ?
"" : " . $apres");
754 if ($res!==$t) $res = "($res)";
755 return !$cond ?
$res : "($cond ?\n\t$tab$res :\n\t$tab$altern)";
759 function compile_inclure_doublons($lexemes){
760 foreach ($lexemes as $v)
761 if ($v->type
==='include' AND $v->param
)
762 foreach ($v->param
as $r)
763 if (trim($r[0])==='doublons')
768 // Prend en argument le texte d'un squelette, le nom de son fichier d'origine,
769 // sa grammaire et un nom. Retourne False en cas d'erreur,
770 // sinon retourne un tableau de fonctions PHP compilees a evaluer,
771 // notamment une fonction portant ce nom et calculant une page.
772 // Pour appeler la fonction produite, lui fournir 2 tableaux de 1 e'le'ment:
773 // - 1er: element 'cache' => nom (du fichier ou` mettre la page)
774 // - 2e: element 0 contenant un environnement ('id_article => $id_article, etc)
775 // Elle retournera alors un tableau de 5 e'le'ments:
776 // - 'texte' => page HTML, application du squelette a` l'environnement;
777 // - 'squelette' => le nom du squelette
778 // - 'process_ins' => 'html' ou 'php' selon la pre'sence de PHP dynamique
779 // - 'invalideurs' => de'pendances de cette page, pour invalider son cache.
780 // - 'entetes' => tableau des entetes http
781 // En cas d'erreur, elle retournera un tableau des 2 premiers elements seulement
783 // http://doc.spip.org/@public_compiler_dist
784 function public_compiler_dist($squelette, $nom, $gram, $sourcefile, $connect = ''){
785 // Pre-traitement : reperer le charset du squelette, et le convertir
786 // Bonus : supprime le BOM
787 include_spip('inc/charsets');
788 $squelette = transcoder_page($squelette);
790 $descr = array('nom' => $nom,
792 'sourcefile' => $sourcefile,
793 'squelette' => $squelette);
795 // Phraser le squelette, selon sa grammaire
798 $f = charger_fonction('phraser_' . $gram, 'public');
800 $squelette = $f($squelette, '', $boucles, $descr);
802 return compiler_squelette($squelette, $boucles, $nom, $descr, $sourcefile, $connect);
805 // Point d'entree pour arbre de syntaxe abstraite fourni en premier argument
806 // Autres specifications comme ci-dessus
808 function compiler_squelette($squelette, $boucles, $nom, $descr, $sourcefile, $connect = ''){
809 global $tables_jointures;
810 static $trouver_table;
811 spip_timer('calcul_skel');
813 if (isset($GLOBALS['var_mode']) AND $GLOBALS['var_mode']=='debug'){
814 $GLOBALS['debug_objets']['squelette'][$nom] = $descr['squelette'];
815 $GLOBALS['debug_objets']['sourcefile'][$nom] = $sourcefile;
817 if (!isset($GLOBALS['debug_objets']['principal']))
818 $GLOBALS['debug_objets']['principal'] = $nom;
820 foreach ($boucles as $id => $boucle){
821 $GLOBALS['debug_objets']['boucle'][$nom . $id] = $boucle;
823 $descr['documents'] = compile_inclure_doublons($squelette);
825 // Demander la description des tables une fois pour toutes
826 // et reperer si les doublons sont demandes
827 // pour un inclure ou une boucle document
828 // c'est utile a la fonction champs_traitements
830 $trouver_table = charger_fonction('trouver_table', 'base');
832 foreach ($boucles as $id => $boucle){
833 if (!($type = $boucle->type_requete
)) continue;
834 if (!$descr['documents'] AND (
835 (($type=='documents') AND $boucle->doublons
) OR
836 compile_inclure_doublons($boucle->avant
) OR
837 compile_inclure_doublons($boucle->apres
) OR
838 compile_inclure_doublons($boucle->milieu
) OR
839 compile_inclure_doublons($boucle->altern
))
841 $descr['documents'] = true;
842 if ($type!='boucle'){
843 if (!$boucles[$id]->sql_serveur
AND $connect)
844 $boucles[$id]->sql_serveur
= $connect;
845 $show = $trouver_table($type, $boucles[$id]->sql_serveur
);
846 // si la table n'existe pas avec le connecteur par defaut,
847 // c'est peut etre une table qui necessite son connecteur dedie fourni
848 // permet une ecriture allegee (GEO) -> (geo:GEO)
849 if (!$show AND $show = $trouver_table($type, strtolower($type)))
850 $boucles[$id]->sql_serveur
= strtolower($type);
852 $boucles[$id]->show
= $show;
853 // recopie les infos les plus importantes
854 $boucles[$id]->primary
= $show['key']["PRIMARY KEY"];
855 $boucles[$id]->id_table
= $x = $show['id_table'];
856 $boucles[$id]->from
[$x] = $nom_table = $show['table'];
858 $boucles[$id]->descr
= &$descr;
859 if ((!$boucles[$id]->jointures
)
860 AND (isset($tables_jointures[$nom_table]))
861 AND is_array($x = $tables_jointures[$nom_table])
863 $boucles[$id]->jointures
= $x;
864 if ($boucles[$id]->jointures_explicites
){
865 $jointures = preg_split("/\s+/", $boucles[$id]->jointures_explicites
);
866 while ($j = array_pop($jointures))
867 array_unshift($boucles[$id]->jointures
, $j);
870 // Pas une erreur si la table est optionnelle
871 if ($boucles[$id]->table_optionnelle
)
872 $boucles[$id]->type_requete
= '';
874 $boucles[$id]->type_requete
= false;
875 $boucle = $boucles[$id];
876 $x = (!$boucle->sql_serveur ?
'' :
877 ($boucle->sql_serveur
. ":")) .
879 $msg = array('zbug_table_inconnue',
880 array('table' => $x));
881 erreur_squelette($msg, $boucle);
887 // Commencer par reperer les boucles appelees explicitement
888 // car elles indexent les arguments de maniere derogatoire
889 foreach ($boucles as $id => $boucle){
890 if ($boucle->type_requete
=='boucle' AND $boucle->param
){
891 $boucles[$id]->descr
= &$descr;
892 $rec = &$boucles[$boucle->param
[0]];
894 $msg = array('zbug_boucle_recursive_undef',
895 array('nom' => $boucle->param
[0]));
896 erreur_squelette($msg, $boucle);
897 $boucles[$id]->type_requete
= false;
900 $descr['id_mere'] = $id;
901 $boucles[$id]->return =
902 calculer_liste(array($rec),
909 foreach ($boucles as $id => $boucle){
910 $id = strval($id); // attention au type dans index_pile
911 $type = $boucle->type_requete
;
912 if ($type AND $type!='boucle'){
913 $crit = !$boucle->param ?
true : calculer_criteres($id, $boucles);
914 $descr['id_mere'] = $id;
915 $boucles[$id]->return =
916 calculer_liste($boucle->milieu
,
920 // Si les criteres se sont mal compiles
921 // ne pas tenter d'assembler le code final
922 // (mais compiler le corps pour detection d'erreurs)
924 $boucles[$id]->type_requete
= false;
928 // idem pour la racine
929 $descr['id_mere'] = '';
930 $corps = calculer_liste($squelette, $descr, $boucles);
931 $debug = (isset($GLOBALS['var_mode']) AND $GLOBALS['var_mode']=='debug');
934 include_spip('public/decompiler');
935 include_spip('public/format_' . _EXTENSION_SQUELETTES
);
937 // Calcul du corps de toutes les fonctions PHP,
938 // en particulier les requetes SQL et TOTAL_BOUCLE
939 // de'terminables seulement maintenant
941 foreach ($boucles as $id => $boucle){
942 $boucle = $boucles[$id] = pipeline('pre_boucle', $boucle);
943 if ($boucle->return===false) continue;
944 // appeler la fonction de definition de la boucle
946 if ($req = $boucle->type_requete
){
947 $f = 'boucle_' . strtoupper($req);
948 // si pas de definition perso, definition spip
949 if (!function_exists($f)) $f = $f . '_dist';
950 // laquelle a une definition par defaut
951 if (!function_exists($f)) $f = 'boucle_DEFAUT';
952 if (!function_exists($f)) $f = 'boucle_DEFAUT_dist';
953 $req = "\n\n\tstatic \$connect = " .
954 _q($boucle->sql_serveur
) .
957 } else $req = ("\n\treturn '';");
959 $boucles[$id]->return =
960 "function BOUCLE" . strtr($id, "-", "_") . $nom .
961 '(&$Cache, &$Pile, &$doublons, &$Numrows, $SP) {' .
966 $GLOBALS['debug_objets']['code'][$nom . $id] = $boucles[$id]->return;
969 // Au final, si le corps ou un critere au moins s'est mal compile
970 // retourner False, sinon inserer leur decompilation
971 if (is_bool($corps)) return false;
972 foreach ($boucles as $id => $boucle){
973 if ($boucle->return===false) return false;
974 $boucle->return = "\n\n/* BOUCLE " .
975 $boucle->type_requete
.
978 str_replace('*/', '* /',
979 decompiler_criteres($boucle->param
,
980 $boucle->criteres
))) .
985 $secondes = spip_timer('calcul_skel');
986 spip_log("COMPIL ($secondes) [$sourcefile] $nom.php");
987 // $connect n'est pas sûr : on nettoie
988 $connect = preg_replace(',[^\w],', '', $connect);
990 // Assimiler la fct principale a une boucle anonyme, c'est plus simple
992 $code->descr
= $descr;
995 // Fonction principale du squelette ' .
997 ($connect ?
" pour $connect" : '') .
998 (!CODE_COMMENTE ?
'' : "\n// Temps de compilation total: $secondes") .
1000 (!$debug ?
'' : ("\n/*\n" .
1001 str_replace('*/', '* /', public_decompiler($squelette))
1004 function " . $nom . '($Cache, $Pile, $doublons=array(), $Numrows=array(), $SP=0) {
1007 // reporter de maniere securisee les doublons inclus
1009 if (isset($Pile[0]["doublons"]) AND is_array($Pile[0]["doublons"]))
1010 $doublons = nettoyer_env_doublons($Pile[0]["doublons"]);
1015 // ATTENTION, le calcul de l'expression $corps affectera $Cache
1016 // c'est pourquoi on l'affecte a la variable auxiliaire $page.
1017 // avant de referencer $Cache
1020 return analyse_resultat_skel(" . var_export($nom, true)
1021 . ", \$Cache, \$page, " . var_export($sourcefile, true) . ");
1024 $boucles[''] = $code;