X-Git-Url: http://git.cyclocoop.org/?p=velocampus%2Fweb%2Fwww.git;a=blobdiff_plain;f=www%2Fecrire%2Finc%2Ftexte.php;fp=www%2Fecrire%2Finc%2Ftexte.php;h=148c5720b927f8000c779817404789de63a4cfa5;hp=0000000000000000000000000000000000000000;hb=80b4d3e85f78d402ed2e73f8f5d1bf4c19962eed;hpb=aaf970bf4cdaf76689ecc10609048e18d073820c diff --git a/www/ecrire/inc/texte.php b/www/ecrire/inc/texte.php new file mode 100644 index 0000000..148c572 --- /dev/null +++ b/www/ecrire/inc/texte.php @@ -0,0 +1,985 @@ +)?/S", + /* 7 */ "/[{][{]/S", + /* 8 */ "/[}][}]/S", + /* 9 */ "/[{]/S", + /* 10 */ "/[}]/S", + /* 11 */ "/(?:){2,}/S", + /* 12 */ "/

\n*(?:\n*)*/S", + /* 13 */ "//S", + /* 14 */ "/<\/quote>/S", + /* 15 */ "/<\/?intro>/S" + ), + array( + /* 4 */ "\$1\n\n" . $debut_intertitre, + /* 5 */ $fin_intertitre ."\n\n\$1", + /* 6 */ "

", + /* 7 */ $debut_gras, + /* 8 */ $fin_gras, + /* 9 */ $debut_italique, + /* 10 */ $fin_italique, + /* 11 */ "

", + /* 12 */ "

", + /* 13 */ "

", + /* 14 */ "

", + /* 15 */ "" + ) +); + +// Raccourcis dependant du sens de la langue + +function definir_raccourcis_alineas() +{ + global $ligne_horizontale; + static $alineas = array(); + $x = _DIR_RESTREINT ? lang_dir() : lang_dir($GLOBALS['spip_lang']); + if (!isset($alineas[$x])) { + + $alineas[$x] = array( + array( + /* 0 */ "/\n(----+|____+)/S", + /* 1 */ "/\n-- */S", + /* 2 */ "/\n- */S", /* DOIT rester a cette position */ + /* 3 */ "/\n_ +/S" + ), + array( + /* 0 */ "\n\n" . $ligne_horizontale . "\n\n", + /* 1 */ "\n
— ", + /* 2 */ "\n
".definir_puce()." ", + /* 3 */ "\n
" + ) + ); + } + return $alineas[$x]; +} + +// On initialise la puce pour eviter find_in_path() a chaque rencontre de \n- +// Mais attention elle depend de la direction et de X_fonctions.php, ainsi que +// de l'espace choisi (public/prive) +// http://doc.spip.org/@definir_puce +function definir_puce() { + + // Attention au sens, qui n'est pas defini de la meme facon dans + // l'espace prive (spip_lang est la langue de l'interface, lang_dir + // celle du texte) et public (spip_lang est la langue du texte) + $dir = _DIR_RESTREINT ? lang_dir() : lang_dir($GLOBALS['spip_lang']); + + $p = 'puce' . (test_espace_prive() ? '_prive' : ''); + if ($dir == 'rtl') $p .= '_rtl'; + + if (!isset($GLOBALS[$p])) { + $img = find_in_path($p.'.gif'); + list(,,,$size) = @getimagesize($img); + $GLOBALS[$p] = '-'; + } + return $GLOBALS[$p]; +} + +// XHTML - Preserver les balises-bloc : on liste ici tous les elements +// dont on souhaite qu'ils provoquent un saut de paragraphe +if (!defined('_BALISES_BLOCS')) define('_BALISES_BLOCS', + 'div|pre|ul|ol|li|blockquote|h[1-6r]|' + .'t(able|[rdh]|body|foot|extarea)|' + .'form|object|center|marquee|address|' + .'d[ltd]|script|noscript|map|button|fieldset|style'); + +// +// Echapper les elements perilleux en les passant en base64 +// + +// Creer un bloc base64 correspondant a $rempl ; au besoin en marquant +// une $source differente ; le script detecte automagiquement si ce qu'on +// echappe est un div ou un span +// http://doc.spip.org/@code_echappement +function code_echappement($rempl, $source='', $no_transform=false) { + if (!strlen($rempl)) return ''; + + // Tester si on echappe en span ou en div + $mode = preg_match(',[:space:]],iS', $rempl) ? + 'div' : 'span'; + $return = ''; + + // Decouper en morceaux, base64 a des probleme selon la taille de la pile + $taille = 30000; + for($i = 0; $i < strlen($rempl); $i += $taille) { + // Convertir en base64 et cacher dans un attribut + // utiliser les " pour eviter le re-encodage de ' et ’ + $base64 = base64_encode(substr($rempl, $i, $taille)); + $return .= "<$mode class=\"base64$source\" title=\"$base64\">"; + } + + return $return + . ((!$no_transform AND $mode == 'div') + ? "\n\n" + : '' + ); +; +} + +// Echapper les ... +// http://doc.spip.org/@traiter_echap_html_dist +function traiter_echap_html_dist($regs) { + return $regs[3]; +} + +// Echapper les ... +// http://doc.spip.org/@traiter_echap_code_dist +function traiter_echap_code_dist($regs) { + list(,,$att,$corps) = $regs; + $echap = htmlspecialchars($corps); // il ne faut pas passer dans entites_html, ne pas transformer les &#xxx; du code ! + + // ne pas mettre le s'il n'y a qu'une ligne + if (is_int(strpos($echap,"\n"))) { + // supprimer les sauts de ligne debut/fin + // (mais pas les espaces => ascii art). + $echap = preg_replace("/^[\n\r]+|[\n\r]+$/s", "", $echap); + $echap = nl2br($echap); + $echap = "

" + .$echap."
"; + } else { + $echap = "".$echap.""; + } + + $echap = str_replace("\t", "        ", $echap); + $echap = str_replace(" ", "  ", $echap); + return $echap; +} + +// Echapper les ... aka ... +// http://doc.spip.org/@traiter_echap_cadre_dist +function traiter_echap_cadre_dist($regs) { + $echap = trim(entites_html($regs[3])); + // compter les lignes un peu plus finement qu'avec les \n + $lignes = explode("\n",trim($echap)); + $n = 0; + foreach($lignes as $l) + $n+=floor(strlen($l)/60)+1; + $n = max($n,2); + $echap = "\n"; + return generer_form_ecrire('', $echap, " method='get'"); +} +// http://doc.spip.org/@traiter_echap_frame_dist +function traiter_echap_frame_dist($regs) { + return traiter_echap_cadre_dist($regs); +} + +// http://doc.spip.org/@traiter_echap_script_dist +function traiter_echap_script_dist($regs) { + // rendre joli (et inactif) si c'est un script language=php + if (preg_match(',]+php,ims', $regs[0])) + return highlight_string($regs[0],true); + + // Cas normal : le script passe tel quel + return $regs[0]; +} + +define('_PROTEGE_BLOCS', ',<(html|code|cadre|frame|script)(\s[^>]*)?>(.*),UimsS'); + +// - pour $source voir commentaire infra (echappe_retour) +// - pour $no_transform voir le filtre post_autobr dans inc/filtres +// http://doc.spip.org/@echappe_html +function echappe_html($letexte, $source='', $no_transform=false, +$preg='') { + if (!is_string($letexte) or !strlen($letexte)) + return $letexte; + + if (($preg OR strpos($letexte,"<")!==false) + AND preg_match_all($preg ? $preg : _PROTEGE_BLOCS, $letexte, $matches, PREG_SET_ORDER)) + foreach ($matches as $regs) { + // echappements tels quels ? + if ($no_transform) { + $echap = $regs[0]; + } + + // sinon les traiter selon le cas + else if (function_exists($f = 'traiter_echap_'.strtolower($regs[1]))) + $echap = $f($regs); + else if (function_exists($f = $f.'_dist')) + $echap = $f($regs); + + $letexte = str_replace($regs[0], + code_echappement($echap, $source, $no_transform), + $letexte); + } + + if ($no_transform) + return $letexte; + + // Gestion du TeX + if (strpos($letexte, "") !== false) { + include_spip('inc/math'); + $letexte = traiter_math($letexte, $source); + } + + // Echapper le php pour faire joli (ici, c'est pas pour la securite) + if (strpos($letexte,"<"."?")!==false AND preg_match_all(',<[?].*($|[?]>),UisS', + $letexte, $matches, PREG_SET_ORDER)) + foreach ($matches as $regs) { + $letexte = str_replace($regs[0], + code_echappement(highlight_string($regs[0],true), $source), + $letexte); + } + + return $letexte; +} + +// +// Traitement final des echappements +// Rq: $source sert a faire des echappements "a soi" qui ne sont pas nettoyes +// par propre() : exemple dans multi et dans typo() +// http://doc.spip.org/@echappe_retour +function echappe_retour($letexte, $source='', $filtre = "") { + if (strpos($letexte,"base64$source")) { + # spip_log(htmlspecialchars($letexte)); ## pour les curieux + if (strpos($letexte,"<")!==false AND + preg_match_all(',<(span|div) class=[\'"]base64'.$source.'[\'"]\s(.*)>\s*,UmsS', + $letexte, $regs, PREG_SET_ORDER)) { + foreach ($regs as $reg) { + $rempl = base64_decode(extraire_attribut($reg[0], 'title')); + // recherche d'attributs supplementaires + $at = array(); + foreach(array('lang', 'dir') as $attr) { + if ($a = extraire_attribut($reg[0], $attr)) + $at[$attr] = $a; + } + if ($at) { + $rempl = '<'.$reg[1].'>'.$rempl.''; + foreach($at as $attr => $a) + $rempl = inserer_attribut($rempl, $attr, $a); + } + if ($filtre) $rempl = $filtre($rempl); + $letexte = str_replace($reg[0], $rempl, $letexte); + } + } + } + return $letexte; +} + +// Reinserer le javascript de confiance (venant des modeles) + +// http://doc.spip.org/@echappe_retour_modeles +function echappe_retour_modeles($letexte, $interdire_scripts=false) +{ + $letexte = echappe_retour($letexte); + + // Dans les appels directs hors squelette, securiser aussi ici + if ($interdire_scripts) + $letexte = interdire_scripts($letexte,true); + + return trim($letexte); +} + + +// http://doc.spip.org/@couper +function couper($texte, $taille=50, $suite = ' (...)') { + if (!($length=strlen($texte)) OR $taille <= 0) return ''; + $offset = 400 + 2*$taille; + while ($offset<$length + AND strlen(preg_replace(",<[^>]+>,Uims","",substr($texte,0,$offset)))<$taille) + $offset = 2*$offset; + if ( $offset<$length + && ($p_tag_ouvrant = strpos($texte,'<',$offset))!==NULL){ + $p_tag_fermant = strpos($texte,'>',$offset); + if ($p_tag_fermant<$p_tag_ouvrant) + $offset = $p_tag_fermant+1; // prolonger la coupe jusqu'au tag fermant suivant eventuel + } + $texte = substr($texte, 0, $offset); /* eviter de travailler sur 10ko pour extraire 150 caracteres */ + + // on utilise les \r pour passer entre les gouttes + $texte = str_replace("\r\n", "\n", $texte); + $texte = str_replace("\r", "\n", $texte); + + // sauts de ligne et paragraphes + $texte = preg_replace("/\n\n+/", "\r", $texte); + $texte = preg_replace("/<(p|br)( [^>]*)?".">/", "\r", $texte); + + // supprimer les traits, lignes etc + $texte = preg_replace("/(^|\r|\n)(-[-#\*]*|_ )/", "\r", $texte); + + // supprimer les tags + $texte = supprimer_tags($texte); + $texte = trim(str_replace("\n"," ", $texte)); + $texte .= "\n"; // marquer la fin + + // travailler en accents charset + $texte = unicode2charset(html2unicode($texte, /* secure */ true)); + $texte = nettoyer_raccourcis_typo($texte); + + // corriger la longueur de coupe + // en fonction de la presence de caracteres utf + if ($GLOBALS['meta']['charset']=='utf-8'){ + $long = charset2unicode($texte); + $long = spip_substr($long, 0, max($taille,1)); + $nbcharutf = preg_match_all('/(&#[0-9]{3,5};)/S', $long, $matches); + $taille += $nbcharutf; + } + + + // couper au mot precedent + $long = spip_substr($texte, 0, max($taille-4,1)); + $u = $GLOBALS['meta']['pcre_u']; + $court = preg_replace("/([^\s][\s]+)[^\s]*\n?$/".$u, "\\1", $long); + $points = $suite; + + // trop court ? ne pas faire de (...) + if (spip_strlen($court) < max(0.75 * $taille,2)) { + $points = ''; + $long = spip_substr($texte, 0, $taille); + $texte = preg_replace("/([^\s][\s]+)[^\s]*\n?$/".$u, "\\1", $long); + // encore trop court ? couper au caractere + if (spip_strlen($texte) < 0.75 * $taille) + $texte = $long; + } else + $texte = $court; + + if (strpos($texte, "\n")) // la fin est encore la : c'est qu'on n'a pas de texte de suite + $points = ''; + + // remettre les paragraphes + $texte = preg_replace("/\r+/", "\n\n", $texte); + + // supprimer l'eventuelle entite finale mal coupee + $texte = preg_replace('/&#?[a-z0-9]*$/S', '', $texte); + + return quote_amp(trim($texte)).$points; +} + +// +// Les elements de propre() +// + +// afficher joliment les

\n", $ligne); + + // tout mettre dans un tableau 2d + preg_match_all('/\|([^|]*)/S', $ligne, $cols); + $lignes[]= $cols[1]; + } + } + + // maintenant qu'on a toutes les cellules + // on prepare une liste de rowspan par defaut, a partir + // du nombre de colonnes dans la premiere ligne. + // Reperer egalement les colonnes numeriques pour les cadrer a droite + $rowspans = $numeric = array(); + $n = count($lignes[0]); + $k = count($lignes); + // distinguer les colonnes numeriques a point ou a virgule, + // pour les alignements eventuels sur "," ou "." + $numeric_class = array('.'=>'point',','=>'virgule'); + for($i=0;$i<$n;$i++) { + $align = true; + for ($j=0;$j<$k;$j++) $rowspans[$j][$i] = 1; + for ($j=0;$j<$k;$j++) { + $cell = trim($lignes[$j][$i]); + if (preg_match($reg_line_all, $cell)) { + if (!preg_match('/^\d+([.,]?)\d*$/', $cell, $r)) + { $align = ''; break;} + else if ($r[1]) $align = $r[1]; + } + } + $numeric[$i] = !$align ? '' : (" class='numeric ".$numeric_class[$align]."'"); + } + + // et on parcourt le tableau a l'envers pour ramasser les + // colspan et rowspan en passant + $html = ''; + + for($l=count($lignes)-1; $l>=0; $l--) { + $cols= $lignes[$l]; + $colspan=1; + $ligne=''; + + for($c=count($cols)-1; $c>=0; $c--) { + $attr= $numeric[$c]; + $cell = trim($cols[$c]); + if($cell=='<') { + $colspan++; + + } elseif($cell=='^') { + $rowspans[$l-1][$c]+=$rowspans[$l][$c]; + + } else { + if($colspan>1) { + $attr .= " colspan='$colspan'"; + $colspan=1; + } + if(($x=$rowspans[$l][$c])>1) { + $attr.= " rowspan='$x'"; + } + $ligne= "\n'.$cols[$c].''.$ligne; + } + } + + // ligne complete + $class = alterner($l+1, 'even', 'odd'); + $html = "$ligne\n$html"; + } + return "\n\n\n" + . $debut_table + . "\n" + . $html + . "\n" + . "\n\n"; +} + + +// +// Traitement des listes (merci a Michael Parienti) +// +// http://doc.spip.org/@traiter_listes +function traiter_listes ($texte) { + global $class_spip, $class_spip_plus; + $parags = preg_split(",\n[[:space:]]*\n,S", $texte); + $texte =''; + + // chaque paragraphe est traite a part + while (list(,$para) = each($parags)) { + $niveau = 0; + $pile_li = $pile_type = array(); + $lignes = explode("\n-", "\n" . $para); + + // ne pas toucher a la premiere ligne + list(,$debut) = each($lignes); + $texte .= $debut; + + // chaque item a sa profondeur = nb d'etoiles + $type =''; + while (list(,$item) = each($lignes)) { + preg_match(",^([*]*|[#]*)([^*#].*)$,sS", $item, $regs); + $profond = strlen($regs[1]); + + if ($profond > 0) { + $ajout=''; + + // changement de type de liste au meme niveau : il faut + // descendre un niveau plus bas, fermer ce niveau, et + // remonter + $nouv_type = (substr($item,0,1) == '*') ? 'ul' : 'ol'; + $change_type = ($type AND ($type <> $nouv_type) AND ($profond == $niveau)) ? 1 : 0; + $type = $nouv_type; + + // d'abord traiter les descentes + while ($niveau > $profond - $change_type) { + $ajout .= $pile_li[$niveau]; + $ajout .= $pile_type[$niveau]; + if (!$change_type) + unset ($pile_li[$niveau]); + $niveau --; + } + + // puis les identites (y compris en fin de descente) + if ($niveau == $profond && !$change_type) { + $ajout .= $pile_li[$niveau]; + } + + // puis les montees (y compris apres une descente un cran trop bas) + while ($niveau < $profond) { + if ($niveau == 0) $ajout .= "\n\n"; + elseif (!isset($pile_li[$niveau])) { + $ajout .= ""; + $pile_li[$niveau] = ""; + } + $niveau ++; + $ajout .= "<$type$class_spip_plus>"; + $pile_type[$niveau] = ""; + } + + $ajout .= ""; + $pile_li[$profond] = ""; + } + else { + $ajout = "\n-"; // puce normale ou
+ } + + $texte .= $ajout . $regs[2]; + } + + // retour sur terre + $ajout = ''; + while ($niveau > 0) { + $ajout .= $pile_li[$niveau]; + $ajout .= $pile_type[$niveau]; + $niveau --; + } + $texte .= $ajout; + + // paragraphe + $texte .= "\n\n"; + } + + // sucrer les deux derniers \n + return substr($texte, 0, -2); +} + + +// fonction en cas de texte extrait d'un serveur distant: +// on ne sait pas (encore) rapatrier les documents joints +// Sert aussi a nettoyer un texte qu'on veut mettre dans un etc. +// TODO: gerer les modeles ? +// http://doc.spip.org/@supprime_img +function supprime_img($letexte, $message=NULL) { + if ($message===NULL) $message = '(' . _T('img_indisponible') . ')'; + return preg_replace(',<(img|doc|emb)([0-9]+)(\|([^>]*))?'.'\s*/?'.'>,i', + $message, $letexte); +} + +// +// Une fonction pour fermer les paragraphes ; on essaie de preserver +// des paragraphes indiques a la main dans le texte +// (par ex: on ne modifie pas un

) +// +// deuxieme argument : forcer les

meme pour un seul paragraphe +// +// http://doc.spip.org/@paragrapher +function paragrapher($letexte, $forcer=true) { + global $class_spip; + + $letexte = trim($letexte); + if (!strlen($letexte)) + return ''; + + if ($forcer OR ( + strstr($letexte,'<') AND preg_match(', et un "STOP P" + // transformer aussi les

existants en

, nettoyes ensuite + $letexte = preg_replace(',,iS', '

', + '

'.$letexte.''); + + // Fermer les paragraphes (y compris sur "STOP P") + $letexte = preg_replace(',([:space:]]),UimsS', + "\n\\1

\n\\2", $letexte); + + // Supprimer les marqueurs "STOP P" + $letexte = str_replace('', '', $letexte); + + // Reduire les blancs dans les

+ $u = @$GLOBALS['meta']['pcre_u']; + $letexte = preg_replace(',()\s*,UiS'.$u, '\1',$letexte); + $letexte = preg_replace(',\s*(),UiS'.$u, '\1',$letexte); + + // Supprimer les

vides + $letexte = preg_replace(',]*>

\s*,iS'.$u, '', + $letexte); + + // Renommer les paragraphes normaux + $letexte = str_replace('

', "", + $letexte); + + } + + return $letexte; +} + +// http://doc.spip.org/@traiter_poesie +function traiter_poesie($letexte) +{ + if (preg_match_all(",<(poesie|poetry)>(.*)<\/(poesie|poetry)>,UimsS", + $letexte, $regs, PREG_SET_ORDER)) { + $u = "/\n[\s]*\n/S" . $GLOBALS['meta']['pcre_u']; + foreach ($regs as $reg) { + $lecode = preg_replace(",\r\n?,S", "\n", $reg[2]); + $lecode = preg_replace($u, "\n \n",$lecode); + $lecode = "

\n
" + .preg_replace("/\n+/", "
\n
", trim($lecode)) + ."
\n
\n\n"; + $letexte = str_replace($reg[0], $lecode, $letexte); + } + } + return $letexte; +} + +// Harmonise les retours chariots et mange les paragraphes html +// http://doc.spip.org/@traiter_retours_chariots +function traiter_retours_chariots($letexte) { + $letexte = preg_replace(",\r\n?,S", "\n", $letexte); + $letexte = preg_replace(",[:space:]],iS", "\n\n\\0", $letexte); + $letexte = preg_replace(",[:space:]],iS", "\\0\n\n", $letexte); + return $letexte; +} + +// Ces deux constantes permettent de proteger certains caracteres +// en les remplacanat par des caracteres "illegaux". (cf corriger_caracteres) + +define('_RACCOURCI_PROTEGER', "{}_-"); +define('_RACCOURCI_PROTECTEUR', "\x1\x2\x3\x4"); + +define('_RACCOURCI_BALISE', ",]*[".preg_quote(_RACCOURCI_PROTEGER)."][^<>]*>,imsS"); + +// Nettoie un texte, traite les raccourcis autre qu'URL, la typo, etc. +// http://doc.spip.org/@traiter_raccourcis +function traiter_raccourcis($letexte) { + + // Appeler les fonctions de pre_traitement + $letexte = pipeline('pre_propre', $letexte); + + // Gerer les notes (ne passe pas dans le pipeline) + $notes = charger_fonction('notes', 'inc'); + list($letexte, $mes_notes) = $notes($letexte); + + // + // Tableaux + // + + // ne pas oublier les tableaux au debut ou a la fin du texte + $letexte = preg_replace(",^\n?[|],S", "\n\n|", $letexte); + $letexte = preg_replace(",\n\n+[|],S", "\n\n\n\n|", $letexte); + $letexte = preg_replace(",[|](\n\n+|\n?$),S", "|\n\n\n\n", $letexte); + + if (preg_match_all(',[^|](\n[|].*[|]\n)[^|],UmsS', $letexte, + $regs, PREG_SET_ORDER)) + foreach ($regs as $t) { + $letexte = str_replace($t[1], traiter_tableau($t[1]), $letexte); + } + + $letexte = "\n".trim($letexte); + + // les listes + if (strpos($letexte,"\n-*")!==false OR strpos($letexte,"\n-#")!==false) + $letexte = traiter_listes($letexte); + + // Proteger les caracteres actifs a l'interieur des tags html + + if (preg_match_all(_RACCOURCI_BALISE, $letexte, $regs, PREG_SET_ORDER)) { + foreach ($regs as $reg) { + $insert = strtr($reg[0], _RACCOURCI_PROTEGER, _RACCOURCI_PROTECTEUR); + $letexte = str_replace($reg[0], $insert, $letexte); + } + } + + // Traitement des alineas + list($a,$b) = definir_raccourcis_alineas(); + $letexte = preg_replace($a, $b, $letexte); + // Introduction des attributs class_spip* et autres raccourcis + list($a,$b) = $GLOBALS['spip_raccourcis_typo']; + $letexte = preg_replace($a, $b, $letexte); + $letexte = preg_replace('@^\n
@S', '', $letexte); + + // Retablir les caracteres proteges + $letexte = strtr($letexte, _RACCOURCI_PROTECTEUR, _RACCOURCI_PROTEGER); + + // Fermer les paragraphes ; mais ne pas forcement en creer si un seul + $letexte = paragrapher($letexte, $GLOBALS['toujours_paragrapher']); + + // Appeler les fonctions de post-traitement + $letexte = pipeline('post_propre', $letexte); + + if ($mes_notes) $notes($mes_notes); + + return $letexte; +} + + + +// Filtre a appliquer aux champs du type #TEXTE* +// http://doc.spip.org/@propre +function propre($t, $connect=null) { + // les appels directs a cette fonction depuis le php de l'espace + // prive etant historiquement ecrits sans argment $connect + // on utilise la presence de celui-ci pour distinguer les cas + // ou il faut passer interdire_script explicitement + // les appels dans les squelettes (de l'espace prive) fournissant un $connect + // ne seront pas perturbes + $interdire_script = false; + if (is_null($connect)){ + $connect = ''; + $interdire_script = true; + } + + return !$t ? strval($t) : + echappe_retour_modeles( + traiter_raccourcis( + expanser_liens(echappe_html($t),$connect)),$interdire_script); +} +?>