source: spip-zone/_plugins_/coloration_code/trunk/geshi/geshi/spip.php @ 111499

Last change on this file since 111499 was 111499, checked in by marcimat@…, 19 months ago

Compatibilité PHP 7.2 : utiliser des fonctions anonymes et pas des create_function.
Comme ça n’arrive qu’avec PHP 5.3, on met SPIP 3.2 minimum en borne. Na !

File size: 19.4 KB
Line 
1<?php
2/*************************************************************************************
3 * spip.php
4 * -------
5 * Author: Collectif SPIP
6 * Copyright: (c) 2004 Nigel McNie (http://qbnz.com/highlighter/)
7 * Release Version: 1.0.7.6
8 * CVS Revision Version: $Revision: 1.10 $
9 *
10 *************************************************************************************
11 *
12 *     This file is part of GeSHi.
13 *
14 *   GeSHi is free software; you can redistribute it and/or modify
15 *   it under the terms of the GNU General Public License as published by
16 *   the Free Software Foundation; either version 2 of the License, or
17 *   (at your option) any later version.
18 *
19 *   GeSHi is distributed in the hope that it will be useful,
20 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
21 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22 *   GNU General Public License for more details.
23 *
24 *   You should have received a copy of the GNU General Public License
25 *   along with GeSHi; if not, write to the Free Software
26 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
27 *
28 ************************************************************************************/
29
30
31// nom de la boucle x dans <BOUCLEx>
32@define('REG_NOM_BOUCLE', '[a-zA-Z0-9_]+');
33
34// table d'une boucle (TABLE) ou (connect:TABLE)
35@define('REG_NOM_TABLE_BOUCLE', '\([^)]+\)');
36
37// criteres | arguments : {critere > 0} {critere = #ENV{truc}}
38@define('REG_CRITERES',           '\{(?:\s*(?:(?>[^{}]+)|(?R))*\s*)\}');
39// la meme chose sans rien de capturant
40@define('REG_CRITERES_TOUT',      '\{(?:\s*(?:(?>[^{}]+)|(?R))*\s*)\}');
41// la meme chose en capturant {, contenu et } en 3 morceaux
42@define('REG_CRITERES_ACCOLADES', '(\{)(\s*(?:(?>[^{}]+)|(?R))*\s*)(\})');
43
44// Remplacements de Regexp par GESHI
45// A chaque fois dans le tableau REGEXPS que geshi trouve quelque chose,
46// il l'encadre de <|!REG3EXPn!>contenu|>
47// ou n est la cle de regexp et contenu ce qui est dans "geshi_replace"
48@define('REG_REMPLACEMENTS_GESHI_START', '<\|!REG3XP[0-9]+!>');
49@define('REG_REMPLACEMENTS_GESHI_END', '\|>');
50@define('REG_REMPLACEMENTS_GESHI', REG_REMPLACEMENTS_GESHI_START . '.*' . REG_REMPLACEMENTS_GESHI_END);
51
52// <Bx> </Bx> <//Bx> </BOUCLEx>
53@define('REG_BOUCLE_SIMPLE','(&lt;\/?\/?B(OUCLE)?' . REG_NOM_BOUCLE . '\s*&gt;)');
54
55// Calcul des <BOUCLEx(){} />. C'est complexe
56// 1) trouver la fin   />
57@define('REG_FIN_BOUCLE', '\s*\/?&gt;');
58@define('REG_FIN_BOUCLE_TROUVE', REG_REMPLACEMENTS_GESHI_START . REG_FIN_BOUCLE . REG_REMPLACEMENTS_GESHI_END);
59// 2) trouver le debut <BOUCLEx
60@define('REG_DEBUT_BOUCLE', '&lt;BOUCLE' . REG_NOM_BOUCLE);
61@define('REG_DEBUT_BOUCLE_TROUVE', REG_REMPLACEMENTS_GESHI_START . REG_DEBUT_BOUCLE . REG_REMPLACEMENTS_GESHI_END);
62// 3) trouver la table (TABLE)
63@define('REG_TABLE_BOUCLE_TROUVE', REG_REMPLACEMENTS_GESHI_START . REG_NOM_TABLE_BOUCLE . REG_REMPLACEMENTS_GESHI_END);
64// 4) trouver les criteres
65
66
67// Aide pour les reg de boucle
68// ?R est applique sur l'expression complete.
69// on indique donc la parenthese que l'on souhaite avec ?x
70// sinon ca ne fonctionne pas (des qu'un critere a d'autres accolades internes.)
71@define('REG_CRITERES_BOUCLE', '(?:(\s*' . REG_CRITERES . '\s*)*)'); // 1 parenthese capturante pour la recursion
72
73// 1) <BOUCLEx(TABLE){criteres} /> ( la fin /> )
74@define('REG_BOUCLE_FIN', '((?:' . REG_DEBUT_BOUCLE . ')(?:' . REG_NOM_TABLE_BOUCLE . ')'
75        // criteres + fin de boucle
76        . str_replace('?R', '?2', REG_CRITERES_BOUCLE) . ')(' . REG_FIN_BOUCLE . ')');
77
78// 2) <BOUCLEx(TABLE){criteres} @@/>@@ ( le debut <BOUCLEx )
79@define('REG_BOUCLE_DEBUT','(' . REG_DEBUT_BOUCLE . ')((?:' . REG_NOM_TABLE_BOUCLE . ')'
80        // criteres + fin de boucle
81        . str_replace('?R', '?3', REG_CRITERES_BOUCLE) . '(?:' . REG_FIN_BOUCLE_TROUVE . '))');
82
83// 3) @@<BOUCLEx@@ (TABLE){criteres} @@/>@@ ( la table (TABLE) )
84@define('REG_BOUCLE_TABLE','(' . REG_DEBUT_BOUCLE_TROUVE . ')(' . REG_NOM_TABLE_BOUCLE . ')' . '('
85        // criteres + fin de boucle
86        .  str_replace('?R', '?4', REG_CRITERES_BOUCLE) . '(?:' . REG_FIN_BOUCLE_TROUVE . '))');
87
88// 4) @@<BOUCLEx@@ @@(TABLE)@@ {criteres} @@/>@@ ( des criteres {criteres} )
89@define('REG_BOUCLE_CRITERES','((?:' . REG_DEBUT_BOUCLE_TROUVE . ')(?:' . REG_TABLE_BOUCLE_TROUVE . '))'
90        // criteres + fin de boucle
91        . '(' . str_replace('?R', '?3', REG_CRITERES_BOUCLE) . ')(' . REG_FIN_BOUCLE_TROUVE . ')');
92
93
94// <INCLURE
95@define('REG_INCLURE','(&lt;INCLU(D|R)E)(\([^)]*\))?(.*)?(&gt;)');
96
97// Ce qui suit un filtre d'operation tel que |> |< |== |? ...
98// doit toujours etre une { ou equivalent ( la capture d'un parametre (REGEXP40) )
99// On le teste pour eviter de prendre | <style> par exemple
100// Mais certaines versions de PCRE (7.6 ko, 8.12 ok) plantent sur cette recherche de suite,
101// donc on ne le fait pas pour ces vieilles versions
102if (version_compare(current(explode(' ', PCRE_VERSION, 2)), '7.7', '>=')) {
103        @define('REG_SUITE_FILTRE', '(?={|<\|!REG3XP40!>)');
104} else {
105        @define('REG_SUITE_FILTRE', '');
106}
107
108// |filtre |class::methode
109// et |>= |?
110@define('REG_NOM_FILTRE', '((?:<PIPE>\s*[a-z_][a-z0-9_=]*(::[a-z0-9_]*)?)'
111                // |< et consoeurs sont toujours suivis par une accolade ouvrante {
112                . '|(?:<PIPE>\s*(?:&gt;=?|&lt;=?|&lt;&gt;|===?|!==?|\?)(?:\s*)'
113                . REG_SUITE_FILTRE
114                . '))');
115// la meme chose, mais sans etre capturant.
116@define('REG_NOM_FILTRE_TOUT', '(?:(?:<PIPE>\s*[a-z_][a-z0-9_=]*(?:::[a-z0-9_]*)?)'
117                . '|(?:<PIPE>\s*(?:&gt;=?|&lt;=?|&lt;&gt;|===?|!==?|\?)(?:\s*)'
118                . REG_SUITE_FILTRE
119                . '))');
120
121// #BALISE
122@define('REG_BALISE','(\#)(' . REG_NOM_BOUCLE . ':)?([A-Z0-9_]+)([*]{0,2})');
123// la meme chose, mais sans etre capturant.
124@define('REG_BALISE_TOUT','(?:\#)(?:' . REG_NOM_BOUCLE . ':)?(?:[A-Z0-9_]+)(?:[*]{0,2})');
125
126
127
128// Recherche des parties exterieures des balises.
129// On ne peut pas avoir plus d'une seule recursivite
130/* @define('REG_BALISE_EXTERIEUR', '(?:\s*(?:(?>[^\[\]]+)|(?R))*\s*)'); */ 
131// du coup on ne peut attraper que les parties exterieures
132// qui n'ont pas de crochets internes.
133@define('REG_BALISE_EXTERIEUR', '(?:[^\[\]]*)');
134@define('REG_BALISE_COMPLET_START', '(\[)(' . REG_BALISE_EXTERIEUR . ')(\()'); // [ ... (
135@define('REG_BALISE_COMPLET_STOP',  '(\))(' . REG_BALISE_EXTERIEUR . ')(\])'); // ) ... ]
136// Attention a ne pas avoir plus de 9 parentheses capturantes car on ne peut pas ecrire \\10
137@define('REG_BALISE_COMPLET',
138          REG_BALISE_COMPLET_START . '(' // [ ... (
139        . '(?:' . REG_BALISE_TOUT . ')' // #BALISE
140         // {arguments} |filtre{criteres}
141         // *+ pour diminuer le nombre de pcre.backtrace_limit
142        . '(?:(\s*' . REG_NOM_FILTRE_TOUT . '?' . str_replace('?R', '?5', REG_CRITERES_BOUCLE) . '?)*+)'
143         // ) ... ]
144        . ')' . REG_BALISE_COMPLET_STOP );
145
146
147
148
149if (!function_exists('spip2_geshi_regexp_critere_callback')) {
150/**
151 * Cette fonction recupere la liste des criteres de boucle trouves
152 * "  {critere > 0} {critere=#ENV{tom}}{critere} "
153 * Elle echappe tous les { et } appartenants au criteres
154 * en les remplacant par <CRITERE> et </CRITERE>. Ils seront
155 * remis apres le calcul les arguments de balises / filtres.
156 *
157 * Ceci est simplement la pour pouvoir distinguer filtre et critere
158 * dans la coloration.
159 *
160 * @param array $matches
161 *              Le resultat du preg_match
162 * @param Object $geshi
163 *              Instance de l'objet SPIP_GESHI (issu de GESHI)
164 * @return string
165 *              La chaine attendu par Geshi
166 *              qui est quelque chose comme
167 *              "avant <|!REG3XP31!>contenu|> apres"
168**/
169function spip2_geshi_regexp_critere_callback($matches, $geshi) {
170        $key = $geshi->_hmr_key;
171        // 0 = tout
172        // 1 = <BOUCLEx(TABLE)
173        // 2 = {critere}{critere}
174        // 3 = />
175        // L'entree 2 contient les criteres a echapper, et il ne faut pas oublier aussi les espaces possibles.
176        $criteres = $matches[2];
177        if (preg_match_all('/(\s*)' . REG_CRITERES_ACCOLADES . '(\s*)/s', $criteres, $crits, PREG_SET_ORDER)) {
178                $criteres = "";
179                foreach ($crits as $c) {
180                        $criteres .=
181                                  $c[1] // espace
182                                . "<CRITERE>" // {
183                                . $c[3] // critere
184                                . "</CRITERE>" // }
185                                . $c[5]; // espace
186                }
187        }
188
189        $retour = $matches[1] . '<|!REG3XP' . $key .'!>'
190                . str_replace("\n", "|>\n<|!REG3XP" . $key . '!>', $criteres)
191                . '|>' . $matches[4];
192        return $retour;
193}
194
195
196
197
198/**
199 * Cette fonction recupere la liste des balises qui
200 * ont des parties optionnelles [ ...( et ) ... ]
201 *
202 * Elle colorie les signes [()]
203 * Elle les echappe egalement.
204 * Ainsi, on peut relancer la regexp pour tenter de trouver des enchainements
205 * de balise plus profonds.
206 *
207 * @param array $matches
208 *              Le resultat du preg_match
209 * @param Object $geshi
210 *              Instance de l'objet SPIP_GESHI (issu de GESHI)
211 * @return string
212 *              La chaine attendu par Geshi
213 *              qui est quelque chose comme
214 *              "avant <|!REG3XP31!>contenu|> apres"
215**/
216function spip2_geshi_regexp_balise_callback($matches, $geshi) {
217        $key = $geshi->_hmr_key;
218        // on l'appelle plusieurs fois mais on colorie toujours avec la meme cle.
219        $key = 4; 
220        // 0 = tout
221        // 1 = [
222        // 2 = avant
223        // 3 = (
224        // 4 = #BALISE|filtre{x}
225        // 5 =
226        // 6 =
227        // 7 = )
228        // 8 = apres
229        // 9 = ]
230        // -INERTE=x= sera remplace ensuite par le vrai caractere.
231        $retour =
232                  '<|!REG3XP' . $key .'!>-INERTE=' . ord('[') . '=|>' // [
233                . $matches[2] // avant
234                . '<|!REG3XP' . $key .'!>-INERTE=' . ord('(') . '=|>' // (
235                . $matches[4] // balise
236                . '<|!REG3XP' . $key .'!>-INERTE=' . ord(')') . '=|>' // )
237                . $matches[8] // apres
238                . '<|!REG3XP' . $key .'!>-INERTE=' . ord(']') . '=|>' // ]
239                ;
240
241        return $retour;
242}
243
244
245
246/**
247 * Echapper les echappements \[ \] ...
248 * Attention a < et > qui arrivent avec &lt; et &gt;
249 *
250**/
251function spip2_geshi_regexp_echappements_echapper_callback($matches, $geshi) {
252        $squelette = $matches[0];
253
254        // rendre inertes les echappements de #[](){}<>
255        $inerte = '-INERTE';
256        // mais eviter d'echapper \<PIPE>, <PIPE> etant deja un echappement de Geshi
257        // normalement les < et > sont justement aussi echapes en &gt et &lt
258        // donc on ne cherche pas la capture de \< ou \>
259        $squelette = preg_replace_callback(',\\\\([#[()\]{}]|&gt;|&lt;),',
260                function($a) use ($inerte) {
261                        return $inerte . '-' . ord(html_entity_decode($a[1])) . '-';
262                },
263                $squelette, -1, $esc
264        );
265
266        return $squelette;
267}
268
269/**
270 * Remettre les echappements \[ \] ...
271 *
272 * Remettre les [ ( ) ] echappes des balises
273 * Attention a < et > qui doivent repartir avec &lt; et &gt;
274 *
275**/
276function spip2_geshi_regexp_echappements_remettre_callback($matches, $geshi) {
277        $contenu = $matches[0];
278        $inerte = '-INERTE';
279        $key = $geshi->_hmr_key;
280        // echappements avec \
281        $contenu = preg_replace_callback(",$inerte-(\d+)-,",
282                function($a) use ($inerte, $key) {
283                        return '<|!REG3XP' . $key . '!>\\' . htmlspecialchars(chr($a[1])) . '|>';
284                },
285                $contenu
286        );
287
288        // echappements de balise faits par une regexp de ce colorieur (regexp 4 à 7).
289        $contenu = preg_replace_callback(",$inerte=(\d+)=,",
290                function($a) use ($contenu) {
291                        return chr($a[1]);
292                }, $contenu
293        );
294
295        return $contenu;
296}
297
298
299
300
301} // /if
302
303
304
305$language_data = array (
306        'LANG_NAME' => 'XML',
307        'COMMENT_SINGLE' => array(),
308        'COMMENT_MULTI' => array('<!--' => '-->'),
309        'CASE_KEYWORDS' => GESHI_CAPS_NO_CHANGE,
310        'QUOTEMARKS' => array(),
311        'ESCAPE_CHAR' => '',
312        'KEYWORDS' => array(),
313        'SYMBOLS' => array(),
314        'CASE_SENSITIVE' => array(
315                GESHI_COMMENTS => false,
316                ),
317        'PARSER_CONTROL' => array(
318                'ENABLE_FLAGS' => array(
319                        'BRACKETS' => GESHI_NEVER, // le colorieur s'occupera des [](){} !
320                        'NUMBERS'  => GESHI_NEVER, // le colorieur s'occupera des 123 (ou pas !)
321                        #'KEYWORDS' => GESHI_NEVER, // il les faut pour les classes css :(
322        )),
323        'STYLES' => array(
324                'KEYWORDS' => array(),
325                'COMMENTS' => array(
326                        'MULTI' => 'color: #808080; font-style: italic;'
327                        ),
328                'ESCAPE_CHAR' => array(
329                        0 => 'color: #000099; font-weight: bold;'
330                        ),
331                'BRACKETS' => array(),
332                'STRINGS' => array(),
333                'NUMBERS' => array(),
334                'METHODS' => array(),
335                'SYMBOLS' => array(),
336                'SCRIPT' => array(),
337                'REGEXPS' => array(
338                        0 => 'color: #FF4E00;', // balise (#nom:TITRE**) ** (meme couleur que 50:filtre)
339                        1 => 'color: #D05000;', // balise (#nom:TITRE) #TITRE
340                        2 => 'color: #1DA3DD;', // balise (#nom:TITRE) nom:
341                        4 => 'color: #D05000;', // [ ( et ) ]
342
343                        10 => 'color: #1DA3DD;', // fin boucle
344                        11 => 'color: #1DA3DD;', // debut boucle
345                        12 => 'color: #527EE0;', // tables boucle
346                        13 => 'color: #984CFF;', // criteres boucles
347                        15 => 'color: #1DA3DD;', // boucle simple <Bx> </Bx> ...
348
349                        20 => 'color: #527EE0;', // inclure entre parenthese
350                        21 => 'color: #222', // inclure debut
351                        22 => 'color: #745E4B;', // inclure criteres
352                        23 => 'color: #222;', // inclure fin
353                       
354                        30 => 'color: #C90', // idiome (chaine de langue)
355                        31 => 'color: #C90', // multi
356                       
357                        40 => 'color: #74B900;', // critere de boucle ou de balise
358                        50 => 'color: #FF851D;', // filtres de balise
359
360                        // echappements
361                        101 => '', // \[ \] \{ ...
362                        102 => 'color:#FF2100; font-weight:bold;', // les \ dans les echappements
363
364                        // autres (eviter des notices php)
365                        100  => '',
366                        41   => '',
367                        '4b' => '',
368                        '4c' => '',
369                        '4d' => '',
370                        '4e' => '',
371                        )
372                ),
373        'URLS' => array(),
374        'OOLANG' => false,
375        'OBJECT_SPLITTERS' => array(),
376
377        'REGEXPS' => array(
378                // echapper les echappements
379                100 => array(
380                        GESHI_SEARCH => '^.*$',
381                        SPIP_GESHI_REGEXP_FUNCTION => 'spip2_geshi_regexp_echappements_echapper_callback',
382                        GESHI_MODIFIERS => 's',
383                        // eviter des notices PHP
384                        GESHI_REPLACE => '',
385                        GESHI_BEFORE => '',
386                        GESHI_AFTER => ''
387                        ),
388
389
390                #######  BALISES  ########
391
392                // Balise complexe avec [ ( et ) ] si on peut
393                // Colorie les [()] et les echappe lorsqu'il en trouve.
394                // on l'applique plusieurs fois pour tenter de capturer un plus grand nombre
395                // lorsqu'on a des imbrications comme [ [(#TITRE)] (#ENV) apres ]
396                // car on ne peut pas effectuer d'autre recursion
397                // dans cette regexp qui en possede deja une pour les criteres
398                4 => array(
399                        GESHI_SEARCH => REG_BALISE_COMPLET,
400                        SPIP_GESHI_REGEXP_FUNCTION => 'spip2_geshi_regexp_balise_callback',
401                        GESHI_MODIFIERS => '',
402                        // eviter des notices PHP
403                        GESHI_REPLACE => '',
404                        GESHI_BEFORE => '',
405                        GESHI_AFTER => ''
406                        ),
407                '4b' => array(
408                        GESHI_SEARCH => REG_BALISE_COMPLET,
409                        SPIP_GESHI_REGEXP_FUNCTION => 'spip2_geshi_regexp_balise_callback',
410                        GESHI_MODIFIERS => '',
411                        // eviter des notices PHP
412                        GESHI_REPLACE => '',
413                        GESHI_BEFORE => '',
414                        GESHI_AFTER => ''
415                        ),
416                '4c' => array(
417                        GESHI_SEARCH => REG_BALISE_COMPLET,
418                        SPIP_GESHI_REGEXP_FUNCTION => 'spip2_geshi_regexp_balise_callback',
419                        GESHI_MODIFIERS => '',
420                        // eviter des notices PHP
421                        GESHI_REPLACE => '',
422                        GESHI_BEFORE => '',
423                        GESHI_AFTER => ''
424                        ),
425                '4d' => array(
426                        GESHI_SEARCH => REG_BALISE_COMPLET,
427                        SPIP_GESHI_REGEXP_FUNCTION => 'spip2_geshi_regexp_balise_callback',
428                        GESHI_MODIFIERS => '',
429                        // eviter des notices PHP
430                        GESHI_REPLACE => '',
431                        GESHI_BEFORE => '',
432                        GESHI_AFTER => ''
433                        ),
434                '4e' => array(
435                        GESHI_SEARCH => REG_BALISE_COMPLET,
436                        SPIP_GESHI_REGEXP_FUNCTION => 'spip2_geshi_regexp_balise_callback',
437                        GESHI_MODIFIERS => '',
438                        // eviter des notices PHP
439                        GESHI_REPLACE => '',
440                        GESHI_BEFORE => '',
441                        GESHI_AFTER => ''
442                        ),
443
444                // Balise (#nom:TITRE**) (les etoiles)
445                0 => array(
446                        GESHI_SEARCH => REG_BALISE,
447                        GESHI_REPLACE => '\\4',
448                        GESHI_MODIFIERS => '',
449                        GESHI_BEFORE => '\\1\\2\\3',
450                        GESHI_AFTER => ''
451                        ),
452                // Balise (#nom:TITRE) (l'ensemble hors etoiles)
453                1 => array(
454                        GESHI_SEARCH => REG_BALISE,
455                        GESHI_REPLACE => '\\1\\2\\3',
456                        GESHI_MODIFIERS => '',
457                        GESHI_BEFORE => '',
458                        GESHI_AFTER => ''
459                        ),
460                // Balise (nom:) (le connecteur nom:)
461                2 => array(
462                        GESHI_SEARCH => REG_BALISE,
463                        GESHI_REPLACE => '\\2',
464                        GESHI_MODIFIERS => '',
465                        GESHI_BEFORE => '\\1',
466                        GESHI_AFTER => '\\3'
467                        ),
468
469
470                #######  BOUCLES  ########
471
472                // Au fur et a mesure que GESHI trouve des regexp
473                // il encadre ses trouvailles de <|!REG3XPn!>contenu|>
474                // tel que <|!REG3XP10!>(ARTICLES)|>
475
476                // 1) fin de boucle <BOUCLEx(TABLE).../> ( /> )
477                10 => array(
478                        GESHI_SEARCH => REG_BOUCLE_FIN,
479                        GESHI_REPLACE => '\\3',
480                        GESHI_MODIFIERS => '',
481                        GESHI_BEFORE => '\\1',
482                        GESHI_AFTER => ''
483                        ),
484
485                // 2) debut de boucle <BOUCLEx(TABLE).../> ( <BOUCLEx )
486                11 => array(
487                        GESHI_SEARCH => REG_BOUCLE_DEBUT,
488                        GESHI_REPLACE => '\\1',
489                        GESHI_MODIFIERS => '',
490                        GESHI_BEFORE => '',
491                        GESHI_AFTER => '\\2'
492                        ),
493
494                // 3) table de la boucle <BOUCLEx(TABLE).../> ( (TABLE) )
495                12 => array(
496                        GESHI_SEARCH => REG_BOUCLE_TABLE,
497                        GESHI_REPLACE => '\\2',
498                        GESHI_MODIFIERS => '',
499                        GESHI_BEFORE => '\\1',
500                        GESHI_AFTER => '\\3'
501                        ),
502
503                // criteres de boucle <BOUCLEx(TABLE).../> ( {criteres} )
504                // on remplace { et } de chaque critere par <CRITERE> pour
505                // que les filtres 40 ne matchent pas les criteres
506                // 41 les remets.
507                13 => array(
508                        GESHI_SEARCH => REG_BOUCLE_CRITERES,
509                        SPIP_GESHI_REGEXP_FUNCTION => 'spip2_geshi_regexp_critere_callback',
510                        GESHI_MODIFIERS => '',
511                        // eviter des notices PHP
512                        GESHI_REPLACE => '',
513                        GESHI_BEFORE => '',
514                        GESHI_AFTER => ''
515                        ),
516
517
518
519                // boucle simple <Bx>
520                15 => array(
521                        GESHI_SEARCH => REG_BOUCLE_SIMPLE,
522                        GESHI_REPLACE => '\\1',
523                        GESHI_MODIFIERS => '',
524                        GESHI_BEFORE => '',
525                        GESHI_AFTER => ''
526                        ),
527
528
529                #######  INCLURE  ########
530
531                // inclure (entre parenthese)
532                20 => array(
533                        GESHI_SEARCH => REG_INCLURE,
534                        GESHI_REPLACE => '\\3',
535                        GESHI_MODIFIERS => '',
536                        GESHI_BEFORE => '\\1',
537                        GESHI_AFTER => '\\4\\5'
538                        ),
539                // inclure (debut)
540                21 => array(
541                        GESHI_SEARCH => REG_INCLURE,
542                        GESHI_REPLACE => '\\1',
543                        GESHI_MODIFIERS => '',
544                        GESHI_BEFORE => '',
545                        GESHI_AFTER => '\\3\\4\\5'
546                        ),
547                // inclure (criteres)
548                22 => array(
549                        GESHI_SEARCH => REG_INCLURE,
550                        GESHI_REPLACE => '\\4',
551                        GESHI_MODIFIERS => '',
552                        GESHI_BEFORE => '\\1\\3',
553                        GESHI_AFTER => '\\5'
554                        ),
555                // inclure (fin)
556                23 => array(
557                        GESHI_SEARCH => REG_INCLURE,
558                        GESHI_REPLACE => '\\5',
559                        GESHI_MODIFIERS => '',
560                        GESHI_BEFORE => '\\1\\3\\4',
561                        GESHI_AFTER => ''
562                        ),
563
564
565
566                #######  CHAINES DE LANGUE  ########
567
568                // idiome
569                30 => array(
570                        GESHI_SEARCH => '(&lt;:(.*):&gt;)',
571                        GESHI_REPLACE => '\\1',
572                        GESHI_MODIFIERS => '',
573                        GESHI_BEFORE => '',
574                        GESHI_AFTER => ''
575                        ),
576                // multi
577                31 => array(
578                        GESHI_SEARCH => '(&lt;multi&gt;(.*)&lt;\\/multi&gt;)',
579                        GESHI_REPLACE => '\\1',
580                        GESHI_MODIFIERS => 'i',
581                        GESHI_BEFORE => '',
582                        GESHI_AFTER => ''
583                        ),
584
585
586                #######  PARAMETRES  ########
587
588                // parametres de filtre, balise
589                40 => array(
590                        GESHI_SEARCH => '(' . REG_CRITERES . ')',
591                        GESHI_REPLACE => '\\1',
592                        GESHI_MODIFIERS => '',
593                        GESHI_BEFORE => '',
594                        GESHI_AFTER => ''
595                        ),
596                // remise des accolades de criteres
597                // echappees pour eviter que filtres 40 ne les matchent
598                41 => array(
599                        GESHI_SEARCH => '<CRITERE>(.*)<\/CRITERE>',
600                        GESHI_REPLACE => '{\\1}',
601                        GESHI_MODIFIERS => 'Us',
602                        GESHI_BEFORE => '',
603                        GESHI_AFTER => ''
604                        ),
605
606
607                #######  FILTRES  ########
608
609                // filtre
610                50 => array(
611                        GESHI_SEARCH => REG_NOM_FILTRE,
612                        GESHI_REPLACE => '\\1',
613                        GESHI_MODIFIERS => 'i',
614                        GESHI_BEFORE => '',
615                        GESHI_AFTER => ''
616                        ),
617
618
619                #######  ECHAPPEMENTS  ########
620
621                // remettre les echappements
622                101 => array(
623                        GESHI_SEARCH => '^.*$',
624                        SPIP_GESHI_REGEXP_FUNCTION => 'spip2_geshi_regexp_echappements_remettre_callback',
625                        GESHI_MODIFIERS => 's',
626                        // eviter des notices PHP
627                        GESHI_REPLACE => '',
628                        GESHI_BEFORE => '',
629                        GESHI_AFTER => ''
630                        ),
631                // permettre de colorer le \ des echappements differement
632                // attention a \&gt; et \&lt; a la place de \> et \< dans geshi
633                102 => array(
634                        GESHI_SEARCH => '(<\|!REG3XP101!>)(.)((?:.|&lt;|&gt;)\|>)',
635                        GESHI_REPLACE => '\\2',
636                        GESHI_MODIFIERS => '',
637                        GESHI_BEFORE => '\\1',
638                        GESHI_AFTER => '\\3'
639                        ),
640               
641                ),
642
643        'STRICT_MODE_APPLIES' => GESHI_NEVER,
644        'SCRIPT_DELIMITERS' => array(),
645
646        'HIGHLIGHT_STRICT_BLOCK' => array(
647                0 => true,
648                1 => true,
649                2 => true,
650                3 => true,
651                4 => true,
652                5 => true,
653                )
654);
Note: See TracBrowser for help on using the repository browser.