Changeset 68178 in spip-zone


Ignore:
Timestamp:
Dec 5, 2012, 10:30:19 PM (7 years ago)
Author:
esj@…
Message:

iterateurs: ne redéfinir que les fonctions qui changent afin d'hériter de toute modif dans le phraseur standard.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/iterateurs/public/phraser_html.php

    r43155 r68178  
    1414if (!defined('_ECRIRE_INC_VERSION')) return;
    1515
    16 # Ce fichier transforme un squelette en un tableau d'objets de classe Boucle
    17 # il est charge par un include calcule
    18 # pour permettre differentes syntaxes en entree
    19 
    20 define('BALISE_BOUCLE', '<BOUCLE');
    21 define('BALISE_FIN_BOUCLE', '</BOUCLE');
    22 define('BALISE_PRE_BOUCLE', '<B');
    23 define('BALISE_POST_BOUCLE', '</B');
    24 define('BALISE_ALT_BOUCLE', '<//B');
    25 
    26 define('TYPE_RECURSIF', 'boucle');
    27 define('SPEC_BOUCLE','/\s*\(\s*([^\s?)]+)(\s*[^)?]*)([?]?)\)/');
    28 define('NOM_DE_BOUCLE', "[0-9]+|[-_][-_.a-zA-Z0-9]*");
    29 # ecriture alambiquee pour rester compatible avec les hexadecimaux des vieux squelettes
    30 define('NOM_DE_CHAMP', "#((" . NOM_DE_BOUCLE . "):)?(([A-F]*[G-Z_][A-Z_0-9]*)|[A-Z_]+)(\*{0,2})");
    31 define('CHAMP_ETENDU', '/\[([^]\[]*)\(' . NOM_DE_CHAMP . '([^[)]*\)[^]\[]*)\]/S');
    32 
    33 define('BALISE_INCLURE','/<INCLU[DR]E[[:space:]]*(\(([^)]*)\))?/S');
    34 define('BALISE_POLYGLOTTE',',<multi>(.*)</multi>,Uims');
    35 define('BALISE_IDIOMES',',<:(([a-z0-9_]+):)?([a-z0-9_]+)({([^\|=>]*=[^\|>]*)})?((\|[^>]*)?:>),iS');
    36 
    37 define('SQL_ARGS', '(\([^)]*\))');
     16include(_DIR_RESTREINT . 'public/phraser_html.php');
     17
    3818define('CHAMP_SQL_PLUS_FONC', '`?([A-Z_\/][A-Z_\/0-9.]*)' . SQL_ARGS . '?`?');
    3919
    40 // http://doc.spip.org/@phraser_inclure
    41 function phraser_inclure($texte, $ligne, $result) {
    42 
    43         while (preg_match(BALISE_INCLURE, $texte, $match)) {
    44                 $p = strpos($texte,$match[0]);
    45                 $debut = substr($texte, 0, $p);
    46                 if ($p) $result = phraser_idiomes($debut, $ligne, $result);
    47                 $ligne +=  substr_count($debut, "\n");
    48                 $champ = new Inclure;
    49                 $champ->ligne = $ligne;
    50                 $ligne += substr_count($match[0], "\n");
    51                 $fichier = @$match[2];
    52                 # assurer ici la migration .php3 => .php
    53                 # et de l'ancienne syntaxe INCLURE(page.php3) devenue surperflue
    54                 if (preg_match(',^(.*[.]php)3$,', $fichier, $r)) {
    55                         $fichier = $r[1];
    56                 }
    57                 $champ->texte = ($fichier !== 'page.php') ? $fichier : '';
    58                 $texte = substr($texte, $p+strlen($match[0]));
    59                 // on assimile {var=val} a une liste de un argument sans fonction
    60                 phraser_args($texte,"/>","",$result,$champ);
    61                 if (!$champ->texte OR count($champ->param) > 1) {
    62                         include_spip('public/normaliser');
    63                         normaliser_inclure($champ);
    64                 }
    65                 $texte = substr($champ->apres, strpos($champ->apres, '>')+1);
    66                 $champ->apres = "";
    67                 $texte = preg_replace(',^</INCLU[DR]E>,', '', $texte);
    68                 $result[] = $champ;
    69         }
    70         return (($texte==="") ? $result : phraser_idiomes($texte, $ligne, $result));
    71 }
    72 
    73 // http://doc.spip.org/@phraser_polyglotte
    74 function phraser_polyglotte($texte,$ligne, $result) {
    75 
    76         if (preg_match_all(BALISE_POLYGLOTTE, $texte, $m, PREG_SET_ORDER))
    77         foreach ($m as $match) {
    78                 $p = strpos($texte, $match[0]);
    79                 $debut = substr($texte, 0, $p);
    80                 if ($p) {
    81                         $champ = new Texte;
    82                         $champ->texte = $debut;
    83                         $champ->ligne = $ligne;
    84                         $result[] = $champ;
    85                         $ligne += substr_count($champ->texte, "\n");
    86                 }
    87 
    88                 $champ = new Polyglotte;
    89                 $champ->ligne = $ligne;
    90                 $ligne += substr_count($match[0], "\n");
    91                 $lang = '';
    92                 $bloc = $match[1];
    93                 $texte = substr($texte,$p+strlen($match[0]));
    94                 while (preg_match("/^[[:space:]]*([^[{]*)[[:space:]]*[[{]([a-z_]+)[]}](.*)$/si", $bloc, $regs)) {
    95                   $trad = $regs[1];
    96                   if ($trad OR $lang)
    97                         $champ->traductions[$lang] = $trad;
    98                   $lang = $regs[2];
    99                   $bloc = $regs[3];
    100                 }
    101                 $champ->traductions[$lang] = $bloc;
    102                 $result[] = $champ;
    103         }
    104         if ($texte!=="") {
    105                         $champ = new Texte;
    106                         $champ->texte = $texte;
    107                         $champ->ligne = $ligne;
    108                         $result[] = $champ;
    109         }
    110         return $result;
    111 }
    112 
    113 
    114 // http://doc.spip.org/@phraser_idiomes
    115 function phraser_idiomes($texte,$ligne,$result) {
    116 
    117         // Reperer les balises de traduction <:module:chaine{argument1=texte,argument2=#BALISE}|filtre1{texte,#BALISE}|filtre2:>
    118         while (preg_match(BALISE_IDIOMES, $texte, $match)) {
    119                 $p = strpos($texte, $match[0]);
    120                 $debut = substr($texte, 0, $p);
    121                 if ($p) $result = phraser_champs($debut, $ligne, $result);
    122                 $champ = new Idiome;
    123                 $ligne += substr_count($debut, "\n");   
    124                 $champ->ligne = $ligne;
    125                 $ligne += substr_count($match[0], "\n");
    126                 $texte = substr($texte,$p+strlen($match[0]));
    127                 // Stocker les arguments de la balise de traduction
    128                 $args=array();
    129                 $vals=preg_split('/,\s*/',$match[5]);
    130                 foreach ($vals as $val) {
    131                         $arg=preg_split('/\s*=/',$val);
    132                         if ($arg[0])
    133                           $args[$arg[0]]=phraser_champs($arg[1], 0, array());   
    134                 }
    135                 $champ->arg=$args;
    136                 $champ->nom_champ = strtolower($match[3]);
    137                 $champ->module = $match[2] ? $match[2] : MODULES_IDIOMES;
    138                 // pas d'imbrication pour les filtres sur langue
    139                 phraser_args(@$match[7], ":", '', array(), $champ);
    140                 $result[] = $champ;
    141         }
    142         if ($texte!=="")  $result = phraser_champs($texte,$ligne,$result);
    143         return $result;
    144 }
    145 
    146 // http://doc.spip.org/@phraser_champs
    147 function phraser_champs($texte,$ligne,$result) {
    148         while (preg_match("/".NOM_DE_CHAMP."/S", $texte, $match)) {
    149           $p = strpos($texte, $match[0]);
    150           $suite = substr($texte,$p+strlen($match[0]));
    151           if ($match[5] || (strpos($suite[0], "[0-9]") === false)) {
    152                 $debut = substr($texte, 0, $p);
    153                 if ($p) $result = phraser_polyglotte($debut, $ligne, $result);
    154                 $ligne += substr_count($debut, "\n");
    155                 $champ = new Champ;
    156                 $champ->ligne = $ligne;
    157                 $ligne += substr_count($match[0], "\n");
    158                 $champ->nom_boucle = $match[2];
    159                 $champ->nom_champ = $match[3];
    160                 $champ->etoile = $match[5];
    161 
    162                 if ($suite[0] == '{') {
    163                         phraser_arg($suite, '', array(), $champ);
    164                 // ce ltrim est une ereur de conception
    165                 // mais on le conserve par souci de compatibilite
    166                         $texte = ltrim($suite);
    167                 // Il faudrait le normaliser dans l'arbre de syntaxe abstraite
    168                 // pour faire sauter ce cas particulier a la decompilation.
    169                 /* Ce qui suit est malheureusement incomplet pour cela:
    170                         if ($n = (strlen($suite) - strlen($texte))) {
    171                                 $champ->apres = array(new Texte);
    172                                 $champ->apres[0]->texte = substr($suite,0,$n);
    173                         }
    174                 */
    175                 } else $texte = $suite;
    176                 phraser_vieux($champ);
    177                 $result[] = $champ;
    178           } else {
    179             // faux champ
    180             $result = phraser_polyglotte (substr($texte, 0, $p+1), $ligne, $result);
    181             $texte = (substr($texte, $p+1));
    182           }
    183         }
    184         if ($texte!=="") $result = phraser_polyglotte($texte, $ligne, $result);
    185         return $result;
    186 }
    187 
    188 // Gestion des imbrications:
    189 // on cherche les [..] les plus internes et on les remplace par une chaine
    190 // %###N@ ou N indexe un tableau comportant le resultat de leur analyse
    191 // on recommence tant qu'il y a des [...] en substituant a l'appel suivant
    192 
    193 // http://doc.spip.org/@phraser_champs_etendus
    194 function phraser_champs_etendus($texte, $ligne,$result) {
    195         if ($texte==="") return $result;
    196         $sep = '##';
    197         while (strpos($texte,$sep)!== false)
    198                 $sep .= '#';
    199         return array_merge($result, phraser_champs_interieurs($texte, $ligne, $sep, array()));
    200 }
    201 
    202 //  Analyse les filtres d'un champ etendu et affecte le resultat
    203 // renvoie la liste des lexemes d'origine augmentee
    204 // de ceux trouves dans les arguments des filtres (rare)
    205 // sert aussi aux arguments des includes et aux criteres de boucles
    206 // Tres chevelu
    207 
    208 // http://doc.spip.org/@phraser_args
    209 function phraser_args($texte, $fin, $sep, $result, &$pointeur_champ) {
    210   $texte = ltrim($texte);
    211   while (($texte!=="") && strpos($fin, $texte[0]) === false) {
    212         $result = phraser_arg($texte, $sep, $result, $pointeur_champ);
    213         $texte = ltrim($texte);
    214   }
    215 # mettre ici la suite du texte,
    216 # notamment pour que l'appelant vire le caractere fermant si besoin
    217   $pointeur_champ->apres = $texte;
    218   return $result;
    219 }
    220 
    221 // http://doc.spip.org/@phraser_arg
    222 function phraser_arg(&$texte, $sep, $result, &$pointeur_champ) {
    223         preg_match(",^(\|?[^}{)|]*)(.*)$,ms", $texte, $match);
    224         $suite = ltrim($match[2]);
    225         $fonc = trim($match[1]);
    226         if ($fonc && $fonc[0] == "|") $fonc = ltrim(substr($fonc,1));
    227         $res = array($fonc);
    228         $err_f = '';
    229         // cas du filtre sans argument ou du critere /
    230         if (($suite && ($suite[0] != '{')) || ($fonc  && $fonc[0] == '/')) {
    231                 // si pas d'argument, alors il faut une fonction ou un double |
    232                 if (!$match[1]) {
    233                         $err_f = array('zbug_erreur_filtre', array('filtre' => $texte));
    234                         erreur_squelette($err_f, $pointeur_champ);
    235                         $texte = '';
    236                 } else  $texte = $suite;
    237                 if ($err_f) $pointeur_champ->param = false;
    238                 elseif ($fonc!=='') $pointeur_champ->param[] = $res;
    239                 // pour les balises avec faux filtres qui boudent ce dur larbeur
    240                 $pointeur_champ->fonctions[] = array($fonc, '');
    241                 return $result;
    242         }
    243         $args = ltrim(substr($suite,1)); // virer le '(' initial
    244         $collecte = array();
    245         while ($args && $args[0] != '}') {
    246                 if ($args[0] == '"')
    247                         preg_match ('/^(")([^"]*)(")(.*)$/ms', $args, $regs);
    248                 else if ($args[0] == "'")
    249                         preg_match ("/^(')([^']*)(')(.*)$/ms", $args, $regs);
    250                 else {
    251                   preg_match("/^([[:space:]]*)([^,([{}]*([(\[{][^])}]*[])}])?[^,}]*)([,}].*)$/ms", $args, $regs);
    252                   if (!strlen($regs[2]))
    253                     {
    254                         $err_f = array('zbug_erreur_filtre', array('filtre' => $args));
    255                         erreur_squelette($err_f, $pointeur_champ);
    256                         $champ->apres = $champ->avant = $args = "";
    257                         break;
    258                       }   
    259                 }
    260                 $arg = $regs[2];
    261                 if (trim($regs[1])) {
    262                         $champ = new Texte;
    263                         $champ->texte = $arg;
    264                         $champ->apres = $champ->avant = $regs[1];
    265                         $result[] = $champ;
    266                         $collecte[] = $champ;
    267                         $args = ltrim($regs[count($regs)-1]);
    268                 } else {
    269                         if (!preg_match("/".NOM_DE_CHAMP ."([{|])/", $arg, $r)) {
    270                                 // 0 est un aveu d'impuissance. A completer
    271                                 $arg = phraser_champs_exterieurs($arg, 0, $sep, $result);
    272 
    273                                 $args = ltrim($regs[count($regs)-1]);
    274                                 $collecte = array_merge($collecte, $arg);
    275                                 $result = array_merge($result, $arg);
    276                         }
    277                         else {
    278                                 $n = strpos($args,$r[0]);
    279                                 $pred = substr($args, 0, $n);
    280                                 $par = ',}';
    281                                 if (preg_match('/^(.*)\($/', $pred, $m))
    282                                         {$pred = $m[1]; $par =')';}
    283                                 if ($pred) {
    284                                         $champ = new Texte;
    285                                         $champ->texte = $pred;
    286                                         $champ->apres = $champ->avant = "";
    287                                         $result[] = $champ;
    288                                         $collecte[] = $champ;
    289                                 }
    290                                 $rec = substr($args, $n + strlen($r[0]) -1);
    291                                 $champ = new Champ;
    292                                 $champ->nom_boucle = $r[2];
    293                                 $champ->nom_champ = $r[3];
    294                                 $champ->etoile = $r[5];
    295                                 $next = $r[6];
    296                                 while ($next=='{') {
    297                                         phraser_arg($rec, $sep, array(), $champ);
    298                                         $args = ltrim($rec) ;
    299                                         $next = $args[0];
    300                                 }
    301                                 while ($next=='|') {
    302                                         phraser_args($rec, $par, $sep, array(), $champ);
    303                                         $args = $champ->apres ;
    304                                         $champ->apres = '';
    305                                         $next = $args[0];
    306                                 }
    307                                 // Si erreur de syntaxe dans un sous-argument, propager.
    308                                 if ($champ->param === false)
    309                                         $err_f = true;
    310                                 else phraser_vieux($champ);
    311                                 if ($par==')') $args = substr($args,1);
    312                                 $collecte[] = $champ;
    313                                 $result[] = $champ;
    314                         }
    315                 }
    316                 if ($args[0] == ',') {
    317                         $args = ltrim(substr($args,1));
    318                         if ($collecte) {$res[] = $collecte; $collecte = array();}
    319                 }
    320         }
    321         if ($collecte) {$res[] = $collecte; $collecte = array();}
    322         $texte = substr($args,1);
    323         $source = substr($suite, 0, strlen($suite) - strlen($texte));
    324         // propager les erreurs, et ignorer les param vides
    325         if ($pointeur_champ->param !== false) {
    326                 if ($err_f)
    327                         $pointeur_champ->param = false;
    328                 elseif ($fonc!=='' || count($res) > 1)
    329                         $pointeur_champ->param[] = $res;
    330         }
    331         // pour les balises avec faux filtres qui boudent ce dur larbeur
    332         $pointeur_champ->fonctions[] = array($fonc, $source);
    333         return $result;
    334 }
    335 
    336 
    337 // http://doc.spip.org/@phraser_champs_exterieurs
    338 function phraser_champs_exterieurs($texte, $ligne, $sep, $nested) {
    339         $res = array();
    340         while (($p=strpos($texte, "%$sep"))!==false) {
    341                 if (!preg_match(',^%'.preg_quote($sep).'([0-9]+)@,', substr($texte,$p), $m))
    342                         break;
    343                 $debut = substr($texte,0,$p);
    344                 $texte = substr($texte, $p+strlen($m[0]));
    345                 if ($p)
    346                         $res = phraser_inclure($debut, $ligne, $res);
    347                 $ligne += substr_count($debut, "\n");
    348                 $res[]= $nested[$m[1]];
    349         }
    350         return (($texte==='') ? $res : phraser_inclure($texte, $ligne, $res));
    351 }
    352 
    353 // http://doc.spip.org/@phraser_champs_interieurs
    354 function phraser_champs_interieurs($texte, $ligne, $sep, $result) {
    355         $i = 0; // en fait count($result)
    356         $x = "";
    357 
    358         while (true) {
    359                 $j=$i;
    360                 $n = $ligne;
    361                 while (preg_match(CHAMP_ETENDU, $texte, $match)) {
    362                         $p = strpos($texte, $match[0]);
    363                         $debut = substr($texte, 0, $p);
    364                         if ($p) {
    365                                 $result[$i] = $debut;
    366                                 $i++;
    367                         }
    368                         $nom = $match[4];
    369                         $champ = new Champ;
    370                         // ca ne marche pas encore en cas de champ imbrique
    371                         $champ->ligne = $x ? 0 :($n+substr_count($debut, "\n"));
    372                         $champ->nom_boucle = $match[3];
    373                         $champ->nom_champ = $nom;
    374                         $champ->etoile = $match[6];
    375                         // phraser_args indiquera ou commence apres
    376                         $result = phraser_args($match[7], ")", $sep, $result, $champ);
    377                         phraser_vieux($champ);
    378                         $champ->avant =
    379                                 phraser_champs_exterieurs($match[1],$n,$sep,$result);
    380                         $debut = substr($champ->apres,1);
    381                         $n += substr_count(substr($texte, 0, strpos($texte, $debut)), "\n");
    382                         $champ->apres = phraser_champs_exterieurs($debut,$n,$sep,$result);
    383 
    384                         $result[$i] = $champ;
    385                         $i++;
    386                         $texte = substr($texte,$p+strlen($match[0]));
    387                 }
    388                 if ($texte!=="") {$result[$i] = $texte; $i++;}
    389                 $x ='';
    390 
    391                 while($j < $i) {
    392                         $z= $result[$j];
    393                         // j'aurais besoin de connaitre le nombre de lignes...
    394                         if (is_object($z))
    395                                 $x .= "%$sep$j@";
    396                         else
    397                                 $x.=$z;
    398                         $j++;
    399                 }
    400                 if (preg_match(CHAMP_ETENDU, $x))
    401                         $texte = $x;
    402                 else
    403                         return phraser_champs_exterieurs($x, $ligne, $sep, $result);
    404         }
    405 }
    406 
    407 function phraser_vieux(&$champ)
    408 {
    409         $nom = $champ->nom_champ;
    410         if ($nom == 'EMBED_DOCUMENT') {
    411                 include_spip('public/normaliser');
    412                 phraser_vieux_emb($champ);
    413         } elseif ($nom == 'EXPOSER') {
    414                 include_spip('public/normaliser');
    415                 phraser_vieux_exposer($champ);
    416         } elseif ($champ->param) {
    417                 if ($nom == 'FORMULAIRE_RECHERCHE') {
    418                         include_spip('public/normaliser');
    419                         phraser_vieux_recherche($champ);
    420                 } elseif (preg_match(",^LOGO_[A-Z]+,", $nom)) {
    421                         include_spip('public/normaliser');
    422                         phraser_vieux_logos($champ);
    423                 } elseif ($nom == 'MODELE') {
    424                         include_spip('public/normaliser');
    425                         phraser_vieux_modele($champ);
    426                 } elseif ($nom == 'INCLURE' OR $nom == 'INCLUDE') {
    427                         include_spip('public/normaliser');
    428                         phraser_vieux_inclu($champ);
    429                 }
    430         }
    431 }
    432 
    43320// analyse des criteres de boucle,
    43421
    43522// http://doc.spip.org/@phraser_criteres
    436 function phraser_criteres($params, &$result) {
     23function phraser_criteres_iterateurs($params, &$result) {
    43724
    43825        $err_ci = ''; // indiquera s'il y a eu une erreur
     
    581168}
    582169
    583 // http://doc.spip.org/@phraser_critere_infixe
    584 function phraser_critere_infixe($arg1, $arg2, $args, $op, $not, $cond)
    585 {
    586         $args[0] = new Texte;
    587         $args[0]->texte = $arg1;
    588         $args[0] = array($args[0]);
    589         $args[1][0] = new Texte;
    590         $args[1][0]->texte  = $arg2;
    591         $crit = new Critere;
    592         $crit->op = $op;
    593         $crit->not = $not;
    594         $crit->cond = $cond;
    595         $crit->param = $args;
    596         return $crit;
    597 }
    598 
    599 function public_phraser_html_dist($texte, $id_parent, &$boucles, $descr, $ligne=1) {
     170function public_phraser_html($texte, $id_parent, &$boucles, $descr, $ligne=1) {
    600171
    601172        $all_res = array();
     
    727298                        $err_b = true;
    728299                else {
    729                         phraser_criteres($result->param, $result);
     300                        phraser_criteres_iterateurs($result->param, $result);
    730301                        if (strncasecmp($soustype, TYPE_RECURSIF, strlen(TYPE_RECURSIF)) == 0) {
    731302                                $result->type_requete = TYPE_RECURSIF;
Note: See TracChangeset for help on using the changeset viewer.