source: spip-zone/_plugins_/coloration_code/trunk/public/format_html_geshi.php @ 107599

Last change on this file since 107599 was 107599, checked in by p@…, 3 years ago

Les <INCLURE> de spip utilisent des {} pour le fond et non pas des ()

File size: 11.7 KB
Line 
1<?php
2
3/*****************************************************************************\
4 *  Decompilateur créant une syntaxe avec des <| class='' > pour GESHI 1.0.8 *
5\*****************************************************************************/
6
7if (!defined('_ECRIRE_INC_VERSION')) {
8        return;
9}
10
11
12/**
13 * Encadre un texte donne par un code <| style='x'|code|> ou <| class='x'|code|>
14 * que GESHI remplacera ensuite par des spans
15 *
16 * L'encadrement tient compte du fait que l'on veut des styles inline
17 * ou des classes CSS dans le code genere par GESHI
18 *
19 * On indique le type de style que l'on veut (KEYWORDS) et son numero (30)
20 * Il faut se referer a geshi/geshi/spip3.php pour avoir les correspondances.
21 *
22 * @param string $code
23 *              Le code a encadrer
24 * @param string $styles_geshi_name
25 *              Un des types de styles dans Geshi ( KEYWORDS uniquement utilise pour l'instant )
26 * @param int $styles_geshi_key
27 *              Le numero de style dans le groupe precedent.
28 * @return string
29 *              Le code encadre.
30**/
31function format_to_geshi_spip($code, $styles_geshi_name, $styles_geshi_key) {
32        static $use_style = null;
33        static $styles = array();
34        static $classes = array();
35
36        // utiliser des styles ou des classes
37        if (is_null($use_style)) {
38                // geshi/spip3.php doit forcement etre deja charge !
39                include_spip('geshi/geshi/spip3');
40                $styles = geshi_language_data_spip3_styles();
41                $use_style = (!defined('PLUGIN_COLORATION_CODE_STYLES_INLINE') OR PLUGIN_COLORATION_CODE_STYLES_INLINE);
42                $classes = array(
43                        'KEYWORDS' => 'kw'
44                );
45        }
46
47        $style  = $styles[ $styles_geshi_name ][ $styles_geshi_key ];
48        $classe = $classes[ $styles_geshi_name ] . $styles_geshi_key;
49        $in = $use_style ? "style=\"$style\"" : "class=\"$classe\"";
50        $code = "<| $in>$code|>";
51        return $code;
52}
53
54
55
56
57/**
58 * Demande d'encadrer un texte pour geshi selon un code de couleur demande.
59 *
60 *
61 * @param string $code
62 *              Le code a encadrer
63 * @param string $quoi
64 *              Un type de couleur plus lisible que les mots cles de GESHI
65 *              La correspondance est fait avec les tags GESHI dans cette fonction.
66 * @param bool $echapper
67 *              Echappe le texte au passage selon la methode de GESHI
68 *              Evidemment, il ne faut pas le faire 2 fois pour un meme texte !
69 * @return string
70 *              Le code encadre.
71**/
72function format_geshi_spip($code, $quoi, $echapper=true) {
73        // echapper le code en mode geshi
74        if ($echapper) {
75                $code = geshi_hsc($code);
76        }
77
78        // ajouter l'encadrement geshi
79        switch($quoi) {
80                case 'boucle':
81                        $code = format_to_geshi_spip($code, 'KEYWORDS', 10);
82                        break;
83                case 'boucle_table':
84                        $code = format_to_geshi_spip($code, 'KEYWORDS', 11);
85                        break;
86                case 'boucle_critere':
87                        $code = format_to_geshi_spip($code, 'KEYWORDS', 12);
88                        break;
89
90                case 'balise':
91                        $code = format_to_geshi_spip($code, 'KEYWORDS', 20);
92                        break;
93                case 'balise_boucle':
94                        $code = format_to_geshi_spip($code, 'KEYWORDS', 21);
95                        break;
96                case 'balise_etoile':
97                        $code = format_to_geshi_spip($code, 'KEYWORDS', 22);
98                        break;
99                       
100                case 'balise_crochet':
101                        $code = format_to_geshi_spip($code, 'KEYWORDS', 25);
102                        break;
103                case 'balise_parenthese':
104                        $code = format_to_geshi_spip($code, 'KEYWORDS', 26);
105                        break;
106
107                case 'filtre':
108                        $code = format_to_geshi_spip($code, 'KEYWORDS', 30);
109                        break;
110                case 'parametre':
111                        $code = format_to_geshi_spip($code, 'KEYWORDS', 31);
112                        break;
113                case 'parametre_contenu':
114                        $code = format_to_geshi_spip($code, 'KEYWORDS', 32);
115                        break;
116
117                case 'inclure':
118                        $code = format_to_geshi_spip($code, 'KEYWORDS', 40);
119                        break;
120                case 'inclure_fichier':
121                        $code = format_to_geshi_spip($code, 'KEYWORDS', 41);
122                        break;
123
124                case 'polyglotte':
125                        $code = format_to_geshi_spip($code, 'KEYWORDS', 50);
126                        break;
127                case 'polyglotte_langue':
128                        $code = format_to_geshi_spip($code, 'KEYWORDS', 51);
129                        break;
130                case 'polyglotte_contenu':
131                        $code = format_to_geshi_spip($code, 'KEYWORDS', 52);
132                        break;
133
134                case 'idiome':
135                        $code = format_to_geshi_spip($code, 'KEYWORDS', 60);
136                        break;
137                case 'idiome_module':
138                        $code = format_to_geshi_spip($code, 'KEYWORDS', 61);
139                        break;
140                case 'idiome_chaine':
141                        $code = format_to_geshi_spip($code, 'KEYWORDS', 62);
142                        break;
143
144                case 'operateur':
145                        $code = format_to_geshi_spip($code, 'KEYWORDS', 70);
146                        break;
147
148                case 'nombre':
149                        $code = format_to_geshi_spip($code, 'KEYWORDS', 80);
150                        break;
151        }
152        return $code;
153}
154
155
156/**
157 * Copie de la methode GESHI->hsc() (geshi/geshi.php)
158 * servant a echapper les textes.
159**/
160function geshi_hsc($string, $quote_style = ENT_COMPAT) {
161        // init
162        static $aTransSpecchar = array(
163                '&' => '&amp;',
164                '"' => '&quot;',
165                '<' => '&lt;',
166                '>' => '&gt;',
167
168                //This fix is related to SF#1923020, but has to be applied
169                //regardless of actually highlighting symbols.
170
171                //Circumvent a bug with symbol highlighting
172                //This is required as ; would produce undesirable side-effects if it
173                //was not to be processed as an entity.
174                ';' => '<SEMI>', // Force ; to be processed as entity
175                '|' => '<PIPE>' // Force | to be processed as entity
176                );                      // ENT_COMPAT set
177
178        switch ($quote_style) {
179                case ENT_NOQUOTES: // don't convert double quotes
180                        unset($aTransSpecchar['"']);
181                        break;
182                case ENT_QUOTES: // convert single quotes as well
183                        $aTransSpecchar["'"] = '&#39;'; // (apos) htmlspecialchars() uses '&#039;'
184                        break;
185        }
186
187        // return translated string
188        return strtr($string, $aTransSpecchar);
189}
190
191
192
193
194/**
195 * <BOUCLES>
196 * Fonction automatiquement appelee par le decompilateur
197 * pour recreer le code d'une boucle.
198 *
199**/
200function format_boucle_html_geshi ($avant, $nom, $type, $crit, $corps, $apres, $altern, $prof)
201{
202        $avant = $avant ? format_geshi_spip("<B$nom>", "boucle") . "$avant" : "";
203        $apres = $apres ? "$apres" . format_geshi_spip("</B$nom>", "boucle") : "";
204        $altern = $altern ? "$altern" . format_geshi_spip("<//B$nom>", "boucle") : "";
205        if (!$corps) {
206                $corps = format_geshi_spip(" />", "boucle");
207        } else {
208                $corps = format_geshi_spip(">", "boucle") . $corps . format_geshi_spip("</BOUCLE$nom>", "boucle");
209        }
210        return "$avant"
211                . format_geshi_spip("<BOUCLE$nom", "boucle")
212                . format_geshi_spip("($type)", "boucle_table")
213                . "$crit$corps$apres$altern";
214}
215
216
217
218
219// raccourcis pour {parametre}
220function _format_parametre_html_geshi($param, $echapper=true) {
221        if (!$param) return '';
222
223        if (is_array($param)) {
224                $param = join(format_geshi_spip(", ", 'parametre'), $param);
225        }
226
227        return   format_geshi_spip("{", 'parametre')
228                   . format_geshi_spip($param, 'parametre_contenu', $echapper)
229                   . format_geshi_spip("}", 'parametre');
230}
231
232
233
234
235/**
236 * <INCLURE>
237 * Fonction automatiquement appelee par le decompilateur
238 * pour recreer le code d'une inclusion.
239 *
240**/
241function format_inclure_html_geshi ($file, $args, $prof)
242{
243        if (strpos($file, '#')===false)
244                $t = $file ? (
245                          format_geshi_spip("{", 'inclure')
246                        . format_geshi_spip($file, 'inclure_fichier')
247                        . format_geshi_spip("}", 'inclure')) : "" ;
248        else {
249                $t = _format_parametre_html_geshi("fond=" . $file);
250        }
251        $args = _format_parametre_html_geshi($args, false);
252
253        return (
254                  format_geshi_spip("<INCLURE", 'inclure')
255                . $t . $args
256                . format_geshi_spip(" />", 'inclure'));
257}
258
259
260/**
261 * <multi>[fr]texte</multi>
262 *
263 * Fonction automatiquement appelee par le decompilateur
264 * pour recreer le code d'un polyglotte.
265 *
266**/
267function format_polyglotte_html_geshi ($args, $prof)
268{
269        $contenu = array(); 
270        foreach($args as $l=>$t)
271                $contenu[]= ($l ? format_geshi_spip("[$l]", 'polyglotte_langue') : '') . $t;
272
273        return (
274                  format_geshi_spip("<multi>", 'polyglotte')
275                . format_geshi_spip(join(" ", $contenu), 'polyglotte_contenu', false)
276                . format_geshi_spip("</multi>", 'polyglotte')
277        );
278}
279
280
281
282/**
283 * <:chaine_de_langue:>
284 *
285 * Fonction automatiquement appelee par le decompilateur
286 * pour recreer le code d'un idiome.
287 *
288**/
289function format_idiome_html_geshi ($nom, $module, $args, $filtres, $prof)
290{
291        foreach ($args as $k => $v) {
292                $args[$k] = "$k" . format_geshi_spip("=", 'operateur') . "$v";
293        }
294        $args = _format_parametre_html_geshi($args, false);
295        return (
296                  format_geshi_spip("<:", 'idiome')
297                . ($module ? format_geshi_spip($module, 'idiome_module') . format_geshi_spip(":", 'idiome') : "")
298                . format_geshi_spip($nom, 'idiome_chaine')
299                . $args
300                . $filtres
301                . format_geshi_spip(":>", 'idiome')
302        );
303}
304
305
306
307/**
308 * #BALISE
309 * [(#BALISE)]
310 *
311 * Fonction automatiquement appelee par le decompilateur
312 * pour recreer le code d'une balise.
313 *
314**/
315function format_champ_html_geshi ($nom, $boucle, $etoile, $avant, $apres, $args, $filtres, $prof)
316{
317        $nom = format_geshi_spip("#", 'balise')
318        . ($boucle ? format_geshi_spip($boucle . ":", 'balise_boucle') : "")
319        . format_geshi_spip($nom, 'balise')
320        . format_geshi_spip($etoile, 'balise_etoile')
321        . $args
322        . $filtres;
323
324        // Determiner si c'est un champ etendu,
325        $s = ($avant OR $apres OR $filtres
326              OR (strpos($args, '(#') !==false)); // ## A VERIFIER !!
327
328        // champ simple
329        if (!$s) {
330                return $nom;
331        }
332
333        return format_geshi_spip("[", 'balise_crochet')
334                        . $avant
335                        . format_geshi_spip("(", 'balise_parenthese')
336                        . $nom
337                        . format_geshi_spip(")", 'balise_parenthese')
338                        . $apres
339                        . format_geshi_spip("]", 'balise_crochet');
340}
341
342
343
344/**
345 * {criteres de boucles}
346 *
347 * Fonction automatiquement appelee par le decompilateur
348 * pour recreer les criteres d'une boucle.
349 *
350**/
351function format_critere_html_geshi ($critere)
352{
353        foreach ($critere as $k => $crit) {
354                $crit_s = '';
355                foreach ($crit as $operande) {
356                        list($type, $valeur) = $operande;
357                        if ($type == 'champ' AND $valeur[0]=='[') {
358                          $valeur = substr($valeur,1,-1);
359                          if (preg_match(',^[(](#[^|]*)[)]$,sS', $valeur))
360                                $valeur = substr($valeur,1,-1);
361                        }
362                        $crit_s .= $valeur;
363                }
364                $critere[$k] = $crit_s;
365        }
366        return (!$critere ? "" : format_geshi_spip(
367                geshi_hsc("{") . join(", ", $critere). geshi_hsc("}"),
368                "boucle_critere", false));
369}
370
371
372/**
373 * {parametres de balises}
374 * |filtre{parametres de filtres}
375 *
376 * Fonction automatiquement appelee par le decompilateur
377 * pour recreer les parametres d'une balise,
378 * les filtres et leurs parametres.
379 *
380**/
381function format_liste_html_geshi ($fonc, $args, $prof)
382{
383        return ((($fonc!=='')
384                ? format_geshi_spip("|$fonc", 'filtre')
385                : $fonc)
386        . _format_parametre_html_geshi($args, false));
387}
388
389
390/**
391 *
392 * Fonction automatiquement appelee par le decompilateur
393 * pour concatener les morceaux tel que "#TITRE #TITRE"
394 * = "#TITRE" + " " + "#TITRE" (3 morceaux)
395 *
396 * Concatenation sans separateur: verifier qu'on ne cree pas de faux lexemes
397 *
398**/ 
399function format_suite_html_geshi ($args)
400{
401        for($i=0; $i < count($args)-1; $i++) {
402                list($texte, $type) = $args[$i];
403                list($texte2, $type2) = $args[$i+1];
404                if (!$texte OR !$texte2) continue; 
405                $c1 = substr($texte,-1);
406                if ($type2 !== 'texte') {
407                  // si un texte se termine par ( et est suivi d'un champ
408                  // ou assimiles, forcer la notation pleine
409                        if ($c1 == '(' AND substr($texte2,0,1) == '#')
410                                $args[$i+1][0] = _format_suite_html_geshi_notation_balise_pleine($texte2);
411                } else {
412                        if ($type == 'texte') continue;
413                        // si un champ ou assimiles est suivi d'un texte
414                        // et si celui-ci commence par un caractere de champ
415                        // forcer la notation pleine
416                        if (($c1 == '}' AND substr(ltrim($texte2),0,1) == '|')
417                        OR (preg_match('/[\w\d_*]/', $c1) AND preg_match('/^[\w\d_*{|]/', $texte2)))
418                                $args[$i][0] = _format_suite_html_geshi_notation_balise_pleine($texte);
419                }
420        }
421        return join("", array_map('array_shift', $args));
422}
423
424
425// Raccourci pour ajouter [( et )] sur une balise
426function _format_suite_html_geshi_notation_balise_pleine($balise) {
427        return
428                  format_geshi_spip("[", 'balise_crochet')
429                . format_geshi_spip("(", 'balise_parenthese')
430                . $balise
431                . format_geshi_spip(")", 'balise_parenthese')
432                . format_geshi_spip("]", 'balise_crochet');
433}
434
435
436/**
437 * Du texte
438 *
439**/
440function format_texte_html_geshi ($texte)
441{
442        if (is_numeric($texte)) {
443                return format_geshi_spip($texte, 'nombre');
444        } else {
445                return geshi_hsc($texte);
446        }
447}
448
Note: See TracBrowser for help on using the repository browser.