Your IP : 216.73.216.249
<?php
/***************************************************************************\
* SPIP, Systeme de publication pour l'internet *
* *
* Copyright (c) 2001-2011 *
* 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. *
\***************************************************************************/
if (!defined('_ECRIRE_INC_VERSION')) return;
include_spip('inc/filtres');
include_spip('inc/lang');
include_spip('inc/lien');
// init du tableau principal des raccourcis
global $spip_raccourcis_typo, $class_spip_plus, $debut_intertitre, $fin_intertitre, $debut_gras, $fin_gras, $debut_italique, $fin_italique;
$spip_raccourcis_typo = array(
array(
/* 4 */ "/(^|[^{])[{][{][{]/S",
/* 5 */ "/[}][}][}]($|[^}])/S",
/* 6 */ "/(( *)\n){2,}(<br\s*\/?".">)?/S",
/* 7 */ "/[{][{]/S",
/* 8 */ "/[}][}]/S",
/* 9 */ "/[{]/S",
/* 10 */ "/[}]/S",
/* 11 */ "/(?:<br\s*\/?".">){2,}/S",
/* 12 */ "/<p>\n*(?:<br\s*\/?".">\n*)*/S",
/* 13 */ "/<quote>/S",
/* 14 */ "/<\/quote>/S",
/* 15 */ "/<\/?intro>/S"
),
array(
/* 4 */ "\$1\n\n" . $debut_intertitre,
/* 5 */ $fin_intertitre ."\n\n\$1",
/* 6 */ "<p>",
/* 7 */ $debut_gras,
/* 8 */ $fin_gras,
/* 9 */ $debut_italique,
/* 10 */ $fin_italique,
/* 11 */ "<p>",
/* 12 */ "<p>",
/* 13 */ "<blockquote$class_spip_plus><p>",
/* 14 */ "</blockquote><p>",
/* 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<br />— ",
/* 2 */ "\n<br />".definir_puce()." ",
/* 3 */ "\n<br />"
)
);
}
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] = '<img src="'.$img.'" '.$size.' class="puce" alt="-" />';
}
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(',</?('._BALISES_BLOCS.')[>[: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\"></$mode>";
}
return $return
. ((!$no_transform AND $mode == 'div')
? "\n\n"
: ''
);
;
}
// Echapper les <html>...</ html>
// http://doc.spip.org/@traiter_echap_html_dist
function traiter_echap_html_dist($regs) {
return $regs[3];
}
// Echapper les <code>...</ code>
// 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 <div...> 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 = "<div style='text-align: left;' "
. "class='spip_code' dir='ltr'><code$att>"
.$echap."</code></div>";
} else {
$echap = "<code$att class='spip_code' dir='ltr'>".$echap."</code>";
}
$echap = str_replace("\t", " ", $echap);
$echap = str_replace(" ", " ", $echap);
return $echap;
}
// Echapper les <cadre>...</ cadre> aka <frame>...</ frame>
// 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<textarea readonly='readonly' cols='40' rows='$n' class='spip_cadre' dir='ltr'>$echap</textarea>";
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(',<script\b[^>]+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[^>]*)?>(.*)</\1>,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, "<math>") !== 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*</\1>,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.'</'.$reg[1].'>';
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 <script>
// http://doc.spip.org/@echappe_js
function echappe_js($t,$class=' class="echappe-js"') {
if (preg_match_all(',<script.*?($|</script.),isS', $t, $r, PREG_SET_ORDER))
foreach ($r as $regs)
$t = str_replace($regs[0],
"<code$class>".nl2br(htmlspecialchars($regs[0])).'</code>',
$t);
return $t;
}
// http://doc.spip.org/@protege_js_modeles
function protege_js_modeles($t) {
if (isset($GLOBALS['visiteur_session'])){
if (preg_match_all(',<script.*?($|</script.),isS', $t, $r, PREG_SET_ORDER)){
if (!defined('_PROTEGE_JS_MODELES')){
include_spip('inc/acces');
define('_PROTEGE_JS_MODELES',creer_uniqid());
}
foreach ($r as $regs)
$t = str_replace($regs[0],code_echappement($regs[0],'javascript'._PROTEGE_JS_MODELES),$t);
}
if (preg_match_all(',<\?php.*?($|\?'.'>),isS', $t, $r, PREG_SET_ORDER)){
if (!defined('_PROTEGE_PHP_MODELES')){
include_spip('inc/acces');
define('_PROTEGE_PHP_MODELES',creer_uniqid());
}
foreach ($r as $regs)
$t = str_replace($regs[0],code_echappement($regs[0],'php'._PROTEGE_PHP_MODELES),$t);
}
}
return $t;
}
// Securite : empecher l'execution de code PHP, en le transformant en joli code
// dans l'espace prive, cette fonction est aussi appelee par propre et typo
// si elles sont appelees en direct
// il ne faut pas desactiver globalement la fonction dans l'espace prive car elle protege
// aussi les balises des squelettes qui ne passent pas forcement par propre ou typo apres
// http://doc.spip.org/@interdire_scripts
function interdire_scripts($arg) {
// on memorise le resultat sur les arguments non triviaux
static $dejavu = array();
// Attention, si ce n'est pas une chaine, laisser intact
if (!$arg OR !is_string($arg) OR !strstr($arg, '<')) return $arg;
if (isset($dejavu[$GLOBALS['filtrer_javascript']][$arg])) return $dejavu[$GLOBALS['filtrer_javascript']][$arg];
// echapper les tags asp/php
$t = str_replace('<'.'%', '<%', $arg);
// echapper le php
$t = str_replace('<'.'?', '<?', $t);
// echapper le < script language=php >
$t = preg_replace(',<(script\b[^>]+\blanguage\b[^\w>]+php\b),UimsS', '<\1', $t);
// Pour le js, trois modes : parano (-1), prive (0), ok (1)
switch($GLOBALS['filtrer_javascript']) {
case 0:
if (!_DIR_RESTREINT)
$t = echappe_js($t);
break;
case -1:
$t = echappe_js($t);
break;
}
// pas de <base href /> svp !
$t = preg_replace(',<(base\b),iS', '<\1', $t);
// Reinserer les echappements des modeles
if (defined('_PROTEGE_JS_MODELES'))
$t = echappe_retour($t,"javascript"._PROTEGE_JS_MODELES);
if (defined('_PROTEGE_PHP_MODELES'))
$t = echappe_retour($t,"php"._PROTEGE_PHP_MODELES);
return $dejavu[$GLOBALS['filtrer_javascript']][$arg] = $t;
}
// Securite : utiliser SafeHTML s'il est present dans ecrire/safehtml/
// http://doc.spip.org/@safehtml
function safehtml($t) {
static $safehtml;
# attention safehtml nettoie deux ou trois caracteres de plus. A voir
if (strpos($t,'<')===false)
return str_replace("\x00", '', $t);
$t = interdire_scripts($t); // jolifier le php
$t = echappe_js($t);
if (!isset($safehtml))
$safehtml = charger_fonction('safehtml', 'inc', true);
if ($safehtml)
$t = $safehtml($t);
return interdire_scripts($t); // interdire le php (2 precautions)
}
// Typographie generale
// avec protection prealable des balises HTML et SPIP
// http://doc.spip.org/@typo
function typo($letexte, $echapper=true, $connect=null) {
// Plus vite !
if (!$letexte) return $letexte;
// les appels directs a cette fonction depuis le php de l'espace
// prive etant historiquement ecrit 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;
}
// Echapper les codes <html> etc
if ($echapper)
$letexte = echappe_html($letexte, 'TYPO');
//
// Installer les modeles, notamment images et documents ;
//
// NOTE : propre() ne passe pas par ici mais directement par corriger_typo
// cf. inc/lien
$letexte = traiter_modeles($mem = $letexte, false, $echapper ? 'TYPO' : '', $connect);
if ($letexte != $mem) $echapper = true;
unset($mem);
$letexte = corriger_typo($letexte);
// reintegrer les echappements
if ($echapper)
$letexte = echappe_retour($letexte, 'TYPO');
// Dans les appels directs hors squelette, securiser ici aussi
if ($interdire_script)
$letexte = interdire_scripts($letexte);
return $letexte;
}
// Correcteur typographique
define('_TYPO_PROTEGER', "!':;?~%-");
define('_TYPO_PROTECTEUR', "\x1\x2\x3\x4\x5\x6\x7\x8");
define('_TYPO_BALISE', ",</?[a-z!][^<>]*[".preg_quote(_TYPO_PROTEGER)."][^<>]*>,imsS");
// http://doc.spip.org/@corriger_typo
function corriger_typo($letexte, $lang='') {
// Plus vite !
if (!$letexte) return $letexte;
$letexte = pipeline('pre_typo', $letexte);
// Caracteres de controle "illegaux"
$letexte = corriger_caracteres($letexte);
// Proteger les caracteres typographiques a l'interieur des tags html
if (preg_match_all(_TYPO_BALISE, $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, _TYPO_PROTEGER, _TYPO_PROTECTEUR);
$letexte = str_replace($reg[0], $insert, $letexte);
}
}
// trouver les blocs multi et les traiter a part
$letexte = extraire_multi($e = $letexte, $lang, true);
$e = ($e === $letexte);
// Charger & appliquer les fonctions de typographie
$typographie = charger_fonction(lang_typo($lang), 'typographie');
$letexte = $typographie($letexte);
// Les citations en une autre langue, s'il y a lieu
if (!$e) $letexte = echappe_retour($letexte, 'multi');
// Retablir les caracteres proteges
$letexte = strtr($letexte, _TYPO_PROTECTEUR, _TYPO_PROTEGER);
// pipeline
$letexte = pipeline('post_typo', $letexte);
# un message pour abs_url - on est passe en mode texte
$GLOBALS['mode_abs_url'] = 'texte';
return $letexte;
}
//
// Tableaux
//
define('_RACCOURCI_TH_SPAN', '\s*(?:{{[^{}]+}}\s*)?|<');
// http://doc.spip.org/@traiter_tableau
function traiter_tableau($bloc) {
// Decouper le tableau en lignes
preg_match_all(',([|].*)[|]\n,UmsS', $bloc, $regs, PREG_PATTERN_ORDER);
$lignes = array();
$debut_table = $summary = '';
$l = 0;
$numeric = true;
// Traiter chaque ligne
$reg_line1 = ',^(\|(' . _RACCOURCI_TH_SPAN . '))+$,sS';
$reg_line_all = ',^' . _RACCOURCI_TH_SPAN . '$,sS';
foreach ($regs[1] as $ligne) {
$l ++;
// Gestion de la premiere ligne :
if ($l == 1) {
// - <caption> et summary dans la premiere ligne :
// || caption | summary || (|summary est optionnel)
if (preg_match(',^\|\|([^|]*)(\|(.*))?$,sS', rtrim($ligne,'|'), $cap)) {
$l = 0;
if ($caption = trim($cap[1]))
$debut_table .= "<caption>".$caption."</caption>\n";
$summary = ' summary="'.entites_html(trim($cap[3])).'"';
}
// - <thead> sous la forme |{{titre}}|{{titre}}|
// Attention thead oblige a avoir tbody
else if (preg_match($reg_line1, $ligne)) {
preg_match_all('/\|([^|]*)/S', $ligne, $cols);
$ligne='';$cols= $cols[1];
$colspan=1;
for($c=count($cols)-1; $c>=0; $c--) {
$attr='';
if($cols[$c]=='<') {
$colspan++;
} else {
if($colspan>1) {
$attr= " colspan='$colspan'";
$colspan=1;
}
// inutile de garder le strong qui n'a servi que de marqueur
$cols[$c] = str_replace(array('{','}'), '', $cols[$c]);
$ligne= "<th scope='col'$attr>$cols[$c]</th>$ligne";
}
}
$debut_table .= "<thead><tr class='row_first'>".
$ligne."</tr></thead>\n";
$l = 0;
}
}
// Sinon ligne normale
if ($l) {
// Gerer les listes a puce dans les cellules
if (strpos($ligne,"\n-*")!==false OR strpos($ligne,"\n-#")!==false)
$ligne = traiter_listes($ligne);
// Pas de paragraphes dans les cellules
$ligne = preg_replace("/\n{2,}/", "<br /><br />\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<td".$attr.'>'.$cols[$c].'</td>'.$ligne;
}
}
// ligne complete
$class = alterner($l+1, 'even', 'odd');
$html = "<tr class='row_$class'>$ligne</tr>\n$html";
}
return "\n\n<table".$GLOBALS['class_spip_plus'].$summary.">\n"
. $debut_table
. "<tbody>\n"
. $html
. "</tbody>\n"
. "</table>\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 .= "<li$class_spip>";
$pile_li[$niveau] = "</li>";
}
$niveau ++;
$ajout .= "<$type$class_spip_plus>";
$pile_type[$niveau] = "</$type>";
}
$ajout .= "<li$class_spip>";
$pile_li[$profond] = "</li>";
}
else {
$ajout = "\n-"; // puce normale ou <hr>
}
$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 <a> 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 <p align='center'>)
//
// deuxieme argument : forcer les <p> 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(',<p\b,iS',$letexte)
)) {
// Ajouter un espace aux <p> et un "STOP P"
// transformer aussi les </p> existants en <p>, nettoyes ensuite
$letexte = preg_replace(',</?p\b\s?(.*?)>,iS', '<STOP P><p \1>',
'<p>'.$letexte.'<STOP P>');
// Fermer les paragraphes (y compris sur "STOP P")
$letexte = preg_replace(',(<p\s.*)(</?(STOP P|'._BALISES_BLOCS.')[>[:space:]]),UimsS',
"\n\\1</p>\n\\2", $letexte);
// Supprimer les marqueurs "STOP P"
$letexte = str_replace('<STOP P>', '', $letexte);
// Reduire les blancs dans les <p>
$u = @$GLOBALS['meta']['pcre_u'];
$letexte = preg_replace(',(<p\b.*>)\s*,UiS'.$u, '\1',$letexte);
$letexte = preg_replace(',\s*(</p\b.*>),UiS'.$u, '\1',$letexte);
// Supprimer les <p xx></p> vides
$letexte = preg_replace(',<p\b[^<>]*></p>\s*,iS'.$u, '',
$letexte);
// Renommer les paragraphes normaux
$letexte = str_replace('<p >', "<p$class_spip>",
$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 = "<blockquote class=\"spip_poesie\">\n<div>"
.preg_replace("/\n+/", "</div>\n<div>", trim($lecode))
."</div>\n</blockquote>\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(",<p[>[:space:]],iS", "\n\n\\0", $letexte);
$letexte = preg_replace(",</p[>[: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', ",</?[a-z!][^<>]*[".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<br />@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);
}
?>