www/ecrire/xml/analyser_dtd.php

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