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 \***************************************************************************/
13 if (!defined('_ECRIRE_INC_VERSION')) return;
15 // Decompilation de l'arbre de syntaxe abstraite d'un squelette SPIP
17 function decompiler_boucle($struct, $fmt='', $prof=0)
19 $nom = $struct->id_boucle
;
20 $avant = decompiler_($struct->avant
, $fmt, $prof);
21 $apres = decompiler_($struct->apres
, $fmt, $prof);
22 $altern = decompiler_($struct->altern
, $fmt, $prof);
23 $milieu = decompiler_($struct->milieu
, $fmt, $prof);
25 $type = $struct->sql_serveur ?
"$struct->sql_serveur:" : '';
26 $type .= ($struct->type_requete ?
$struct->type_requete
:
27 $struct->table_optionnelle
);
29 if ($struct->jointures_explicites
)
30 $type .= " " . $struct->jointures_explicites
;
31 if ($struct->table_optionnelle
)
33 // Revoir le cas de la boucle recursive
35 $crit = $struct->param
;
36 if ($crit AND !is_array($crit[0])) {
37 $type = strtolower($type) . array_shift($crit);
39 $crit = decompiler_criteres($struct, $fmt, $prof) ;
41 $f = 'format_boucle_' . $fmt;
42 return $f($avant, $nom, $type, $crit, $milieu, $apres, $altern, $prof);
45 function decompiler_include($struct, $fmt='', $prof=0)
48 foreach($struct->param ?
$struct->param
: array() as $couple) {
50 foreach($couple as $v) {
51 $res[]= decompiler_($v, $fmt, $prof);
54 $file = is_string($struct->texte
) ?
$struct->texte
:
55 decompiler_($struct->texte
, $fmt, $prof);
56 $f = 'format_inclure_' . $fmt;
57 return $f($file, $res, $prof);
60 function decompiler_texte($struct, $fmt='', $prof=0)
62 $f = 'format_texte_' . $fmt;
63 return strlen($struct->texte
) ?
$f($struct->texte
, $prof) : '';
66 function decompiler_polyglotte($struct, $fmt='', $prof=0)
68 $f = 'format_polyglotte_' . $fmt;
69 return $f($struct->traductions
, $prof);
72 function decompiler_idiome($struct, $fmt='', $prof=0)
75 foreach ($struct->arg
as $k => $v) {
76 $args[$k]= public_decompiler($v, $fmt, $prof);
79 $filtres = decompiler_liste($struct->param
, $fmt, $prof);
81 $f = 'format_idiome_' . $fmt;
82 return $f($struct->nom_champ
, $struct->module
, $args, $filtres, $prof);
85 function decompiler_champ($struct, $fmt='', $prof=0)
87 $avant = decompiler_($struct->avant
, $fmt, $prof);
88 $apres = decompiler_($struct->apres
, $fmt, $prof);
89 $args = $filtres = '';
90 if ($p = $struct->param
) {
92 $args = decompiler_liste(array(array_shift($p)), $fmt, $prof);
93 $filtres = decompiler_liste($p, $fmt, $prof);
95 $f = 'format_champ_' . $fmt;
96 return $f($struct->nom_champ
, $struct->nom_boucle
, $struct->etoile
, $avant, $apres, $args, $filtres, $prof);
99 function decompiler_liste($sources, $fmt='', $prof=0) {
100 if (!is_array($sources)) return '';
101 $f = 'format_liste_' . $fmt;
103 foreach($sources as $arg) {
104 if (!is_array($arg)) {
105 continue; // ne devrait pas arriver.
106 } else {$r = array_shift($arg);}
108 foreach($arg as $v) {
109 // cas des arguments entoures de ' ou "
111 AND $v[0]->type
=='texte'
112 AND (strlen($v[0]->apres
) == 1)
113 AND $v[0]->apres
== $v[0]->avant
)
114 $args[]= $v[0]->avant
. $v[0]->texte
. $v[0]->apres
;
115 else $args[]= decompiler_($v, $fmt, 0-$prof);
117 if (($r!=='') OR $args) $res .= $f($r, $args, $prof);
122 // Decompilation des criteres: on triche et on deroge:
123 // - le phraseur fournit un bout du source en plus de la compil
124 // - le champ apres signale le critere {"separateur"} ou {'separateur'}
125 // - les champs sont implicitement etendus (crochets implicites mais interdits)
126 function decompiler_criteres($boucle, $fmt='', $prof=0) {
127 $sources = $boucle->param
;
128 if (!is_array($sources)) return '';
130 $f = 'format_critere_' . $fmt;
131 foreach($sources as $crit) {
132 if (!is_array($crit)) continue; // boucle recursive
135 foreach($crit as $i => $v) {
137 AND $v[0]->type
=='texte'
139 $args[]= array(array('texte', ( $v[0]->apres
. $v[0]->texte
. $v[0]->apres
)));
142 foreach($v as $k => $p) {
144 AND function_exists($d = 'decompiler_' . $p->type
)) {
145 $r = $d($p, $fmt, (0-$prof), @$v[$k+
1]);
146 $res2[]= array($p->type
, $r);
147 } else spip_log("critere $i / $k mal forme");
158 function decompiler_($liste, $fmt='', $prof=0)
160 if (!is_array($liste)) return '';
161 $prof2 = ($prof < 0) ?
($prof-1) : ($prof+
1);
163 foreach($liste as $k => $p) {
164 if (!isset($p->type
)) continue; #??????
165 $d = 'decompiler_' . $p->type
;
166 $next = isset($liste[$k+
1]) ?
$liste[$k+
1] : false;
167 // Forcer le champ etendu si son source (pas les reecritures)
168 // contenait des args et s'il est suivi d'espaces,
169 // le champ simple les eliminant est un bug helas perenne.
172 AND ($next->type
== 'texte')
173 AND $p->type
== 'champ'
177 $n = strlen($next->texte
) - strlen(ltrim($next->texte
));
180 $champ->texte
= substr($next->texte
, 0, $n);
181 $champ->ligne
= $p->ligne
;
182 $p->apres
= array($champ);
183 $next->texte
= substr($next->texte
, $n);
186 $contenu[] = array($d($p, $fmt, $prof2), $p->type
);
189 $f = 'format_suite_' . $fmt;
193 function public_decompiler($liste, $fmt='', $prof=0, $quoi='')
195 if (!include_spip('public/format_' . $fmt)) return "'$fmt'?";
196 $f = 'decompiler_' . $quoi;
197 return $f($liste, $fmt, $prof);