www/ecrire/xml/analyser_dtd.php

   1 <?php
   2
   3 /***************************************************************************\
   4  *  SPIP, Systeme de publication pour l'internet                           *
   5  *                                                                         *
   6  *  Copyright (c) 2001-2014                                                *
   7  *  Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James  *
   8  *                                                                         *
   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 \***************************************************************************/
  12
  13 if (!defined('_ECRIRE_INC_VERSION')) return;
  14
  15 include_spip('xml/interfaces');
  16
  17 // http://doc.spip.org/@charger_dtd
  18 function charger_dtd($grammaire, $avail, $rotlvl)
  19 {
  20         static $dtd = array(); # cache bien utile pour le validateur en boucle
  21
  22         if (isset($dtd[$grammaire]))
  23                 return $dtd[$grammaire];
  24
  25         if ($avail == 'SYSTEM') {
  26                 $grammaire = find_in_path($grammaire);
  27         }
  28         if (!$grammaire) return $dtd[''] = array();
  29
  30         $file = _DIR_CACHE_XML . preg_replace('/[^\w.]/','_', $rotlvl) . '.gz';
  31
  32         if (lire_fichier($file, $r)) {
  33                 if (($avail == 'SYSTEM') AND filemtime($file) < filemtime($grammaire))
  34                                 $r = false;
  35         }
  36
  37         if ($r) {
  38                 $dtc = unserialize($r);
  39         } else {
  40                 spip_timer('dtd');
  41                 $dtc = new DTC;
  42                 // L'analyseur retourne un booleen de reussite et modifie $dtc.
  43                 // Retourner vide en cas d'echec
  44                 if (!analyser_dtd($grammaire, $avail, $dtc))
  45                         $dtc = array();
  46                 else {
  47                 // tri final pour presenter les suggestions de corrections
  48                         foreach ($dtc->peres as $k => $v) {
  49                                 asort($v);
  50                                 $dtc->peres[$k] = $v;
  51                         }
  52
  53                         spip_log("Analyser DTD $avail $grammaire (" . spip_timer('dtd') . ") " . count($dtc->macros)  . ' macros, ' . count($dtc->elements)  . ' elements, ' . count($dtc->attributs) . " listes d'attributs, " . count($dtc->entites) . " entites");
  54                         #       $r = $dtc->regles; ksort($r);foreach($r as $l => $v) {$t=array_keys($dtc->attributs[$l]);echo "<b>$l</b> '$v' ", count($t), " attributs: ", join (', ',$t);$t=$dtc->peres[$l];echo "<br />",count($t), " peres: ", @join (', ',$t), "<br />\n";}exit;
  55                         ecrire_fichier($file, serialize($dtc), true);
  56                 }
  57
  58         }
  59         $dtd[$grammaire] = $dtc;
  60         return $dtc;
  61 }
  62
  63 // Compiler une regle de production en une Regexp qu'on appliquera sur la
  64 // suite des noms de balises separes par des espaces. Du coup:
  65 // supprimer #PCDATA etc, ca ne sert pas pour le controle des balises;
  66 // supprimer les virgules (les sequences sont implicites dans une Regexp)
  67 // conserver | + * ? ( ) qui ont la meme signification en DTD et en Regexp;
  68 // faire suivre chaque nom d'un espace (et supprimer les autres) ...
  69 // et parentheser le tout pour que  | + * ? s'applique dessus.
  70
  71 // http://doc.spip.org/@compilerRegle
  72 function compilerRegle($val)
  73 {
  74         $x = str_replace('()','',
  75                 preg_replace('/\s*,\s*/','',
  76                 preg_replace('/(\w+)\s*/','(\1 )',
  77                 preg_replace('/\s*\)/',')',
  78                 preg_replace('/\s*([(+*|?])\s*/','\1',
  79                 preg_replace('/\s*#\w+\s*[,|]?\s*/','', $val))))));
  80         return $x;
  81 }
  82
  83
  84 // http://doc.spip.org/@analyser_dtd
  85 function analyser_dtd($loc, $avail, &$dtc)
  86 {
  87         // creer le repertoire de cache si ce n'est fait
  88         // (utile aussi pour le resultat de la compil)
  89         $file = sous_repertoire(_DIR_CACHE_XML);
  90         // si DTD locale, ignorer ce repertoire pour le moment
  91         if ($avail == 'SYSTEM')
  92           $file = find_in_path($loc);
  93         else {
  94           $file .= preg_replace('/[^\w.]/','_', $loc);
  95         }
  96
  97         $dtd = '';
  98         if (@is_readable($file)) {
  99                 lire_fichier($file, $dtd);
 100         } else {
 101                 if ($avail == 'PUBLIC') {
 102                         include_spip('inc/distant');
 103                         if ($dtd = trim(recuperer_page($loc)))
 104                                 ecrire_fichier($file, $dtd, true);
 105                 }
 106         }
 107
 108         $dtd = ltrim($dtd);
 109         if (!$dtd) {
 110                 spip_log("DTD '$loc' ($file) inaccessible");
 111                 return false;
 112         } else  spip_log("analyse de la DTD $loc ");
 113
 114         while ($dtd) {
 115                 if ($dtd[0] != '<')
 116                         $r = analyser_dtd_lexeme($dtd, $dtc, $loc);
 117                 elseif ($dtd[1] != '!')
 118                         $r = analyser_dtd_pi($dtd, $dtc, $loc);
 119                 elseif ($dtd[2] == '[')
 120                         $r = analyser_dtd_data($dtd, $dtc, $loc);
 121                 else {
 122                         switch ($dtd[3]) {
 123           case '%' : $r = analyser_dtd_data($dtd, $dtc, $loc); break;
 124           case 'T' : $r = analyser_dtd_attlist($dtd, $dtc, $loc);break;
 125           case 'L' : $r = analyser_dtd_element($dtd, $dtc, $loc);break;
 126           case 'N' : $r = analyser_dtd_entity($dtd, $dtc, $loc);break;
 127           case 'O' : $r = analyser_dtd_notation($dtd, $dtc, $loc);break;
 128           case '-' : $r = analyser_dtd_comment($dtd, $dtc, $loc); break;
 129           default: $r = -1;
 130                         }
 131                   }
 132                 if (!is_string($r)) {
 133                         spip_log("erreur $r dans la DTD  " . substr($dtd,0,80) . ".....");
 134                         return false;
 135                 }
 136                 $dtd = $r;
 137         }
 138         return true;
 139 }
 140
 141 // http://doc.spip.org/@analyser_dtd_comment
 142 function analyser_dtd_comment($dtd, &$dtc, $grammaire){
 143         // ejecter les commentaires, surtout quand ils contiennent du code.
 144         // Option /s car sur plusieurs lignes parfois
 145
 146         if (!preg_match('/^<!--.*?-->\s*(.*)$/s',$dtd, $m))
 147                 return -6;
 148         return $m[1];
 149 }
 150
 151 // http://doc.spip.org/@analyser_dtd_pi
 152 function analyser_dtd_pi($dtd, &$dtc, $grammaire){
 153         if (!preg_match('/^<\?.*?>\s*(.*)$/s', $dtd, $m))
 154                 return -10;
 155         return $m[1];
 156 }
 157
 158 // http://doc.spip.org/@analyser_dtd_lexeme
 159 function analyser_dtd_lexeme($dtd, &$dtc, $grammaire){
 160
 161         if (!preg_match(_REGEXP_ENTITY_DEF,$dtd, $m))
 162                 return -9;
 163
 164         list(,$s) = $m;
 165         $n = $dtc->macros[$s];
 166
 167         if (is_array($n)) {
 168             // en cas d'inclusion, l'espace de nom est le meme
 169           // mais gaffe aux DTD dont l'URL est relative a l'engloblante
 170                 if (($n[0] == 'PUBLIC')
 171                 AND !preg_match("%^http://%", $n[1])) {
 172                         $n[1] = substr($grammaire,0, strrpos($grammaire,'/')+1) . $n[1];
 173                 }
 174                 analyser_dtd($n[1], $n[0], $dtc);
 175         }
 176
 177         return ltrim(substr($dtd,strlen($m[0])));
 178 }
 179
 180 // il faudrait gerer plus proprement les niveaux d'inclusion:
 181 // ca ne depasse pas 3 ici.
 182
 183 // http://doc.spip.org/@analyser_dtd_data
 184 function analyser_dtd_data($dtd, &$dtc, $grammaire){
 185
 186         if (!preg_match(_REGEXP_INCLUDE_USE,$dtd,$m))
 187                 return -11;
 188         if (!preg_match('/^((\s*<!(\[\s*%\s*[^;]*;\s*\[([^]<]*<[^>]*>)*[^]<]*\]\]>)|([^]>]*>))*[^]<]*)\]\]>\s*/s',$m[2], $r))
 189           return -12;
 190
 191         if ($dtc->macros[$m[1]] == 'INCLUDE')
 192           $retour = $r[1] . substr($m[2], strlen($r[0]));
 193         else $retour = substr($m[2], strlen($r[0]));
 194
 195         return $retour;
 196 }
 197
 198 // http://doc.spip.org/@analyser_dtd_notation
 199 function analyser_dtd_notation($dtd, &$dtc, $grammaire){
 200         if (!preg_match('/^<!NOTATION.*?>\s*(.*)$/s',$dtd, $m))
 201                 return -8;
 202         spip_log("analyser_dtd_notation a ecrire");
 203         return $m[1];
 204 }
 205
 206 // http://doc.spip.org/@analyser_dtd_entity
 207 function analyser_dtd_entity($dtd, &$dtc, $grammaire)
 208 {
 209         if (!preg_match(_REGEXP_ENTITY_DECL, $dtd, $m))
 210                 return -2;
 211
 212         list($t, $term, $nom, $type, $k1,$k2,$k3,$k4,$k5,$k6, $c, $q, $alt, $dtd) = $m;
 213
 214         if (isset($dtc->macros[$nom]) AND $dtc->macros[$nom])
 215                 return $dtd;
 216         if (isset($dtc->entites[$nom]))
 217                 spip_log("redefinition de l'entite $nom");
 218         if ($k6) return $k6 . $dtd; // cas du synonyme complet
 219         $val = expanserEntite(($k2 ? $k3 : ($k4 ? $k5 : $k6)), $dtc->macros);
 220
 221         // cas particulier double evaluation: 'PUBLIC "..." "...."'
 222         if (preg_match('/(PUBLIC|SYSTEM)\s+"([^"]*)"\s*("([^"]*)")?\s*$/s',$val,$r)) {
 223                 list($t, $type, $val, $q, $alt) = $r;
 224         }
 225
 226         if  (!$term)
 227                 $dtc->entites[$nom] = $val;
 228         elseif (!$type)
 229           $dtc->macros[$nom] = $val;
 230         else {
 231                 if (($type == 'SYSTEM') AND !$alt) $alt = $val;
 232                 if (!$alt)
 233                         $dtc->macros[$nom] = $val;
 234                 else {
 235                         if (($type == 'PUBLIC')
 236                         AND (strpos($alt, '/') === false))
 237                                 $alt = preg_replace(',/[^/]+$,', '/', $grammaire)
 238                                 . $alt ;
 239                         $dtc->macros[$nom] = array($type, $alt);
 240                 }
 241         }
 242
 243         return $dtd;
 244 }
 245
 246 // Dresser le tableau des filles potentielles de l'element
 247 // pour traquer tres vite les illegitimes.
 248 // Si la regle a au moins une sequence (i.e. une virgule)
 249 // ou n'est pas une itération (i.e. se termine par * ou +)
 250 // en faire une RegExp qu'on appliquera aux balises rencontrees.
 251 // Sinon, conserver seulement le type de l'iteration car la traque
 252 // aura fait l'essentiel du controle sans memorisation des balises.
 253 // Fin du controle en finElement
 254
 255 // http://doc.spip.org/@analyser_dtd_element
 256 function analyser_dtd_element($dtd, &$dtc, $grammaire)
 257 {
 258         if (!preg_match('/^<!ELEMENT\s+([^>\s]+)([^>]*)>\s*(.*)$/s', $dtd, $m))
 259                 return -3;
 260
 261         list(,$nom, $contenu, $dtd) = $m;
 262         $nom = expanserEntite($nom, $dtc->macros);
 263
 264         if (isset($dtc->elements[$nom])) {
 265                 spip_log("redefinition de l'element $nom dans la DTD");
 266                 return -4;
 267         }
 268         $filles = array();
 269         $contenu = expanserEntite($contenu, $dtc->macros);
 270         $val = $contenu ? compilerRegle($contenu) : '(EMPTY )';
 271         if ($val == '(EMPTY )')
 272                 $dtc->regles[$nom] = 'EMPTY';
 273         elseif  ($val == '(ANY )')
 274                 $dtc->regles[$nom] = 'ANY';
 275         else {
 276                 $last = substr($val,-1);
 277                 if (preg_match('/ \w/', $val)
 278                 OR strpos('*+', $last) === false)
 279                         $dtc->regles[$nom] = "/^$val$/";
 280                 else
 281                         $dtc->regles[$nom] = $last;
 282                         $filles = array_values(preg_split('/\W+/', $val,-1, PREG_SPLIT_NO_EMPTY));
 283
 284                         foreach ($filles as $k) {
 285                                 if (!isset($dtc->peres[$k]))
 286                                   $dtc->peres[$k] = array();
 287                                 if (!in_array($nom, $dtc->peres[$k]))
 288                                         $dtc->peres[$k][]= $nom;
 289                         }
 290         }
 291         $dtc->pcdata[$nom]= (strpos($contenu, '#PCDATA')===false);
 292         $dtc->elements[$nom]= $filles;
 293         return $dtd;
 294 }
 295
 296
 297 // http://doc.spip.org/@analyser_dtd_attlist
 298 function analyser_dtd_attlist($dtd, &$dtc, $grammaire)
 299 {
 300         if (!preg_match('/^<!ATTLIST\s+(\S+)\s+([^>]*)>\s*(.*)/s', $dtd, $m))
 301                 return -5;
 302
 303         list(,$nom, $val, $dtd) = $m;
 304         $nom = expanserEntite($nom, $dtc->macros);
 305         $val = expanserEntite($val, $dtc->macros);
 306         if (!isset($dtc->attributs[$nom]))
 307                 $dtc->attributs[$nom] = array();
 308
 309         if (preg_match_all("/\s*(\S+)\s+(([(][^)]*[)])|(\S+))\s+([^\s']*)(\s*'[^']*')?/", $val, $r2, PREG_SET_ORDER)) {
 310                 foreach($r2 as $m2) {
 311                         $v = preg_match('/^\w+$/', $m2[2]) ? $m2[2]
 312                           : ('/^' . preg_replace('/\s+/', '', $m2[2]) . '$/');
 313                         $m21 = expanserEntite($m2[1], $dtc->macros);
 314                         $m25 = expanserEntite($m2[5], $dtc->macros);
 315                         $dtc->attributs[$nom][$m21] = array($v, $m25);
 316                 }
 317         }
 318
 319         return $dtd;
 320 }
 321
 322
 323 // Remplace dans la chaine $val les sous-chaines de forme "%NOM;"
 324 // par leur definition dans le tableau $macros
 325 // Si le premier argument n'est pas une chaine,
 326 // retourne les statistiques (pour debug de DTD, inutilise en mode normal)
 327
 328 // http://doc.spip.org/@expanserEntite
 329 function expanserEntite($val, $macros=array())
 330 {
 331         static $vu = array();
 332         if (!is_string($val)) return $vu;
 333
 334         if (preg_match_all(_REGEXP_ENTITY_USE, $val, $r, PREG_SET_ORDER)){
 335           foreach($r as $m) {
 336                 $ent = $m[1];
 337                   // il peut valoir ""
 338                 if (!isset($macros[$ent]))
 339                         spip_log("Entite $ent inconnu");
 340                 else {
 341                         @$vu[$ent]++;
 342                         $val = str_replace($m[0], $macros[$ent], $val);
 343                 }
 344           }
 345         }
 346
 347         return trim(preg_replace('/\s+/', ' ', $val));
 348 }
 349 ?>