Newer
Older
/***************************************************************************\
* SPIP, Systeme de publication pour l'internet *
* *
* Copyright (c) 2001-2005 *
* Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
* *
* Ce programme est un logiciel libre distribue sous licence GNU/GPL. *
* Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne. *
\***************************************************************************/
//
// Ce fichier ne sera execute qu'une fois
if (defined("_ECRIRE_INC_TEXTE")) return;
define("_ECRIRE_INC_TEXTE", "1");
//
// Initialisation de quelques variables globales
// (on peut les modifier globalement dans mes_fonctions.php3,
// OU individuellement pour chaque type de page dans article.php3,
// rubrique.php3, etc. cf doc...)
function tester_variable($nom_var, $val){
$GLOBALS[$nom_var] = $val;
tester_variable('debut_intertitre', "\n<h3 class=\"spip\">");
tester_variable('fin_intertitre', "</h3>\n");
tester_variable('ligne_horizontale', "\n<hr class=\"spip\" />\n");
tester_variable('ouvre_ref', ' [');
tester_variable('ferme_ref', ']');
tester_variable('ouvre_note', '[');
tester_variable('ferme_note', '] ');
tester_variable('les_notes', '');
tester_variable('compt_note', 0);
tester_variable('nombre_surligne', 4);
tester_variable('url_glossaire_externe', "http://@lang@.wikipedia.org/wiki/");
// On ne prend la $puce_rtl par defaut que si $puce n'a pas ete redefinie
//if (!tester_variable('puce', "<li class='spip_puce' style='list-style-image: url(puce.gif)'>")) {
if (!tester_variable('puce', "<img class='spip_puce' src='puce.gif' alt='-' /> ")) {
tester_variable('puce_rtl', "<img class='spip_puce' src='puce_rtl.gif' alt='-' /> ");
// Diverses fonctions essentielles
// Ne pas afficher le chapo si article virtuel
function nettoyer_chapo($chapo){
if (substr($chapo,0,1) == "="){
// points d'entree de pre- et post-traitement pour propre() et typo()
function spip_avant_propre ($letexte) {
if (function_exists('avant_propre'))
$letexte = avant_propre($letexte);
return $letexte;
function spip_apres_propre ($letexte) {
if (function_exists('apres_propre'))
$letexte = apres_propre($letexte);
return $letexte;
function spip_avant_typo ($letexte) {
$letexte = avant_typo_smallcaps($letexte);
if (function_exists('avant_typo'))
$letexte = avant_typo($letexte);
return $letexte;
function spip_apres_typo ($letexte) {
if (!_DIR_RESTREINT AND $GLOBALS['revision_nbsp'])
$letexte = str_replace(' ',
'<span class="spip-nbsp"> </span>', $letexte);
if (function_exists('apres_typo'))
$letexte = apres_typo($letexte);
return $letexte;
//
// Mise de cote des echappements
//
// Definition de la regexp de echappe_html
define ('__regexp_echappe',
"/(" . "<html>((.*?))<\/html>" . ")|(" #html
. "<code>((.*?))<\/code>" . ")|(" #code
. "<(cadre|frame)>((.*?))<\/(cadre|frame)>" #cadre
. ")|("
. "<(poesie|poetry)>((.*?))<\/(poesie|poetry)>" #poesie
. ")/si");
define ('__regexp_img_echappe', "<(IMG|DOC|EMB)([0-9]+)(\|([^\>]*))?".">");
define ('__regexp_img_seule_echappe', "<(IMG)([0-9]+)(\|([^\>]*))?".">");
define ('__regexp_doc_echappe', "<(DOC|EMB)([0-9]+)(\|([^\>]*))?".">");
esj
a validé
function echappe_html($letexte, $source='SOURCEPROPRE', $no_transform=false) {
if (preg_match_all(__regexp_echappe, $letexte, $matches, PREG_SET_ORDER))
foreach ($matches as $regs) {
$num_echap++;
$marqueur_echap = "@@SPIP_$source$num_echap@@";
if ($no_transform) { // echappements bruts
$les_echap[$num_echap] = $regs[0];
}
else
// Echapper les <html>...</ html>
$les_echap[$num_echap] = $regs[2];
}
else
// Echapper les <code>...</ code>
$lecode = entites_html($regs[5]);
// supprimer les sauts de ligne debut/fin (mais pas les espaces => ascii art).
$lecode = ereg_replace("^\n+|\n+$", "", $lecode);
// ne pas mettre le <div...> s'il n'y a qu'une ligne
if (is_int(strpos($lecode,"\n")))
$lecode = nl2br("<div align='left' class='spip_code' dir='ltr'>".$lecode."</div>");
else
$lecode = "<span class='spip_code' dir='ltr'>".$lecode."</span>";
$lecode = str_replace("\t", " ", $lecode);
$lecode = str_replace(" ", " ", $lecode);
$les_echap[$num_echap] = "<tt>".$lecode."</tt>";
}
else
// Echapper les <cadre>...</cadre>
$lecode = trim(entites_html($regs[9]));
$total_lignes = substr_count($lecode, "\n");
$les_echap[$num_echap] = "<form action=\"/\" method=\"get\"><textarea readonly='readonly' cols='40' rows='$total_lignes' class='spip_cadre' dir='ltr'>".$lecode."</textarea></form>";
// Les marques ci-dessous indiquent qu'on ne veut pas paragrapher
$marqueur_echap = "\n\n</no p>$marqueur_echap<no p>\n\n";
else
if ($regs[12]) {
$lecode = $regs[14];
$lecode = ereg_replace("\n[[:space:]]*\n", "\n \n",$lecode);
$lecode = str_replace("\r", "\n", $lecode); # gestion des \r a revoir !
$lecode = "<div class=\"spip_poesie\"><div>".ereg_replace("\n+", "</div>\n<div>", $lecode)."</div></div>";
$marqueur_echap = "\n\n</no p>$marqueur_echap<no p>\n\n";
$letexte = str_replace($regs[0], $marqueur_echap, $letexte);
// Gestion du TeX
if (!(strpos($letexte, "<math>") === false)) {
include_ecrire("inc_math.php3");
$letexte = traiter_math($letexte, $les_echap, $num_echap, $source);
esj
a validé
// Reperages d'images et de documents utilisateur
// (insertion dans echappe_retour pour faciliter les doublons)
// on explose par paragraphes pour sortir les insertions "lourdes" (xhtml)
if (eregi(__regexp_img_echappe, $letexte)) {
$letexte = str_replace("\r\n", "\n", $letexte);
$letexte = str_replace("\r", "\n", $letexte);
// Attention certains raccourcis impliquent un paragraphe
// (a completer, ou faire autrement !)
$letexte = str_replace('}}}', "}}}\n\n", $letexte);
$paragraphes = explode("\n\n", $letexte);
while (eregi(__regexp_doc_echappe, $para, $match)) {
$num_echap++;
$para = "</no p>@@SPIP_$source$num_echap@@<no p>\n\n".str_replace($match[0], "", $para);
$les_echap[$num_echap] = $match;
}
while (eregi(__regexp_img_seule_echappe, $para, $match)) {
$num_echap++;
$para = str_replace($match[0], "@@SPIP_$source$num_echap@@<no p>", $para);
$les_echap[$num_echap] = $match;
}
$paragraphe[] = "$para";
}
$letexte= join("\n\n",$paragraphe);
}
return array($letexte, $les_echap);
// Traitement final des echappements
function echappe_retour($letexte, $les_echap, $source='') {
$expr = ",@@SPIP_$source([0-9]+)@@,";
if (preg_match_all($expr, $letexte, $regs, PREG_SET_ORDER)) {
foreach ($regs as $reg) {
$rempl = $les_echap[$reg[1]];
# si $rempl est un tableau, c'est le resultat (cf echappe_html) de eregi sur :
esj
a validé
# <(IMG|DOC|EMB)([0-9]+)(\|([^\>]*))?
if (is_array($rempl)) {
include_ecrire("inc_documents.php3");
$type = strtoupper($rempl[1]);
if ($type == 'EMB')
$rempl = embed_document($rempl[2], $rempl[4]);
else
$rempl = integre_image($rempl[2], $rempl[4], $type);
}
$letexte = str_replace($reg[0], $rempl, $letexte);
}
}
return $letexte;
esj
a validé
}
// fonction en cas de texte extrait d'un serveur distant:
// on ne sait pas (encore) rapatrier les documents joints
function supprime_img($letexte) {
$message = _T('img_indisponible');
while (eregi(__regexp_img_echappe, $letexte, $match)) {
$letexte = str_replace($match[0], "($message)", $letexte);
}
return $letexte;
}
esj
a validé
# il y a 3 couples de fonctions homonymes au prefixe _doublons pres
# pour eviter a tous les appels de se trimbaler ce qui concerne les squelettes
esj
a validé
function echappe_retour_doublon($letexte, $les_echap, $source, &$doublons)
{
if (!$les_echap)
return $letexte;
foreach($les_echap as $rempl) {
if (is_array($rempl)) # cf commentaires dans la fonction echappe_retour
$doublons['documents'] .= "," . $rempl[2];
}
return echappe_retour($letexte, $les_echap, $source);
//
// Gerer les outils mb_string
//
function spip_substr($c, $start=0, $end='') {
if (init_mb_string()) {
if ($end)
return mb_substr($c, $start, $end);
else
return mb_substr($c, $start);
}
// methode substr normale
else {
if ($end)
return substr($c, $start, $end);
else
return substr($c, $start);
}
}
function spip_strlen($c) {
if (init_mb_string())
return mb_strlen($c);
else
return strlen($c);
}
// fin mb_string
function couper($texte, $taille=50) {
$texte = substr($texte, 0, 400 + 2*$taille); /* eviter de travailler sur 10ko pour extraire 150 caracteres */
// on utilise les \r pour passer entre les gouttes
Fil
a validé
$texte = str_replace("\r\n", "\n", $texte);
$texte = str_replace("\r", "\n", $texte);
// sauts de ligne et paragraphes
$texte = ereg_replace("\n\n+", "\r", $texte);
$texte = ereg_replace("<(p|br)( [^>]*)?".">", "\r", $texte);
Fil
a validé
// supprimer les traits, lignes etc
$texte = ereg_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 = filtrer_entites($texte);
// supprimer les liens
$texte = ereg_replace("\[->([^]]*)\]","\\1", $texte); // liens sans texte
$texte = ereg_replace("\[([^\[]*)->([^]]*)\]","\\1", $texte);
// supprimer les notes
$texte = ereg_replace("\[\[([^]]|\][^]])*\]\]", "", $texte);
// supprimer les codes typos
$texte = ereg_replace("[{}]", "", $texte);
// supprimer les tableaux
// couper au mot precedent
$court = ereg_replace("([^[:space:]][[:space:]]+)[^[:space:]]*\n?$", "\\1", $long);
$points = ' (...)';
// trop court ? ne pas faire de (...)
$points = '';
$texte = ereg_replace("([^[:space:]][[:space:]]+)[^[:space:]]*$", "\\1", $long);
// encore trop court ? couper au caractere
$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 = ereg_replace("\r+", "\n\n", $texte);
$texte = preg_replace('/&#?[a-z0-9]*$/', '', $texte);
return trim($texte).$points;
// prendre <intro>...</intro> sinon couper a la longueur demandee
$texte = extraire_multi(eregi_replace("(</?)intro>", "\\1intro>", $texte)); // minuscules
while ($fin = strpos($texte, "</intro>")) {
$zone = substr($texte, 0, $fin);
$texte = substr($texte, $fin + strlen("</intro>"));
if ($deb = strpos($zone, "<intro>") OR substr($zone, 0, 7) == "<intro>")
$zone = substr($zone, $deb + 7);
$intro .= $zone;
}
if ($intro)
$intro = $intro.' (...)';
else
$intro = couper($texte, $long);
// supprimer un eventuel chapo redirecteur =http:/.....
$intro = ereg_replace("^=[^[:space:]]+","",$intro);
// Les elements de propre()
// Securite : empecher l'execution de code PHP
function interdire_scripts($source) {
$source = preg_replace(",<(\%|\?|([[:space:]]*)script),", "<\\1", $source);
return $source;
Antoine Pitrou
a validé
// Correction typographique francaise
// Nettoyer 160 = nbsp ; 187 = raquo ; 171 = laquo ; 176 = deg ; 147 = ldquo; 148 = rdquo
if (!$trans) {
$trans = array(
" " => "~",
"»" => "»",
"«" => "«",
"”" => "”",
"“" => "“",
$chars = array(160 => '~', 187 => '»', 171 => '«', 148 => '”', 147 => '“', 176 => '°');
include_ecrire('inc_charsets.php3');
while (list($c, $r) = each($chars)) {
$c = unicode2charset(charset2unicode(chr($c), 'iso-8859-1', 'forcer'));
$trans[$c] = $r;
}
/* 1 '/{([^}]+)}/', */
/* 3 */ '/»| --?,|:([^0-9]|$)/',
/* 4 */ '/([^<!?])([!?])/',
/* 5 */ '/«|(M(M?\.|mes?|r\.?)|[MnN]°) /'
/* 1 '<i class="spip">\1</i>', */
/* 3 */ '~\0',
/* 4 */ '\1~\2',
/* 5 */ '\0~'
$letexte = preg_replace($cherche1, $remplace1, $letexte);
$letexte = ereg_replace(" *~+ *", "~", $letexte);
$cherche2 = array(
'/([^-\n]|^)--([^-]|$)/',
'/(http|https|ftp|mailto)~:/',
'\1—\2',
$letexte = preg_replace($cherche2, $remplace2, $letexte);
// rien sauf les "~" et "-,"
function typo_en($letexte) {
$letexte = preg_replace($cherche1, $remplace1, $letexte);
$letexte = ereg_replace(" *~+ *", "~", $letexte);
$cherche2 = array(
'/([^-\n]|^)--([^-]|$)/',
'/~/'
);
$remplace2 = array(
'\1—\2',
$letexte = preg_replace($cherche2, $remplace2, $letexte);
return $letexte;
//
// Typographie generale
//
esj
a validé
function typo_generale($letexte) {
global $spip_lang;
// Appeler la fonction de pre-traitement
$letexte = spip_avant_typo ($letexte);
// Caracteres de controle "illegaux"
$letexte = corriger_caracteres($letexte);
// Proteger les caracteres typographiques a l'interieur des tags html
$protege = "!':;?";
$illegal = "\x1\x2\x3\x4\x5";
if (preg_match_all("/<[a-z!][^<>!':;\?]*[!':;\?][^<>]*>/ims",
$letexte, $regs, PREG_SET_ORDER)) {
foreach ($regs as $reg) {
$insert = $reg[0];
// hack: on transforme les caracteres a proteger en les remplacant
// par des caracteres "illegaux". (cf corriger_caracteres())
$insert = strtr($insert, $protege, $illegal);
$letexte = str_replace($reg[0], $insert, $letexte);
}
}
// zouli apostrophe
$letexte = str_replace("'", "’", $letexte);
// typo francaise ou anglaise ?
// $lang_typo est fixee dans l'interface privee pour editer
// un texte anglais en interface francaise (ou l'inverse) ;
// sinon determiner la typo en fonction de la langue
if (!$lang = $GLOBALS['lang_typo']) {
else
$letexte = typo_en($letexte);
// Retablir les caracteres proteges
$letexte = strtr($letexte, $illegal, $protege);
// Appeler la fonction de post-traitement
$letexte = spip_apres_typo ($letexte);
# un message pour abs_url - on est passe en mode texte
$GLOBALS['mode_abs_url'] = 'texte';
// et retour
return $letexte;
esj
a validé
}
esj
a validé
function typo($letexte) {
// echapper les codes <html>...</html> etc.
list($letexte, $les_echap) = echappe_html($letexte, "SOURCETYPO");
$letexte = typo_generale($letexte);
esj
a validé
return echappe_retour($letexte, $les_echap, "SOURCETYPO");
esj
a validé
function typo_doublon(&$doublons, $letexte)
{
// echapper les codes <html>...</html> etc.
list($letexte, $les_echap) = echappe_html($letexte, "SOURCETYPO");
$letexte = typo_generale($letexte);
// reintegrer les echappements
return echappe_retour_doublon($letexte, $les_echap, "SOURCETYPO", $doublons);
}
// cette fonction est tordue : on lui passe un tableau correspondant au match
// de la regexp ci-dessous, et elle retourne le texte a inserer a la place
// et le lien "brut" a usage eventuel de redirection...
function extraire_lien ($regs) {
$lien_url = entites_html(trim($regs[3]));
if (ereg('^[[:space:]]*(art(icle)?|rub(rique)?|br(.ve)?|aut(eur)?|mot|site|doc(ument)?|im(age|g))?[[:space:]]*([[:digit:]]+)(#.*)?[[:space:]]*$', $lien_url, $match)) {
else
if (@file_exists("inc-urls.php3"))
include_local("inc-urls.php3");
else
include_local("inc-urls-".$GLOBALS['type_urls'].".php3");
$id_lien = $match[8];
$ancre = $match[9];
$type_lien = substr($match[1], 0, 2);
case 'ru':
$lien_url = generer_url_rubrique($id_lien);
if (!$lien_texte) {
$req = "select titre from spip_rubriques where id_rubrique=$id_lien";
$row = @spip_fetch_array(@spip_query($req));
$lien_texte = $row['titre'];
}
break;
case 'br':
$lien_url = generer_url_breve($id_lien);
if (!$lien_texte) {
$req = "select titre from spip_breves where id_breve=$id_lien";
$row = @spip_fetch_array(@spip_query($req));
$lien_texte = $row['titre'];
}
break;
case 'au':
$lien_url = generer_url_auteur($id_lien);
if (!$lien_texte) {
$req = "select nom from spip_auteurs where id_auteur = $id_lien";
$row = @spip_fetch_array(@spip_query($req));
$lien_texte = $row['nom'];
}
break;
case 'mo':
$lien_url = generer_url_mot($id_lien);
if (!$lien_texte) {
$req = "select titre from spip_mots where id_mot=$id_lien";
$row = @spip_fetch_array(@spip_query($req));
case 'im':
case 'do':
$lien_url = generer_url_document($id_lien);
if (!$lien_texte) {
$req = "select titre,fichier from spip_documents where id_document=$id_lien";
$row = @spip_fetch_array(@spip_query($req));
$lien_texte = $row['titre'];
if (!$lien_texte)
$lien_texte = ereg_replace("^.*/","",$row['fichier']);
}
$row = @spip_fetch_array(@spip_query("SELECT nom_site,url_site FROM spip_syndic WHERE id_syndic=$id_lien"));
if ($row) {
$lien_url = $row['url_site'];
if (!$lien_texte)
$lien_texte = typo($row['nom_site']);
}
break;
default:
$lien_url = generer_url_article($id_lien);
if (!$lien_texte) {
$req = "select titre from spip_articles where id_article=$id_lien";
$row = @spip_fetch_array(@spip_query($req));
// supprimer les numeros des titres
include_ecrire("inc_filtres.php3");
$lien_texte = supprimer_numero($lien_texte);
else if (preg_match(',^\?(.*)$,s', $lien_url, $regs)) {
// Liens glossaire
$lien_url = substr($lien_url, 1);
$class_lien = "glossaire";
}
else {
// Liens non automatiques
$class_lien = "out";
// texte vide ?
if ((!$lien_texte) and (!$lien_interne)) {
$lien_texte = str_replace('"', '', $lien_url);
if (strlen($lien_texte)>40)
$lien_texte = substr($lien_texte,0,35).'...';
$class_lien = "url";
Fil
a validé
$lien_texte = "<html>$lien_texte</html>";
if (preg_match(",^www\.[^@]+$,",$lien_url))
else if (strpos($lien_url, "@") && email_valide($lien_url))
$lien_url = "mailto:".$lien_url;
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
//
// Tableaux
//
function traiter_tableau($bloc) {
// Decouper le tableau en lignes
preg_match_all(',([|].*)[|]\n,Ums', $bloc, $regs, PREG_PATTERN_ORDER);
// Traiter chaque ligne
foreach ($regs[1] as $ligne) {
$l ++;
// Gestion de la premiere ligne :
if ($l == 1) {
// - <caption> sous forme de ||xxx|| en premiere ligne
if (preg_match(',^\|\|([^|]*)\|$,ms', $ligne, $caption)) {
$debut_table .= "<caption>".$caption[1]."</caption>\n";
$l = 0;
}
// - <thead> sous la forme |{{titre}}|{{titre}}|
// Attention thead oblige a avoir tbody
else if (preg_match(',^(\|[[:space:]]*{{[^}]+}}[[:space:]]*)+$,ms',
$ligne, $thead)) {
$debut_table .= "<thead>\n
<tr class='row_first'>".
preg_replace(",[|]([^|]*),",
"<th scope='col'>\\1</th>", $ligne)
."</tr>\n";
$l = 0;
}
}
// Sinon ligne normale
if ($l) {
// definition du tr
if ($l == 1
AND ereg("^(\|[[:space:]]*{{[^}]+}}[[:space:]]*)+$", $ligne)) {
$class = 'row_first';
} else {
$class = 'row_'.alterner($l, 'even', 'odd');
}
// Pas de paragraphes dans les cellules
$ligne = preg_replace(",\n\n+,", "<br />\n", $ligne);
// definition du <td>
$ligne = preg_replace(",[|]([^|]*),",
"<td>\\1</td>", $ligne);
// ligne complete
$html[$l] = "<tr class=\"$class\">" . $ligne . "</tr>\n";
}
}
return "\n\n</no p><table class=\"spip\">\n"
. $debut_table
. "<tbody>\n"
. join ('', $html)
. "</tbody>\n"
. "</table><no p>\n\n";
}
// Traitement des listes (merci a Michael Parienti)
//
function traiter_listes ($texte) {
$parags = preg_split(",\n[[:space:]]*\n,", $texte);
unset($texte);
// chaque paragraphe est traite a part
while (list(,$para) = each($parags)) {
$niveau = 0;
$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
unset ($type);
while (list(,$item) = each($lignes)) {
preg_match(",^([*]*|[#]*)([^*#].*)$,s", $item, $regs);
$profond = strlen($regs[1]);
if ($profond > 0) {
unset ($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];
// puis les identites (y compris en fin de descente)
if ($niveau == $profond && !$change_type) {
}
// puis les montees (y compris apres une descente un cran trop bas)
while ($niveau < $profond) {
$niveau ++;
$ajout .= "<$type class=\"spip\">";
$pile_type[$niveau] = "</$type>";
}
$ajout .= "<li class=\"spip\">";
$pile_li[$profond] = "</li>";
Fil
a validé
$ajout = "\n-"; // puce normale ou <hr>
Fil
a validé
$texte .= $ajout . $regs[2];
}
// retour sur terre
unset ($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);
}
// Nettoie un texte, traite les raccourcis spip, la typo, etc.
esj
a validé
function traiter_raccourcis_generale($letexte) {
global $debut_intertitre, $fin_intertitre, $ligne_horizontale, $url_glossaire_externe;
global $marqueur_notes;
global $ouvre_ref;
global $ferme_ref;
global $ouvre_note;
global $ferme_note;
// Appeler la fonction de pre_traitement
$letexte = spip_avant_propre ($letexte);
if (!$lang_dir) {
include_ecrire('inc_lang.php3');
if ($lang_dir == 'rtl' AND $GLOBALS['puce_rtl'])
$puce = $GLOBALS['puce_rtl'];
else
$puce = $GLOBALS['puce'];
// Harmoniser les retours chariot
$letexte = preg_replace(",\r\n?,", "\n", $letexte);
$letexte = preg_replace(",</?p>,i", "\n\n\n", $letexte);
$regexp = ',\[\[(.*?)\]\],ms';
if (preg_match_all($regexp, $letexte, $matches, PREG_SET_ORDER))
foreach ($matches as $regs) {
if (preg_match(",^ *<([^>]*)>,", $note_texte, $regs)){
$note_texte = str_replace($regs[0], "", $note_texte);
if ($marqueur_notes) // quand il y a plusieurs series
// de notes sur une meme page
$mn = $marqueur_notes.'-';
// creer le popup 'title' sur l'appel de note
if ($title = supprimer_tags(propre($note_texte))) {
$title = $ouvre_note.$ancre.$ferme_note.$title;
. texte_backend(couper($title,80)).'</html>"';
}
$insert = "$ouvre_ref<a href=\"#nb$ancre\" name=\"nh$ancre\" class=\"spip_note\"$title>$num_note</a>$ferme_ref";
$appel = "<html>$ouvre_note<a href=\"#nh$ancre\" name=\"nb$ancre\" class=\"spip_note\">$num_note</a>$ferme_note</html>";
// l'ajouter "brut" dans les notes
if ($note_texte) {
if ($mes_notes)
$mes_notes .= "\n\n";
$mes_notes .= $appel . $note_texte;
}
// dans le texte, mettre l'appel de note a la place de la note
$pos = strpos($letexte, $note_source);
$letexte = substr($letexte, 0, $pos) . $insert
. substr($letexte, $pos + strlen($note_source));
// Raccourcis automatiques [?SPIP] vers un glossaire
// (on traite ce raccourci en deux temps afin de ne pas appliquer
// la typo sur les URLs, voir raccourcis liens ci-dessous)
//
if ($url_glossaire_externe) {
$regexp = "|\[\?+([^][<>]+)\]|";
if (preg_match_all($regexp, $letexte, $matches, PREG_SET_ORDER))
foreach ($matches as $regs) {
$terme_underscore = urlencode(preg_replace(',\s+,', '_', $terme));
$url = str_replace("%s", $terme_underscore, $url_glossaire_externe);
else
$url = $url_glossaire_externe.$terme_underscore;
$url = str_replace("@lang@", $GLOBALS['spip_lang'], $url);
$letexte = str_replace($regs[0], $code, $letexte);
}
}
//
// Raccourcis liens [xxx->url] (cf. fonction extraire_lien ci-dessus)
// Note : complique car c'est ici qu'on applique la typo() !
$inserts = array();
if (preg_match_all($regexp, $letexte, $matches, PREG_SET_ORDER)) {
$i = 0;
foreach ($matches as $regs) {
list($insert) = extraire_lien($regs);
$inserts[++$i] = $insert;
$letexte = str_replace($regs[0], "@@SPIP_ECHAPPE$i@@", $letexte);
}
}
$letexte = typo($letexte);
foreach ($inserts as $i => $insert) {
$letexte = str_replace("@@SPIP_ECHAPPE$i@@", $insert, $letexte);
$letexte = preg_replace(",^\n?[|],", "\n\n|", $letexte);
$letexte = preg_replace(",\n\n+[|],", "\n\n\n\n|", $letexte);
$letexte = preg_replace(",[|](\n\n+|\n?$),", "|\n\n\n\n", $letexte);
if (preg_match_all(',\n\n[|].*[|]\n\n,Ums', $letexte,
$regs, PREG_SET_ORDER))
foreach ($regs as $tab) {
$letexte = str_replace($tab[0], traiter_tableau($tab[0]), $letexte);
//
// Ensemble de remplacements implementant le systeme de mise
// en forme (paragraphes, raccourcis...)
//
$letexte = traiter_listes($letexte);
// autres raccourcis
$cherche1 = array(
/* 0 */ "/\n(----+|____+)/",
/* 1 */ "/\n-- */",
/* 2 */ "/\n- */",
/* 3 */ "/\n_ +/",
/* 4 */ "/\{\{\{/",
/* 5 */ "/\}\}\}/",
/* 6 */ "/(( *)\n){2,}(<br[[:space:]]*\/?".">)?/",
/* 7 */ "/\{\{/",
/* 8 */ "/\}\}/",
/* 9 */ "/\{/",
/* 10 */ "/\}/",
/* 11 */ "/(<br[[:space:]]*\/?".">){2,}/",
/* 12 */ "/<p>([\n]*)(<br[[:space:]]*\/?".">)+/",
/* 13 */ "/<p>/",
/* 14 "/\n/", */
/* 15 */ "/<quote>/",
/* 16 */ "/<\/quote>/"
);
$remplace1 = array(
/* 0 */ "@@SPIP_ligne_horizontale@@",
/* 1 */ "\n<br />— ",
/* 2 */ "\n<br />$puce ",
/* 3 */ "\n<br />",
/* 4 */ "\n\n@@SPIP_debut_intertitre@@",
/* 5 */ "@@SPIP_fin_intertitre@@\n\n",
/* 6 */ "<p>",