www/ecrire/inc/lien.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('base/abstract_sql');
  16
  17 //
  18 // Production de la balise A+href a partir des raccourcis [xxx->url] etc.
  19 // Note : complique car c'est ici qu'on applique typo(),
  20 // et en plus on veut pouvoir les passer en pipeline
  21 //
  22
  23 // http://doc.spip.org/@traiter_raccourci_lien_lang
  24 function inc_lien_dist($lien, $texte='', $class='', $title='', $hlang='', $rel='', $connect='')
  25 {
  26         // Si une langue est demandee sur un raccourci d'article, chercher
  27         // la traduction ;
  28         // - [{en}->art2] => traduction anglaise de l'article 2, sinon art 2
  29         // - [{}->art2] => traduction en langue courante de l'art 2, sinon art 2
  30         if ($hlang
  31         AND $match = typer_raccourci($lien)) {
  32                 @list($type,,$id,,$args,,$ancre) = $match;
  33                 if ($id_trad = sql_getfetsel('id_trad', 'spip_articles', "id_article=$id")
  34                 AND $id_dest = sql_getfetsel('id_article', 'spip_articles',
  35                         "id_trad=$id_trad  AND statut<>'refuse' AND lang=" . sql_quote($hlang))
  36                 )
  37                         $lien = "$type$id_dest";
  38                 else
  39                         $hlang = '';
  40         }
  41
  42         $mode = ($texte AND $class) ? 'url' : 'tout';
  43         $lien = calculer_url($lien, $texte, $mode, $connect);
  44         if ($mode === 'tout') {
  45                 $texte = $lien['titre'];
  46                 if (!$class AND isset($lien['class'])) $class = $lien['class'];
  47                 $lang = isset($lien['lang']) ?$lien['lang'] : '';
  48                 $mime = isset($lien['mime']) ? " type='".$lien['mime']."'" : "";
  49                 $lien = $lien['url'];
  50         }
  51         if (substr($lien,0,1) == '#')  # ancres pures (internes a la page)
  52                 $class = 'spip_ancre';
  53         elseif (preg_match('/^\s*mailto:/',$lien)) # pseudo URL de mail
  54                 $class = "spip_mail";
  55         elseif (preg_match('/^<html>/',$texte)) # cf traiter_lien_explicite
  56                 $class = "spip_url spip_out";
  57         elseif (!$class) $class = "spip_out"; # si pas spip_in|spip_glossaire
  58
  59         // Si l'objet n'est pas de la langue courante, on ajoute hreflang
  60         if (!$hlang AND $lang!==$GLOBALS['spip_lang'])
  61                 $hlang = $lang;
  62
  63         $lang = ($hlang ? " hreflang='$hlang'" : '');
  64
  65         if ($title) $title = ' title="'.texte_backend($title).'"';
  66
  67         // rel=external pour les liens externes
  68         if (preg_match(',^https?://,S', $lien)
  69         AND false === strpos("$lien/", url_de_base()))
  70                 $rel = trim("$rel external");
  71         if ($rel) $rel = " rel='$rel'";
  72
  73         $lien = "<a href=\"".str_replace('"', '&quot;', $lien)."\" class='$class'$lang$title$rel$mime>$texte</a>";
  74
  75         # ceci s'execute heureusement avant les tableaux et leur "|".
  76         # Attention, le texte initial est deja echappe mais pas forcement
  77         # celui retourne par calculer_url.
  78         # Penser au cas [<imgXX|right>->URL], qui exige typo('<a>...</a>')
  79         return typo($lien, true, $connect);
  80 }
  81
  82 // Regexp des raccourcis, aussi utilisee pour la fusion de sauvegarde Spip
  83 // Laisser passer des paires de crochets pour la balise multi
  84 // mais refuser plus d'imbrications ou de mauvaises imbrications
  85 // sinon les crochets ne peuvent plus servir qu'a ce type de raccourci
  86 define('_RACCOURCI_LIEN', "/\[([^][]*?([[]\w*[]][^][]*)*)->(>?)([^]]*)\]/msS");
  87
  88 // http://doc.spip.org/@expanser_liens
  89 function expanser_liens($texte, $connect='')
  90 {
  91         $texte = pipeline('pre_liens', $texte);
  92         $sources = $inserts = $regs = array();
  93         if (preg_match_all(_RACCOURCI_LIEN, $texte, $regs, PREG_SET_ORDER)) {
  94                 $lien = charger_fonction('lien', 'inc');
  95                 foreach ($regs as $k => $reg) {
  96
  97                         $inserts[$k] = '@@SPIP_ECHAPPE_LIEN_' . $k . '@@';
  98                         $sources[$k] = $reg[0];
  99                         $texte = str_replace($sources[$k], $inserts[$k], $texte);
 100
 101                         list($titre, $bulle, $hlang) = traiter_raccourci_lien_atts($reg[1]);
 102                         $r = $reg[count($reg)-1];
 103                         // la mise en lien automatique est passee par la a tort !
 104                         // corrigeons pour eviter d'avoir un <a...> dans un href...
 105                         if (strncmp($r,'<a',2)==0){
 106                                 $href = extraire_attribut($r, 'href');
 107                                 // remplacons dans la source qui peut etre reinjectee dans les arguments
 108                                 // d'un modele
 109                                 $sources[$k] = str_replace($r,$href,$sources[$k]);
 110                                 // et prenons le href comme la vraie url a linker
 111                                 $r = $href;
 112                         }
 113                         $regs[$k] = $lien($r, $titre, '', $bulle, $hlang, '', $connect);
 114                 }
 115         }
 116
 117         // on passe a traiter_modeles la liste des liens reperes pour lui permettre
 118         // de remettre le texte d'origine dans les parametres du modele
 119         $texte = traiter_modeles($texte, false, false, $connect, array($inserts, $sources));
 120         $texte = corriger_typo($texte);
 121         $texte = str_replace($inserts, $regs, $texte);
 122         return $texte;
 123 }
 124
 125 // Meme analyse mais pour eliminer les liens
 126 // et ne laisser que leur titre, a expliciter si ce n'est fait
 127 // http://doc.spip.org/@nettoyer_raccourcis_typo
 128 function nettoyer_raccourcis_typo($texte, $connect='')
 129 {
 130         $texte = pipeline('nettoyer_raccourcis_typo',$texte);
 131
 132         if (preg_match_all(_RACCOURCI_LIEN, $texte, $regs, PREG_SET_ORDER))
 133                 foreach ($regs as $reg) {
 134                         list ($titre,,)= traiter_raccourci_lien_atts($reg[1]);
 135                         if (!$titre) {
 136                                 $match = typer_raccourci($reg[count($reg)-1]);
 137                                 @list($type,,$id,,,,) = $match;
 138                                 if ($type) {
 139                                         $url = generer_url_entite($id,$type,'','',true);
 140                                         if (is_array($url)) list($type, $id) = $url;
 141                                         $titre = traiter_raccourci_titre($id, $type, $connect);
 142                                 }
 143                                 $titre = $titre ? $titre['titre'] : $match[0];
 144                         }
 145                         $titre = corriger_typo(supprimer_tags($titre));
 146                         $texte = str_replace($reg[0], $titre, $texte);
 147                 }
 148
 149         // supprimer les notes
 150         $texte = preg_replace(",[[][[]([^]]|[]][^]])*[]][]],UimsS","",$texte);
 151
 152         // supprimer les codes typos
 153         $texte = str_replace(array('}','{'), '', $texte);
 154
 155         // supprimer les tableaux
 156         $texte = preg_replace(",(^|\r)\|.*\|\r,s", "\r", $texte);
 157
 158         return $texte;
 159 }
 160
 161
 162
 163 // Repere dans la partie texte d'un raccourci [texte->...]
 164 // la langue et la bulle eventuelles
 165
 166 define('_RACCOURCI_ATTRIBUTS', '/^(.*?)([|]([^<>]*?))?([{]([a-z_]*)[}])?$/');
 167
 168 // http://doc.spip.org/@traiter_raccourci_lien_atts
 169 function traiter_raccourci_lien_atts($texte) {
 170
 171         $bulle = $hlang = '';
 172         // title et hreflang donnes par le raccourci ?
 173         if (preg_match(_RACCOURCI_ATTRIBUTS, $texte, $m)) {
 174
 175                 $n =count($m);
 176                 // |infobulle ?
 177                 if ($n > 2) {
 178                         $bulle = $m[3];
 179                         // {hreflang} ?
 180                         if ($n > 4) {
 181                         // si c'est un code de langue connu, on met un hreflang
 182                                 if (traduire_nom_langue($m[5]) <> $m[5]) {
 183                                         $hlang = $m[5];
 184                                 } elseif (!$m[5]) {
 185                                         $hlang = test_espace_prive() ?
 186                                           $GLOBALS['lang_objet'] : $GLOBALS['spip_lang'];
 187                                 // sinon c'est un italique
 188                                 } else {
 189                                         $m[1] .= $m[4];
 190                                 }
 191
 192         // S'il n'y a pas de hreflang sous la forme {}, ce qui suit le |
 193         // est peut-etre une langue
 194                         } else if (preg_match('/^[a-z_]+$/', $m[3])) {
 195                         // si c'est un code de langue connu, on met un hreflang
 196                         // mais on laisse le title (c'est arbitraire tout ca...)
 197                                 if (traduire_nom_langue($m[3]) <> $m[3]) {
 198                                   $hlang = $m[3];
 199                                 }
 200                         }
 201                 }
 202                 $texte = $m[1];
 203         }
 204
 205         return array(trim($texte), $bulle, $hlang);
 206 }
 207
 208 define('_EXTRAIRE_DOMAINE', '/^(?:[^\W_]((?:[^\W_]|-){0,61}[^\W_,])?\.)+[a-z]{2,6}\b/Si');
 209
 210 // callback pour la fonction traiter_raccourci_liens()
 211 // http://doc.spip.org/@autoliens_callback
 212 function traiter_autoliens($r) {
 213         if (count($r)<2) return reset($r);
 214         list($tout, $l) = $r;
 215         if (!$l) return $tout;
 216         // reperer le protocole
 217         if (preg_match(',^(https?):/*,S', $l, $m)) {
 218                 $l = substr($l, strlen($m[0]));
 219                 $protocol = $m[1];
 220         } else  $protocol = 'http';
 221         // valider le nom de domaine
 222         if (!preg_match(_EXTRAIRE_DOMAINE, $l)) return $tout;
 223         // supprimer les ponctuations a la fin d'une URL
 224         preg_match('/^(.*?)([,.;?]?)$/', $l, $k);
 225         $url = $protocol.'://'.$k[1];
 226         $lien = charger_fonction('lien', 'inc');
 227         $r = $lien($url,'','','','','nofollow') . $k[2];
 228         // si l'original ne contenait pas le 'http:' on le supprime du clic
 229         return $m ? $r : str_replace('>http://', '>', $r);
 230 }
 231
 232 define('_EXTRAIRE_LIENS', ',' . '\[[^\[\]]*(?:<-|->).*?\]' . '|<a\b.*?</a\b' . '|<\w.*?>' . '|((?:https?:/|www\.)[^"\'\s\[\]\}\)<>]*)' .',imsS');
 233
 234 // Les URLs brutes sont converties en <a href='url'>url</a>
 235 // http://doc.spip.org/@traiter_raccourci_liens
 236 function traiter_raccourci_liens($t) {
 237         return preg_replace_callback(_EXTRAIRE_LIENS, 'traiter_autoliens', $t);
 238 }
 239
 240
 241 define('_RACCOURCI_CHAPO', '/^(\W*)(\W*)(\w*\d+([?#].*)?)$/');
 242 /**
 243  * Fonction pour les champs chapo commencant par =,  redirection qui peut etre:
 244  * 1. un raccourci Spip habituel (premier If) [texte->TYPEnnn]
 245  * 2. un ultra raccourci TYPEnnn voire nnn (article) (deuxieme If)
 246  * 3. une URL std
 247  *
 248  * renvoie l'url reelle de redirection si le $url=true,
 249  * l'url brute contenue dans le chapo sinon
 250  *
 251  * http://doc.spip.org/@chapo_redirige
 252  *
 253  * @param string $chapo
 254  * @param bool $url
 255  * @return string
 256  */
 257 function chapo_redirige($chapo, $url=false)
 258 {
 259         if (!preg_match(_RACCOURCI_LIEN, $chapo, $m))
 260                 if (!preg_match(_RACCOURCI_CHAPO, $chapo, $m))
 261                         return $chapo;
 262
 263         return !$url ? $m[3] : traiter_lien_implicite($m[3]);
 264 }
 265
 266 // Ne pas afficher le chapo si article virtuel
 267 // http://doc.spip.org/@nettoyer_chapo
 268 function nettoyer_chapo($chapo){
 269         return (substr($chapo,0,1) == "=") ? '' : $chapo;
 270 }
 271
 272 // http://doc.spip.org/@chapo_redirigetil
 273 function chapo_redirigetil($chapo) { return $chapo && $chapo[0] == '=';}
 274
 275 // Cherche un lien du type [->raccourci 123]
 276 // associe a une fonction generer_url_raccourci() definie explicitement
 277 // ou implicitement par le jeu de type_urls courant.
 278 //
 279 // Valeur retournee selon le parametre $pour:
 280 // 'tout' : tableau d'index url,class,titre,lang (vise <a href="U" class='C' hreflang='L'>T</a>)
 281 // 'titre': seulement T ci-dessus (i.e. le TITRE ci-dessus ou dans table SQL)
 282 // 'url':   seulement U  (i.e. generer_url_RACCOURCI)
 283
 284 // http://doc.spip.org/@calculer_url
 285 function calculer_url ($ref, $texte='', $pour='url', $connect='') {
 286         $r = traiter_lien_implicite($ref, $texte, $pour, $connect);
 287         return $r ? $r : traiter_lien_explicite($ref, $texte, $pour, $connect);
 288 }
 289
 290 define('_EXTRAIRE_LIEN', ",^\s*(http:?/?/?|mailto:?)\s*$,iS");
 291
 292 // http://doc.spip.org/@traiter_lien_explicite
 293 function traiter_lien_explicite ($ref, $texte='', $pour='url', $connect='')
 294 {
 295         if (preg_match(_EXTRAIRE_LIEN, $ref))
 296                 return ($pour != 'tout') ? '' : array('','','','');
 297
 298         $lien = entites_html(trim($ref));
 299
 300         // Liens explicites
 301         if (!$texte) {
 302                 $texte = str_replace('"', '', $lien);
 303                 // evite l'affichage de trops longues urls.
 304                 $lien_court = charger_fonction('lien_court', 'inc');
 305                 $texte = $lien_court($texte);
 306                 $texte = "<html>".quote_amp($texte)."</html>";
 307         }
 308
 309         // petites corrections d'URL
 310         if (preg_match('/^www\.[^@]+$/S',$lien))
 311                 $lien = "http://".$lien;
 312         else if (strpos($lien, "@") && email_valide($lien)) {
 313                 if (!$texte) $texte = $lien;
 314                 $lien = "mailto:".$lien;
 315         }
 316
 317         if ($pour == 'url') return $lien;
 318
 319         if ($pour == 'titre') return $texte;
 320
 321         return array('url' => $lien, 'titre' => $texte);
 322 }
 323
 324 // http://doc.spip.org/@traiter_lien_implicite
 325 function traiter_lien_implicite ($ref, $texte='', $pour='url', $connect='')
 326 {
 327         if (!($match = typer_raccourci($ref))) return false;
 328         @list($type,,$id,,$args,,$ancre) = $match;
 329 # attention dans le cas des sites le lien doit pointer non pas sur
 330 # la page locale du site, mais directement sur le site lui-meme
 331         if ($type == 'site')
 332                 $url = sql_getfetsel('url_site', 'spip_syndic', "id_syndic=$id",'','','','',$connect);
 333         elseif ($type == 'glose') {
 334                 if (function_exists($f = 'glossaire_' . $ancre))
 335                   $url = $f($texte, $id);
 336                 else $url = glossaire_std($texte);
 337         } else $url = generer_url_entite($id,$type,$args,$ancre,$connect ? $connect : NULL);
 338         if (!$url) return false;
 339         if (is_array($url)) {
 340                 @list($type,$id) = $url;
 341                 $url = generer_url_entite($id,$type,$args,$ancre,$connect ? $connect : NULL);
 342         }
 343         if ($pour === 'url') return $url;
 344         $r = traiter_raccourci_titre($id, $type, $connect);
 345         if ($r) $r['class'] =  ($type == 'site')?'spip_out':'spip_in';
 346         if ($texte = trim($texte)) $r['titre'] = $texte;
 347         if (!@$r['titre']) $r['titre'] =  _T($type) . " $id";
 348         if ($pour=='titre') return $r['titre'];
 349         $r['url'] = $url;
 350
 351         // dans le cas d'un lien vers un doc, ajouter le type='mime/type'
 352         if ($type == 'document'
 353         AND $mime = sql_getfetsel('mime_type', 'spip_types_documents',
 354                         "extension IN (SELECT extension FROM spip_documents where id_document =".sql_quote($id).")",
 355                         '','','','',$connect)
 356         )
 357                 $r['mime'] = $mime;
 358
 359         return $r;
 360 }
 361
 362 // analyse des raccourcis issus de [TITRE->RACCOURCInnn] et connexes
 363
 364 define('_RACCOURCI_URL', '/^\s*(\w*?)\s*(\d+)(\?(.*?))?(#([^\s]*))?\s*$/S');
 365
 366 // http://doc.spip.org/@typer_raccourci
 367 function typer_raccourci ($lien) {
 368         if (!preg_match(_RACCOURCI_URL, $lien, $match)) return array();
 369         $f = $match[1];
 370         // valeur par defaut et alias historiques
 371         if (!$f) $f = 'article';
 372         else if ($f == 'art') $f = 'article';
 373         else if ($f == 'br') $f = 'breve';
 374         else if ($f == 'rub') $f = 'rubrique';
 375         else if ($f == 'aut') $f = 'auteur';
 376         else if ($f == 'doc' OR $f == 'im' OR $f == 'img' OR $f == 'image' OR $f == 'emb')
 377                 $f = 'document';
 378         else if (preg_match('/^br..?ve$/S', $f)) $f = 'breve'; # accents :(
 379         $match[0] = $f;
 380         return $match;
 381 }
 382
 383 // Retourne le champ textuel associe a une cle primaire, et sa langue
 384 function traiter_raccourci_titre($id, $type, $connect=NULL)
 385 {
 386         $trouver_table = charger_fonction('trouver_table', 'base');
 387         $desc = $trouver_table(table_objet($type));
 388         if (!($desc AND $s = $desc['titre'])) return array();
 389         $_id = $desc['key']['PRIMARY KEY'];
 390         $r = sql_fetsel($s, $desc['table'], "$_id=$id", '','','','',$connect);
 391         if (!$r) return array();
 392         $r['titre'] = supprimer_numero($r['titre']);
 393         if (!$r['titre']) $r['titre'] = $r['surnom'];
 394         if (!isset($r['lang'])) $r['lang'] = '';
 395         return $r;
 396 }
 397
 398 // traite les modeles (dans la fonction typo), en remplacant
 399 // le raccourci <modeleN|parametres> par la page calculee a
 400 // partir du squelette modeles/modele.html
 401 // Le nom du modele doit faire au moins trois caracteres (evite <h2>)
 402 // Si $doublons==true, on repere les documents sans calculer les modeles
 403 // mais on renvoie les params (pour l'indexation par le moteur de recherche)
 404 // http://doc.spip.org/@traiter_modeles
 405
 406 define('_RACCOURCI_MODELE',
 407          '(<([a-z_-]{3,})' # <modele
 408         .'\s*([0-9]*)\s*' # id
 409         .'([|](?:<[^<>]*>|[^>])*?)?' # |arguments (y compris des tags <...>)
 410         .'\s*/?'.'>)' # fin du modele >
 411         .'\s*(<\/a>)?' # eventuel </a>
 412        );
 413
 414 define('_RACCOURCI_MODELE_DEBUT', '@^' . _RACCOURCI_MODELE .'@isS');
 415
 416 // http://doc.spip.org/@traiter_modeles
 417 function traiter_modeles($texte, $doublons=false, $echap='', $connect='', $liens = null) {
 418         // preserver la compatibilite : true = recherche des documents
 419         if ($doublons===true)
 420                 $doublons = array('documents'=>array('doc','emb','img'));
 421         // detecter les modeles (rapide)
 422         if (strpos($texte,"<")!==false AND
 423           preg_match_all('/<[a-z_-]{3,}\s*[0-9|]+/iS', $texte, $matches, PREG_SET_ORDER)) {
 424                 include_spip('public/assembler');
 425                 foreach ($matches as $match) {
 426                         // Recuperer l'appel complet (y compris un eventuel lien)
 427
 428                         $a = strpos($texte,$match[0]);
 429                         preg_match(_RACCOURCI_MODELE_DEBUT,
 430                         substr($texte, $a), $regs);
 431                         $regs[]=""; // s'assurer qu'il y a toujours un 5e arg, eventuellement vide
 432                         list(,$mod, $type, $id, $params, $fin) = $regs;
 433                         if ($fin AND
 434                         preg_match('/<a\s[^<>]*>\s*$/i',
 435                                         substr($texte, 0, $a), $r)) {
 436                                 $lien = array(
 437                                         'href' => extraire_attribut($r[0],'href'),
 438                                         'class' => extraire_attribut($r[0],'class'),
 439                                         'mime' => extraire_attribut($r[0],'type')
 440                                 );
 441                                 $n = strlen($r[0]);
 442                                 $a -= $n;
 443                                 $cherche = $n + strlen($regs[0]);
 444                         } else {
 445                                 $lien = false;
 446                                 $cherche = strlen($mod);
 447                         }
 448
 449                         // calculer le modele
 450                         # hack articles_edit, breves_edit, indexation
 451                         if ($doublons)
 452                                 $texte .= preg_replace(',[|][^|=]*,s',' ',$params);
 453                         # version normale
 454                         else {
 455                                 // si un tableau de liens a ete passe, reinjecter le contenu d'origine
 456                                 // dans les parametres, plutot que les liens echappes
 457                                 if (!is_null($liens))
 458                                         $params = str_replace($liens[0], $liens[1], $params);
 459                           $modele = inclure_modele($type, $id, $params, $lien, $connect);
 460                                 // en cas d'echec,
 461                                 // si l'objet demande a une url,
 462                                 // creer un petit encadre vers elle
 463                                 if ($modele === false) {
 464                                         if (!$lien)
 465                                                 $lien = traiter_lien_implicite("$type$id", '', 'tout', $connect);
 466                                         if ($lien)
 467                                                 $modele = '<a href="'
 468                                                   .$lien['url']
 469                                                   .'" class="spip_modele'
 470                                                   . '">'
 471                                                   .sinon($lien['titre'], _T('ecrire:info_sans_titre'))
 472                                                   ."</a>";
 473                                         else {
 474                                                 $modele = "";
 475                                                 if (test_espace_prive()) {
 476                                                         $modele = entites_html(substr($texte,$a,$cherche));
 477                                                         if (!is_null($liens))
 478                                                                 $modele = "<pre>".str_replace($liens[0], $liens[1], $modele)."</pre>";
 479                                                 }
 480                                         }
 481                                 }
 482                                 // le remplacer dans le texte
 483                                 if ($modele !== false) {
 484                                         $modele = protege_js_modeles($modele);
 485                                         $rempl = code_echappement($modele, $echap);
 486                                         $texte = substr($texte, 0, $a)
 487                                                 . $rempl
 488                                                 . substr($texte, $a+$cherche);
 489                                 }
 490                         }
 491
 492                         // hack pour tout l'espace prive
 493                         if (((!_DIR_RESTREINT) OR ($doublons)) AND ($id)){
 494                                 foreach($doublons?$doublons:array('documents'=>array('doc','emb','img')) as $quoi=>$modeles)
 495                                         if (in_array($type,$modeles))
 496                                                 $GLOBALS["doublons_{$quoi}_inclus"][] = $id;
 497                         }
 498                 }
 499         }
 500
 501         return $texte;
 502 }
 503
 504 //
 505 // Raccourcis ancre [#ancre<-]
 506 //
 507
 508 define('_RACCOURCI_ANCRE', "/\[#?([^][]*)<-\]/S");
 509
 510 // http://doc.spip.org/@traiter_raccourci_ancre
 511 function traiter_raccourci_ancre($letexte)
 512 {
 513         if (preg_match_all(_RACCOURCI_ANCRE, $letexte, $m, PREG_SET_ORDER))
 514         foreach ($m as $regs)
 515                 $letexte = str_replace($regs[0],
 516                 '<a name="'.entites_html($regs[1]).'"></a>', $letexte);
 517         return $letexte;
 518 }
 519
 520 //
 521 // Raccourcis automatiques [?SPIP] vers un glossaire
 522 // Wikipedia par defaut, avec ses contraintes techniques
 523 // cf. http://fr.wikipedia.org/wiki/Wikip%C3%A9dia:Conventions_sur_les_titres
 524
 525 define('_RACCOURCI_GLOSSAIRE', "/\[\?+\s*([^][<>]+)\]/S");
 526 define('_RACCOURCI_GLOSES', '/^([^|#{]*\w[^|#{]*)([^#]*)(#([^|{}]*))?(.*)$/S');
 527
 528 // http://doc.spip.org/@traiter_raccourci_glossaire
 529 function traiter_raccourci_glossaire($texte)
 530 {
 531         if (!preg_match_all(_RACCOURCI_GLOSSAIRE,
 532         $texte, $matches, PREG_SET_ORDER))
 533                 return $texte;
 534
 535         include_spip('inc/charsets');
 536         $lien = charger_fonction('lien', 'inc');
 537
 538         foreach ($matches as $regs) {
 539         // Eviter les cas particulier genre "[?!?]"
 540         // et isoler le lexeme a gloser de ses accessoires
 541         // (#:url du glossaire, | bulle d'aide, {} hreflang)
 542         // Transformation en pseudo-raccourci pour passer dans inc_lien
 543                 if (preg_match(_RACCOURCI_GLOSES, $regs[1], $r)) {
 544                         preg_match('/^(.*?)(\d*)$/', $r[4], $m);
 545                         $_n = intval($m[2]);
 546                         $gloss = $m[1] ? ('#' . $m[1]) : '';
 547                         $t = $r[1] . $r[2] . $r[5];
 548                         list($t, $bulle, $hlang) = traiter_raccourci_lien_atts($t);
 549                         $t = unicode2charset(charset2unicode($t), 'utf-8');
 550                         $ref = $lien("glose$_n$gloss", $t, 'spip_glossaire', $bulle, $hlang);
 551                         $texte = str_replace($regs[0], $ref, $texte);
 552                 }
 553         }
 554         return $texte;
 555 }
 556
 557 // http://doc.spip.org/@glossaire_std
 558 function glossaire_std($terme)
 559 {
 560         global $url_glossaire_externe;
 561         static $pcre = NULL;
 562
 563         if ($pcre === NULL) {
 564                 $pcre = isset($GLOBALS['meta']['pcre_u'])
 565                 ? $GLOBALS['meta']['pcre_u']
 566                   : '';
 567                 if (strpos($url_glossaire_externe, "%s") === false)
 568                         $url_glossaire_externe .= '%s';
 569         }
 570
 571         $glosateur = str_replace("@lang@",
 572                                 $GLOBALS['spip_lang'],
 573                                 $GLOBALS['url_glossaire_externe']);
 574
 575         $terme = rawurlencode(preg_replace(',\s+,'.$pcre, '_', $terme));
 576
 577         return  str_replace("%s", $terme, $glosateur);
 578 }
 579
 580 ?>