.-.-.-.-.-

spip/echappe-js.yaml000064400000002305152524374060010432 0ustar00--- # Syntaxe des raccourcis SPIP, version 0.0.1
    #
    # Si on nomme une regle, elle devient surchargeable

-
  if_str: "<script"
  match: "{<script.*?($|</script.)}isS"
  is_wheel: y
  replace:
    -
      type: all
      replace: htmlspecialchars
      is_callback: Y
    -
      type: all
      replace: nl2br
      is_callback: Y
    -
      type: all
      replace: "<code class=\"echappe-js\">$0</code>"

-
  if_str: "<iframe"
  match: "{<iframe.*?($|</iframe.)}isS"
  is_callback: Y
  replace: echappe_anti_xss

-
  if_str: "<embed"
  match: "{<embed.*?($|</embed.)}isS"
  is_callback: Y
  replace: echappe_anti_xss

-
  if_str: "<object"
  match: "{<object.*?($|</object.)}isS"
  is_callback: Y
  replace: echappe_anti_xss

-
  if_str: "<img"
  match: "{<img.*?($|>)}isS"
  is_callback: Y
  replace: echappe_anti_xss

-
  if_str: "<image"
  match: "{<image.*?($|>)}isS"
  is_callback: Y
  replace: echappe_anti_xss

-
  if_str: "<body"
  match: "{<body.*?($|>)}isS"
  is_callback: Y
  replace: echappe_anti_xss

-
  if_str: "<bgsound"
  match: "{<bgsound.*?($|>)}isS"
  is_callback: Y
  replace: echappe_anti_xss

-
  if_str: "<meta"
  match: "{<meta.*?($|>)}isS"
  is_callback: Y
  replace: echappe_anti_xss
spip/spip-poesie.yaml000064400000001046152524374060010651 0ustar00--- # callback pour <poesie> !spip.yaml

-
  # trim
  type: all
  replace: trim
  is_callback: y

-
  # nettoyer les sauts de ligne \r
  # (semble inutile car deja dans spip.yaml#L6)
  match: ",\r\n?,S"
  replace: "\n"
-
  # ligne contenant une espace => ligne contenant un &nbsp;
  match: "/\n[\s]*\n/Su"
  replace: "\n&nbsp;\n"
-
  # deux sauts de ligne => div
  match: "/\n+/"
  replace: "</div>\n<div>"

-
  # entourer avec un blockquote.spip_poesie
  type: all
  replace: "<blockquote class=\"spip_poesie\">\n\n<div>$0</div>\n</blockquote>\n\n"
spip/spip.yaml000064400000011557152524374060007377 0ustar00--- # Syntaxe des raccourcis SPIP, version 0.0.1
    #
    # Si on nomme une regle, elle devient surchargeable

math:
  if_str: "<math>"
  type: all
  is_callback: y
  replace: "replace_math"
  priority: -50 # en tout premier : le contenu des formules math ne doit pas etre modifie

traiter_retours_chariots_1:
  # Harmonise les retours chariots et mange les paragraphes html
  if_chars: "\r"
  match: ",\r\n?,S"
  replace: "\n"
  priority: -40 # avant tout

init-trim:
  # trim
  type: all
  is_callback: y
  replace: trim
  priority: -40 # avant tout

init-saut:
  type: all
  replace: "\n$0"
  priority: -40

lignes-vides:
  match: ",^[ \t]+$,m"
  replace: ""
  priority: -35 # avant les tableaux

tableaux:
  type: all
  # included subwheel with relative filepath
  replace: spip/spip-tableaux.yaml
  is_wheel: Y
  if_str: "\n|"
  priority: -30 # avant les raccourcis

listes:
  if_str: "\n-"
  is_wheel: Y
  type: all
  replace: spip/spip-listes.yaml
  priority: -20 # avant !paragraphes

echappe-tags:
  # voir restaure-tags plus bas
  match: ",</?[a-z!][^<>]*?[{}_-][^<>]*>,imsS"
  if_chars: "{}_-"
  priority: -20 # avant !paragraphes
  is_wheel: Y
  replace:
    echappe-tags-sub:
      if_match: "/[{}]|\n[_-]|--/"
      match: ['{', '}', '_', '-']
      replace: ["\x1\x1", "\x1\x2", "\x1\x3", "\x1\x4"]
      type: str

echappe-raccourcis:
  if_str: '\'
  priority: -20 # avant !paragraphes
  match: ['\{', '\}', '\_', '\-', '\[', '\]', '\|', '\<', '\>', '\\', '\*', '\#', '\+', '\~']
  replace: ["\x1\x1", "\x1\x2", "\x1\x3", "\x1\x4", "\x1\x5", "\x1\x6", "\x1\x7", "\x1\x8", "\x1\x9", "\x1\x10", "\x1\x11", "\x1\x12", "\x1\x13", "\x1\x14"]
  type: str

ligne-horizontale:
  match: "/\n(----+|____+)/S"
  replace: "\n\n\n<hr class=\"spip\" />\n\n\n"
  if_chars: "\n"
  priority: -20 # avant !paragraphes

alinea:
  match: "/\n-- */"
  replace: "\n<br />&mdash;&nbsp;"
  if_str: "\n--"
  priority: -20 # avant !paragraphes

puce:
  match: "/\n- */S"
  replace: replace_puce
  if_str: "\n-"
  is_callback: Y
  priority: -20 # avant !paragraphes

br-inutile:
  match: "/(^|^\n|\n\n)_ +/S"
  replace: "$1"
  if_str: "_ "
  priority: -20 # avant !paragraphes

br:
  match: "/\n_ +/S"
  replace: "<br class='manualbr' />"
  if_str: "\n_"
  priority: -20 # avant !paragraphes

abbr:
  # raccourcis en [ABBR|abbreviation]
  if_chars: "["
  if_chars: "|"
  match: "/\[([^\|\[\]>]+)\|([^\|\]\{>]+)(?:\{([a-z]+)\})?\]/S"
  is_callback: Y
  replace: inserer_abbr

intertitres-compliques:
  # raccourcis imbriques en {{{{..}}}}
  # intertitres
  match: ['/(^|[^{])[{][{][{]/S', '/[}][}][}]($|[^}])/S']
  replace: ["$1\n\n\n<h3 class=\"spip\">", "</h3>\n\n\n$1"]
  if_str: '}}}}'

intertitres:
  # raccourcis en {{{..}}}
  # intertitres
  match: ['{{{', '}}}']
  replace: ["\n\n\n<h3 class=\"spip\">", "</h3>\n\n\n"]
  if_str: '{{{'
  type: str

gras-vide:
  # faux raccourcis vides en {{}}
  # echappes
  match: '{{}}'
  replace: "\x1\x1\x1\x1\x1\x2\x1\x2"
  type: str
  if_str: '{{'

gras:
  # raccourcis en {{..}}
  # strong
  match: ['{{', '}}']
  replace: ['<strong>', '</strong>']
  type: str
  if_str: '{{'

italiques-vide:
  # faux raccourcis vides en {}
  # echappes
  match: '{}'
  replace: "\x1\x1\x1\x2"
  type: str
  if_str: '{'

italiques:
  # raccourcis en {..}
  # i
  match: ['{', '}']
  replace: ['<i>', '</i>']
  type: str
  if_str: '{'

paragraphes:
  # paragraphes
  # lignes vides consecutives, br imbriques dans des p
  # mais attention pas les br trop riches (ex: br style=clear:both)
  match: ["/ *\n(?: *\n)+(?:<br ?\/?>)*/S", '/(?:<br\b[^>]*>){2,}\s*/S', "/(<p\b[^>]*>)\n*(?:<br ?\/?>\n*)+/S"]
  replace: ['<p>', '<p>', '$1']
  priority: 0

quote:
  # raccourci <quote>
  match: ['<quote>', '</quote>']
  replace: ['<blockquote class="spip"><p>', '</blockquote>']
  if_str: '<quote>'
  type: str

intro:
  # suppr raccourci <intro>
  # + suppression de <intro>
  match: ['<intro>', '</intro>']
  replace: ['', '']
  if_str: '<intro>'
  type: str

br-restant:
  # eliminer les br restant en debut de texte
  match: "@^\n<br />@S"
  replace: ''
  if_str: "\n<br"
  priority: -20 # avant !paragraphes

poesie:
  # poesie|poetry
  # utilise une callback
  match: ",<poe(sie|try)>(.*)</poe(sie|try)>,UimsS"
  replace: spip/spip-poesie.yaml
  pick_match: 2
  is_wheel: Y
  if_str: '<poe'
  priority: -40

restaure-tags:
  # voir echappe-tags ci-dessus
  if_chars: "\x1"
  match: ["\x1\x1", "\x1\x2", "\x1\x3", "\x1\x4", "\x1\x5", "\x1\x6", "\x1\x7", "\x1\x8", "\x1\x9", "\x1\x10", "\x1\x11", "\x1\x12", "\x1\x13", "\x1\x14"]
  replace: ['{', '}', '_', '-', '[', ']', '|', '<', '>', '\', '*', '#', '+', '~']
  type: str

echappe-chevron-solitaire:
  # un < qui n'est pas suivi d'une lettre ou d'un / est toujours echappe
  type: preg
  match: "/<(?=[^a-z\/!])/Uims"
  replace: "&lt;"

echappe-chevron-pas-ferme:
  # un < suivi d'une lettre ou d'un / est echappe si il semble mal ferme
  type: preg
  match: "/<([^><\"'!]*)(?=<|$)/Uims"
  replace: "&lt;$1"spip/spip-tableaux.php000064400000000404152524374060011014 0ustar00<?php

if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

include_spip('inc/texte');

/**
 * Callback de traitement de chaque tableau
 *
 * @param array $m
 * @return string
 */
function replace_tableaux($m) {
	return $m[1] . traiter_tableau($m[2]) . $m[3];
}
spip/spip-paragrapher.php000064400000004723152524374060011513 0ustar00<?php

/**
 * Fonctions utiles pour les wheels SPIP sur les paragraphes
 *
 * @SPIP\Textwheel\Wheel\SPIP\Fonctions
 **/

if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

if (!defined('_BALISES_BLOCS')) {
	define('_BALISES_BLOCS',
	'address|applet|article|aside|blockquote|button|center|d[ltd]|div|fieldset|fig(ure|caption)|footer|form|h[1-6r]|hgroup|head|header|iframe|li|map|marquee|nav|noscript|object|ol|pre|section|t(able|[rdh]|body|foot|extarea)|ul|script|style'
	);
}

/**
 * Callback de detection des liens qui contiennent des blocks :
 * dans ce cas il faut traiter le <a> comme un quasi block et fermer/ouvrir les <p> autour du <a>
 *
 * @param string $t
 * @return string
 */
function detecter_liens_blocs(&$t) {

// si une balise bloc est dans le liens, on y a aussi ajoute un <p>, il suffit donc de detecter ce dernier
	if (strpos($t[2], "<p>") !== false) {
		return "<STOP P>" . $t[1] . "<p>" . $t[2] . "</p>" . $t[3] . "\n<p>";
	}

return $t[0];
}

/**
 * Callback fermer-para-mano
 *
 * On refait le preg, à la main
 *
 * @param string $t
 * @return string
 */
function fermer_para_mano(&$t) {
	# match: ",<p (.*)<(/?)(stop p|address|applet|article|aside|blockquote|button|center|d[ltd]|div|fieldset|fig(ure|caption)|footer|form|h[1-6r]|hgroup|head|header|iframe|li|map|marquee|nav|noscript|object|ol|pre|section|t(able|[rdh]|body|foot|extarea)|ul|script|style)\b,UimsS"
	# replace: "\n<p "+trim($1)+"</p>\n<$2$3"

foreach (array('<p ' => "</p>\n", '<li' => "<br-li/>") as $cut => $close) {
		if (strpos($t, $cut) !== false) {
			foreach (explode($cut, $t) as $c => $p) {
				if ($c == 0) {
					$t = $p;
				} else {
					$pi = strtolower($p);
					if (preg_match(
						",</?(?:stop p|" . _BALISES_BLOCS . ")\b,S",
						$pi, $r)) {
						$pos = strpos($pi, $r[0]);
						$t .= $cut . str_replace("\n", _AUTOBR . "\n",
								($close ? rtrim(substr($p, 0, $pos)) : substr($p, 0, $pos))) . $close . substr($p, $pos);
					} else {
						$t .= $cut . $p;
					}
				}
			}
		}
	}

if (strpos($t, "<br-li/>") !== false) {
		$t = str_replace("<br-li/></li>", "</li>", $t); // pour respecter les non-retour lignes avant </li>
		$t = str_replace("<br-li/><ul>", "<ul>", $t); // pour respecter les non-retour lignes avant <ul>
		$t = str_replace("<br-li/>", "\n", $t);
	}
	if (_AUTOBR) {
		$t = str_replace(_AUTOBR . "\n" . "<br", "\n<br", $t); #manque /i
		$reg = ',(<(p|br|li)\b[^>]*>\s*)' . preg_quote(_AUTOBR . "\n", ',') . ",iS";
		$t = preg_replace($reg, '\1' . "\n", $t);
	}

return $t;
}
spip/spip-tableaux.yaml000064400000000627152524374060011176 0ustar00--- # Syntaxe des raccourcis SPIP, version 0.0.1
    #
    # Si on nomme une regle, elle devient surchargeable

tableaux-init:
  match: "/^\n?[|]/S"
  replace: "\n\n|"

tableaux-start:
  match: "/\n\n+[|]/S"
  replace: "\n\n\n\n|"

tableaux-end:
  match: "/[|](\n\n+|\n?$)/S"
  replace: "|\n\n\n\n"

tableaux-middle:
  match: "/([^|])(\n[|].*[|]\n)([^|])/UmsS"
  replace: replace_tableaux
  is_callback: Y
spip/echappe-js.php000064400000001754152524374060010266 0ustar00<?php

/**
 * Fonctions utiles pour la wheel echappe-js
 *
 * @SPIP\Textwheel\Wheel\SPIP\Fonctions
 **/

if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

function echappe_anti_xss($match) {
	static $safehtml;

if (!is_array($match) or !strlen($match[0])) {
		return "";
	}
	$texte = &$match[0];

// on echappe les urls data: javascript: et tout ce qui ressemble
	if (strpos($texte, ":") !== false
		and preg_match(",(data|script)\s*:,iS", $texte)
	) {
		$texte = nl2br(htmlspecialchars($texte));
	} // on echappe si on a possiblement un attribut onxxx et que ca passe pas dans safehtml
	elseif (stripos($texte, "on") !== false
		and preg_match(",\bon\w+\s*=,i", $texte)
	) {
		if (!isset($safehtml)) {
			$safehtml = charger_fonction('safehtml', 'inc', true);
		}
		if (!$safehtml or strlen($safehtml($texte)) !== strlen($texte)) {
			$texte = nl2br(htmlspecialchars($texte));
		}
	}

if (strpos($texte, "<") === false) {
		$texte = "<code class=\"echappe-js\">$texte</code>";
	}

return $texte;
}
spip/spip-listes.yaml000064400000003575152524374060010701 0ustar00--- # Syntaxe des raccourcis SPIP, version 0.0.1
    #
    # Si on nomme une regle, elle devient surchargeable

-
  if_match: "/\n-[*#]/S"
  type: all
  is_wheel: Y
  replace:

listes-decoupe-para:
      match: "\n\n"
      type: split
      is_wheel: Y
      replace:
    
        liste-check:
          if_str: "-"
          if_match: "/-[*#]/S"
          is_wheel: Y
          type: all
          replace:
            liste-prepend:
              type: all
              replace: "\n$0"
            liste-p-init:
              type: all
              replace: tw_liste_init
              is_callback: Y
            liste-p-item:
              # premiere parenthese ne compte pas dans la profondeur
              # capture * deuxieme parenthese : ul
              # capture # deuxieme parenthese : ol
              # nombre de car dans la 2eme  parenthese = profondeur
              match: ",(\n-)(\*+|\#+)([^*#].*)?(?=(?:\z|\n-)),UsS"
              replace: tw_liste_item
              is_callback: Y
            liste-p-close:
              type: all
              replace: tw_liste_close
              is_callback: Y

# Feu les dl/dt/dd via -? -! cf https://core.spip.net/issues/1934
definitions-disabled:
  if_match: "/\n-(&nbsp;)?[\?!]\s/S"
  type: all
  disabled: Y
  is_wheel: Y
  replace:
    listes-decoupe-para2:
      match: "\n\n"
      type: split
      is_wheel: Y
      replace:
        def-check:
          if_str: "-"
          if_match: "/-(&nbsp;)?[!\?]\s/S"
          is_wheel: Y
          type: all
          replace:
            def-wrap:
              type: all
              is_callback: Y
              replace: tw_def_wrap
            def-p-titre:
              match: ",(\n-(&nbsp;)?\?\s+)(.*)(?=(\z|\n-)),UsS"
              replace: "<dt>$3</dt>"
            def-p-desc:
              match: ",(\n-(&nbsp;)?!\s+)(.*)(?=(<dt>|</dl>|\z|\n-)),UsS"
              replace: "<dd>$3</dd>"

spip/ecrire.yaml000064400000000160152524374060007661 0ustar00--- # Syntaxe des raccourcis SPIP, version 0.0.1
    #
    # Si on nomme une regle, elle devient surchargeable

spip/interdire-scripts.yaml000064400000001150152524374060012062 0ustar00--- # Syntaxe des raccourcis SPIP, version 0.0.1
    #
    # Si on nomme une regle, elle devient surchargeable

securite-asp:
  type: str
  match: "<%"
  replace: "&lt;%"

securite-php:
  type: str
  match: "<?"
  replace: "&lt;?"

securite-script-php:
  if_str: "<script"
  type: preg
  match: "/<(script\b[^>]+\blanguage\b[^\w>]+php\b)/UimsS"
  replace: "&lt;$1"

securite-base:
  if_str: "<base"
  type: preg
  match: "/<base\b/iS"
  replace: "&lt;base"
spip/spip-listes.php000064400000005162152524374060010520 0ustar00<?php

if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}
# not useful as this file is included by the engine itself
# require_once 'engine/textwheel.php';

function tw_liste_init($t) {
	charger_fonction('dummy', 'inc', true); // ne sert a rien mais evite un segmentation fault PHP, on dirait
	return tw_liste_item($t, 'init');
}

function tw_liste_close($t) {
	return tw_liste_item($t, 'close');
}

function tw_liste_item($t, $quoi = 'item') {
	global $class_spip, $class_spip_plus;
	static $niveau;
	static $pile_li;
	static $pile_type;
	static $type;

switch ($quoi) {
		case 'init':
			$niveau = 0;
			$pile_li = array();
			$pile_type = array();
			$type = '';
			break;
		case 'close':
			// retour sur terre
			$ajout = '';
			while ($niveau > 0) {
				$ajout .= $pile_li[$niveau];
				$ajout .= $pile_type[$niveau];
				$niveau--;
			}
			$t .= $ajout;
			break;

case 'ul':
		case 'ol':
			$nouv_type = $quoi;
			break;

case 'item':
		default:
			$profond = 0;
			if ($l = strlen($t[2])) {
				$profond = $l;
				$nouv_type = 'ul';
				if (strncmp($t[2], '#', 1) == 0) {
					$nouv_type = 'ol';
				}
			}

if ($profond > 0) {
				$ajout = '';

// changement de type de liste au meme niveau : il faut
				// descendre un niveau plus bas, fermer ce niveau, et
				// remonter
				$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 = $t[1];  // puce normale ou <hr>
			}

if (!isset($t[3]) or (trim($t[3]) === '')) {
				// Permet de gerer la previsualisation grand ecran en temps reel en affichant correctement la derniere puce n'ayant pas encore de texte
				$t[3] = '&nbsp;';
			}
			$t = $ajout . $t[3];
			break;
	}

return $t;
}

function tw_def_wrap($t) {
	global $class_spip_plus;

return "<dl$class_spip_plus>\n$t</dl>\n";
}
spip/spip-paragrapher.yaml000064400000005760152524374060011670 0ustar00--- # paragrapher un texte contenant des <p> mal fermes
    #

paragrapher-init-trim:
    # trim
    type: all
    is_callback: y
    replace: trim

toujours-paragrapher:
    # Ajouter un <p> au debut pour assurer d'avoir toujours un paragraphe
    # annuler cette regle pour revenir a l'ancien comportement de SPIP
    type: all
    replace: "<p>$0"

liens-block:
    # en HTML5, les <a> peuvent contenir une balise block
    if_str: "</a>"
    type: preg
    match: ",(<a\s[^>]*>)(.*)(</a>),Uims"
    is_callback: Y
    replace: detecter_liens_blocs

li-ouvrir:
    # toujours ouvrir un parapgraphe quand on ouvre une liste ?
    # desactive
    if_str: "<li"
    match: ",<li[^>]*>\s*?,UimsS"
    replace: "$0<p>"
    disabled: Y

ajouter-stop-p1:
    # Ajouter un espace aux <p> et un "STOP P"
    # transformer aussi les </p> existants en <p>, nettoyes ensuite
    if_str: "<p>"
    #if_match: ",<p\b,iS"
    match: "/^.*$/msS"
    replace: "<p>$0<STOP P>"

ajouter-stop-p2:
    if_str: "<"
    #if_match: ",<p\b,iS"
    match: ",</?p\b\s?(.*?)>,iS"
    replace: "<STOP P><p $1>"

fermer-para-mano:
    # Fermer les paragraphes
    # en reperant les balises blocs XHTML
    # optimise a la mano
    type: all
    is_callback: Y
    replace: fermer_para_mano

supprimer-stop-p:
    # Supprimer les marqueurs "STOP P"
    match: "<STOP P>"
    replace: ''
    type: str

## inutile
#reduire-blancs1:
#    # Reduire les blancs dans les <p> 1/2
#    match: ",(<p [^>]*>)\s*,UiuS"
#    replace: "$1"
#    disabled: Y

suppr-para-presque-vides:
    # Supprimer les <p xx></xx></p> (ne contiennent qu'une balise ouvrante/fermante)
    match: ",<p [^>]*>(<(?:/\w+|\w+[^>]*[^/])>)</p>,S"
    replace: "$1"

suppr-para-vides:
    # Supprimer les <p xx></p> vides
    match: ",<p [^>]*>\s*</p>\s*,S"
    replace: ""

## desormais implemente sous forme du \s* de fermer-para
#reduire-blancs2:
#    # Reduire les blancs dans les <p> 2/2
#    match: ",\s*</p\b,UiuS"
#    replace: "</p"
#    disabled: Y

renommer-para-normaux:
    # Renommer les paragraphes normaux
    match: ["\n<p >", "<p >"]
    replace: ["\n<p>", "\n<p>"]
    type: str
spip/spip.php000064400000002055152524374060007215 0ustar00<?php

/**
 * Fonctions utiles pour les wheels SPIP
 *
 * @SPIP\Textwheel\Wheel\SPIP\Fonctions
 **/

if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

include_spip('inc/texte');

/**
 * Callback pour les <math></math>
 * Gestion du TeX
 *
 * @param string $t
 * @return string
 */
function replace_math($t) {
	if (!function_exists('traiter_math')) {
		include_spip('inc/math');
	}

$t = traiter_math($t, '', true);

return $t;
}

/**
 * Callback pour la puce qui est définissable/surchargeable
 *
 * @return string
 *     Code HTML d'une puce
 */
function replace_puce() {
	static $puce;
	if (!isset($puce)) {
		$puce = "\n<br />" . definir_puce() . "&nbsp;";
	}

return $puce;
}

/**
 * Callback pour les Abbr
 *
 * @example
 *     ```
 *     [ABBR|abbrevation]
 *     [ABBR|abbrevation{lang}]
 *     ```
 * @param array $m
 * @return string
 *     Code HTML d'une abréviation
 */
function inserer_abbr($m) {
	$title = attribut_html($m[2]);
	$lang = (isset($m[3]) ? " lang=\"" . $m[3] . "\"" : "");

return "<abbr title=\"$title\"$lang>" . $m[1] . "</abbr>";
}

/home/checkyd/www/a3056/../7eda3/../7b5d0/Maildir/../wheels.tar