Bon, il y avait tout ce qu'il faut pour gérer les notes proprement, mais un...

// Notes de bas de page

//

// argument = true: empiler l'etat courant, initialiser un nouvel etat

// argument = false: restaurer l'etat precedent, denonce un etat courant perdu

// argument chaine, on y recherche les notes et on les renvoie en tableau

// argument tableau,c'est les notes qu'on met en page dans $GLOBALS[les_notes]

// argument tableau, texte de notes a rajouter dans ce qu'on a deja

// le dernier cas retourne la composition totale

// en particulier, envoyer un tableau vide permet de tout recuperer

// C'est stocke dans la globale $les_notes, mais pas besoin de le savoir

function inc_notes_dist($arg)

{	  

	if (is_string($arg))

		return traiter_raccourci_notes($arg);

	else return traiter_les_notes($arg);

	static $pile = array();

	global $les_notes, $compt_note, $notes_vues;

	if (is_string($arg)) return traiter_raccourci_notes($arg, count($pile));

	elseif (is_array($arg)) return traiter_les_notes($arg);

	elseif ($arg === true) {

	  array_push($pile, array(@$les_notes, @$compt_note, $notes_vues));

		$les_notes = '';

		$compt_note = 0;

	} elseif ($arg === false) {

		if ($les_notes) spip_log("notes perdues");

		list($les_notes, $compt_note, $notes_vues) = array_pop($pile);

	}

}

define('_RACCOURCI_NOTES', ', *\[\[(\s*(<([^>\'"]*)>)?(.*?))\]\],msS');

function traiter_raccourci_notes($letexte)

function traiter_raccourci_notes($letexte, $marqueur_notes)

{

	global $compt_note,  $marqueur_notes, $les_notes, $notes_vues;

	global $compt_note,   $les_notes, $notes_vues;

	global $ouvre_ref, $ferme_ref;

	if (!preg_match_all(_RACCOURCI_NOTES, $letexte, $m, PREG_SET_ORDER))

function traiter_les_notes($notes) {

	global $ouvre_note, $ferme_note;

	$mes_notes = '<p>';

	$mes_notes = '';

	if ($notes) {

		$title =  _T('info_notes');

		foreach ($notes as $r) {

			list($ancre, $nom, $texte) = $r;

				: '')

			. $texte;

		}

	$mes_notes= propre($mes_notes);

		$mes_notes = propre('<p>' . $mes_notes);

		if ($GLOBALS['class_spip'])

			$mes_notes = str_replace('<p class="spip">', '<p class="spip_note">', $mes_notes);

	}

	return ($GLOBALS['les_notes'] .= $mes_notes);

}

	$contexte['args'] = $arg_list; // on passe la liste des arguments du modeles dans une variable args

	$contexte = array_merge($contexte,$arg_list);

	// On cree un marqueur de notes unique lie a ce modele

	// et on enregistre l'etat courant des globales de notes...

	$enregistre_marqueur_notes = $GLOBALS['marqueur_notes'];

	$enregistre_les_notes = $GLOBALS['les_notes'];

	$enregistre_compt_note = $GLOBALS['compt_note'];

	$GLOBALS['marqueur_notes'] = substr(md5(serialize($contexte)),0,8);

	$GLOBALS['les_notes'] = '';

	$GLOBALS['compt_note'] = 0;

	// Appliquer le modele avec le contexte

	$retour = recuperer_fond($fond, $contexte);

	// On restitue les globales de notes telles qu'elles etaient avant l'appel

	// du modele. Si le modele n'a pas affiche ses notes, tant pis (elles *doivent*

	// etre dans le cache du modele, autrement elles ne seraient pas prises en

	// compte a chaque calcul d'un texte contenant un modele, mais seulement

	// quand le modele serait calcule, et on aurait des resultats incoherents)

	$GLOBALS['les_notes'] = $enregistre_les_notes;

	$GLOBALS['marqueur_notes'] = $enregistre_marqueur_notes;

	$GLOBALS['compt_note'] = $enregistre_compt_note;

	// Regarder si le modele tient compte des liens (il *doit* alors indiquer

	// spip_lien_ok dans les classes de son conteneur de premier niveau ;

	AND strlen($texte) > 2.5*$longueur)

		$texte = couper($texte, 2*$longueur);

	// ne pas tenir compte des notes ;

	// bug introduit en http://trac.rezo.net/trac/spip/changeset/12025

	foreach(array('les_notes','compt_note','marqueur_notes','notes_vues') as $k)

		if (isset($GLOBALS[$k]))

			$mem[$k] = $GLOBALS[$k];

	// memoriser l'etat de la pile unique

	$mem_unique = unique('','_spip_raz_');

	// ne pas tenir compte des notes

	$notes = charger_fonction('notes', 'inc');

	$notes(true);

	$texte = propre($texte,$connect);

	// restituer les notes comme elles etaient avant d'appeler propre()

	foreach(array('les_notes','compt_note','marqueur_notes','notes_vues') as $k)

		if (isset($mem[$k]))

			$GLOBALS[$k] = $mem[$k];

		else 

			unset($GLOBALS[$k]);

	// restituer l'etat de la pile unique

	unique($mem_unique,'_spip_set_');

	$notes(false);

	@define('_INTRODUCTION_SUITE', ' (...)');

	$texte = couper($texte, $longueur, _INTRODUCTION_SUITE);

}

// fonction appelee par la balise #NOTES

// Renvoyer l'etat courant des notes, le purger et en preparer un nouveau

// http://doc.spip.org/@calculer_notes

function calculer_notes() {

	if (!isset($GLOBALS["les_notes"])) return '';

	if ($r = $GLOBALS["les_notes"]) {

		$GLOBALS["les_notes"] = "";

		$GLOBALS["compt_note"] = 0;

		$GLOBALS["marqueur_notes"] ++;

	}

	$notes = charger_fonction('notes', 'inc');

	$r = $notes(array());

	$notes(false);

	$notes(true);

	return $r;

}

		list($fonc) = $code;

		spip_timer($a = 'calcul page '.rand(0,1000));

		$notes = calculer_notes(); // conserver les notes...

		// On cree un marqueur de notes unique lie a cette composition

		// et on enregistre l'etat courant des globales de notes...

		$notes = charger_fonction('notes', 'inc');

		$notes(true);

		// Rajouter d'office ces deux parametres

		// (mais vaudrait mieux que le compilateur sache le simuler

	// Passer le nom du cache pour produire sa destruction automatique

		$page = $fonc(array('cache' => $cache), array($contexte));

		// ... et les retablir

		if ($n = calculer_notes()) spip_log("notes ignorees par $fonc: $n");

		$GLOBALS['les_notes'] = $notes;

	// Restituer les globales de notes telles qu'elles etaient avant l'appel

	// Si l'inclus n'a pas affiche ses notes, tant pis (elles *doivent*

	// etre dans son resultat, autrement elles ne seraient pas prises en

	// compte a chaque calcul d'un texte contenant un modele, mais seulement

	// quand le modele serait calcule, et on aurait des resultats incoherents)

		$notes(false);

		// spip_log: un joli contexte

		$infos = array();