<?php

//////////////////////////////////////////////////////////////////////////////
//
//              Parsing des squelettes
//
//////////////////////////////////////////////////////////////////////////////


class Texte {
	var $type = 'texte';
	var $texte;
}

class Champ {
	var $type = 'champ';
	var $nom_champ, $id_champ;
	var $cond_avant, $cond_apres; // tableaux d'objets
	var $fonctions;
}

class Boucle {
	var $type = 'boucle';
	var $id_boucle, $id_parent;
	var $avant, $cond_avant, $milieu, $cond_apres, $cond_altern, $apres; // tableaux d'objets
	var $commande;
	var $requete;
	var $type_requete;
	var $separateur;
	var $doublons;
	var $hash = false ;
	var $partie, $total_parties;
}

class Requete {
  var $select; //tableau
  var $from;   //tableau
  var $where;  //tableau
  var $group;
  var $limit;
  var $order;
  var $table;
  var $id_objet;
  var $date = "date" ;
  var $lien = false;
  var $tout = false;
  var $plat = false;
}

// détermination de la table SQL à consulter et des champs à y prélever
// (tous, sauf pour celle des articles où on évite de charger le corps
// de ceux-ci lorsqu'ils ne sont pas demandés dans le corps de boucle)

function pre_proces_type($type, $req, $milieu)
{
  switch($type) {
  case 'articles':
    $req->table = "articles";
    $req->select[] = 
		"articles.id_article,articles.id_rubrique,articles.id_secteur,
articles.surtitre,articles.titre,articles.soustitre,
articles.date,articles.date_redac,articles.date_modif,
articles.visites,articles.popularite,
articles.statut,articles.accepter_forum".
      ((ereg('\#INTRODUCTION', $milieu)) ? 
	",articles.texte,articles.chapo,articles.descriptif" :
       ((!(ereg('\#TEXTE', $milieu))) ? "" : 
	 ",articles.texte") .
	((!(ereg('\#CHAPO', $milieu))) ? "" : 
	 ",articles.chapo") .
	((!(ereg('\#DESCRIPTIF', $milieu))) ? "" : 
	 ",articles.descriptif")) .
      (!(ereg('\#PS', $milieu)) ? "" :  ",articles.ps");
    $req->from[] = "spip_articles AS $req->table";
    $req->id_objet = "id_article";
    $req->date = "date";
    break;

  case 'auteurs':
    $req->table = "auteurs";
    $req->select[] = "auteurs.*";
    $req->from[] = "spip_auteurs AS $req->table";
    $req->id_objet = "id_auteur";
    $req->date = "date";
    break;
    
  case 'breves':
    $req->table = "breves";
    $req->select[] = "breves.*";
    $req->from[] = "spip_breves AS $req->table";
    $req->id_objet = "id_breve";
    $req->date = "date_heure";
    break;
    
  case 'forums':
    $req->table = "forums";
    $req->select[] = "forums.*";
    $req->from[] = "spip_forum AS $req->table";
    $req->id_objet = "id_forum";
    $req->date = "date_heure";
    break;
    
  case 'signatures':
    $req->table = "signatures";
    $req->select[] = "signatures.*";
    $req->from[] = "spip_signatures AS $req->table";
    $req->id_objet = "id_signature";
    $req->date = "date_time";
    break;
    
  case 'documents':
    $req->table = "documents";
    $req->select[] = "$req->table.*";
    $req->select[] = "types_d.titre AS type_document";
    $req->select[] = "types_d.extension AS extension_document";
    $req->from[] = "spip_documents AS $req->table";
    $req->from[] = "spip_types_documents AS types_d";
    $req->where[] = "$req->table.id_type = types_d.id_type";
    $req->id_objet = "id_document";
    $req->date = "date";
    break;
    
  case 'types_documents':
    $req->table = "types_documents";
    $req->select[] = "types_documents.*";
    $req->from[] = "spip_types_documents AS $req->table";
    $req->id_objet = "id_type";
    $req->date = "date";
    break;
    
  case 'groupes_mots':
    $req->table = "groupes_mots";
    $req->select[] = "groupes_mots.*";
    $req->from[] = "spip_groupes_mots AS $req->table";
    $req->id_objet = "id_groupe";
    $req->date = "date";
    break;
    
  case 'mots':
    $req->table = "mots";
    $req->select[] = "mots.*";
    $req->from[] = "spip_mots AS $req->table";
    $req->id_objet = "id_mot";
    $req->where[] = "$req->table.titre<>'kawax'";
    $req->date = "date";
    break;
    
  case 'rubriques':
    $req->table = "rubriques";
    $req->select[] = "rubriques.*";
    $req->from[] = "spip_rubriques AS $req->table";
    $req->id_objet = "id_rubrique";
    $req->date = "date";
    break;
    
  case 'syndication':
    $req->table = "syndic";
    $req->select[] = "syndic.*";
    $req->from[] = "spip_syndic AS $req->table";
    $req->where[] = "$req->table.statut='publie'";
    $req->id_objet = "id_syndic";
    $req->date = "date";
    break;
    
  case 'syndic_articles':
    $req->table = "articles";
    $req->select[] = "articles.*";
    $req->from[] = "spip_syndic_articles AS $req->table";
    $req->from[] = "spip_syndic AS source";
    $req->where[] = "$req->table.id_syndic=source.id_syndic";
    $req->where[] = "$req->table.statut='publie'";
    $req->where[] = "source.statut='publie'";
    $req->id_objet = "id_syndic_article";
    $req->date = "date";
    break;
  }
}

// détermination finale des champs de la requete

function post_proces_type($type, $req)
{
  switch($type) {
  case 'articles':
    if (lire_meta("post_dates" == 'non')) 
      $req->where[] = "$req->table.date<NOW()";
    $req->where[] = "$req->table.statut='publie'";
    break;
  case 'groupes_mots':
    // pas de restriction sur les groupes de_mots
    break;
    
  case 'mots':
    // pas de restriction sur les mots
    break;
    
  case 'breves':
    $req->where[] = "$req->table.statut='publie'";
    break;
    
  case 'rubriques':
    $req->where[] = "$req->table.statut='publie'";
    break;
    
  case 'forums':
    // Par defaut, selectionner uniquement les forums sans pere
    if (!$req->tout AND !$req->plat) $req->where[] = "$req->table.id_parent=0";
    $req->where[] = "$req->table.statut='publie'";
    break;
    
  case 'signatures':
    $req->from[] = 'spip_petitions AS petitions';
    $req->from[] = 'spip_articles AS articles';
    $req->where[] = "petitions.id_article=articles.id_article";
    $req->where[] = "petitions.id_article=$req->table.id_article";
    $req->where[] = "$req->table.statut='publie'";
    $req->group = "\nGROUP BY $req->table.$req->id_objet";
    break;
    
  case 'syndic_articles':
    $req->select[]='syndic.nom_site AS nom_site';
    $req->select[]='syndic.url_site AS url_site';
    $req->from[]='spip_syndic AS syndic';
    $req->where[] = "syndic.id_syndic=$req->table.id_syndic";
    break;
    
  case 'documents':
    $req->where[] = "$req->table.taille > 0";
    break;
    
  case 'auteurs':
    // Si pas de lien avec un article, selectionner
    // uniquement les auteurs d'un article publie
    if (!$req->lien) {
      $req->from[] = 'spip_auteurs_articles AS lien';
      $req->from[] = 'spip_articles AS articles';
      $req->where[] = "lien.id_auteur=$req->table.id_auteur";
      $req->where[] = "lien.id_article=articles.id_article";
      $req->where[] = "articles.statut='publie'";
      $req->group = "\nGROUP BY $req->table.$req->id_objet";
    }
    // pas d'auteurs poubellises
    $req->where[] = "NOT($req->table.statut='5poubelle')";
    break;
  }
}

function parser_params($type, $params, $req, $result)
{
 global $tables_relations,$trace;
 
	    // Parametres : premiere passe
 $orig = $params;
 $params2 = ""; $i=0;

# [[:space:]] ne semble pas fiable...
 while (preg_match('/^[ \t\n]*\{[ \t\n]*([^{}]*[^{} \t\n])[ \t\n]*\}[ \t\n]*(.*)$/',
	     $params,
	     $args)) {
      $param = $args[1];
      $i++;
      $params = $args[2];
      if ($param == 'exclus') {
	$req->where[] = "$req->table.$req->id_objet!=\$$req->id_objet";
      }
      else if ($param == 'tout') {
	$req->tout = true;
      }
      else if ($param == 'plat') {
	$req->plat = true;
      }
      else if ($param == 'unique' OR $param == 'doublons') {
	$result->doublons = 'oui';
	$req->where[] = "$req->table.$req->id_objet NOT IN (\$id_doublons[$type])";
      }
      else if (ereg('^ *"([^"]*)" *$', $param, $match)) {
	$result->separateur = ereg_replace("'","\'",$match[1]);
      }
      else if (ereg('^([0-9]+),([0-9]*)$', $param, $match)) {
	$req->limit = $match[1].','.$match[2];
      }
      else if (ereg('^debut([-_a-zA-Z0-9]+),([0-9]*)$', $param, $match)) {
	$debut_lim = "debut".$match[1];
	$req->limit = '".intval($GLOBALS[\'HTTP_GET_VARS\'][\''.$debut_lim.'\']).",'.$match[2];
      }
      else if (ereg('^([0-9]+)/([0-9]+)$', $param, $match)) {
	$result->partie = $match[1];
	$result->total_parties = $match[2];
      }
      else if ($param == 'recherche') {
	if ($type == 'syndication') $req->from[] = "spip_index_syndic AS idx";
	else $req->from[] = "spip_index_$type AS idx";
	$req->select[] = "SUM(idx.points) AS points";
	$req->where[] = "idx.$req->id_objet=$req->table.$req->id_objet";
	$req->group = "\nGROUP BY $req->table.$req->id_objet";
	$req->where[] = "idx.hash IN (\$hash_recherche)";
	$result->hash = true;
      }
      else $params2[] = $param;
  }
	    // Parametres : deuxieme passe

  if ($params2) {
    reset($params2);
    while (list(, $param) = each($params2)) {
      
      // Classement par ordre inverse
      if ($param == 'inverse') {
	if ($req->order) $req->order .= ' DESC';
      }
      
      // Special rubriques
      else if ($param == 'meme_parent') {
	$req->where[] = "$req->table.id_parent=\$id_parent";
	if ($type == 'forums') {
	  $req->where[] = "$req->table.id_parent > 0";
	  $req->plat = true;
	}
      }
      else if ($param == 'racine') {
	$req->where[] = "$req->table.id_parent=0";
      }
      else if ($param == 'branche') {
	$req->where[] = "$req->table.id_rubrique IN (\".calcul_branche(\$id_rubrique).\")";
      }
      
      // Restriction de valeurs (implicite ou explicite)
      else if (ereg('^([a-zA-Z_]+) *((!?)(<=?|>=?|==?) *"?([^<>=!"]*))?"?$', $param, $match)) {
	// Variable comparee
	$col = $match[1];
	$col_table = $req->table;
	
	// Valeur de comparaison
	if ($match[2])
	  $val = $match[5];
	else {
	  $val = $match[1];
	  // Si id_parent, comparer l'id_parent avec l'id_objet de la boucle superieure
	  if ($val == 'id_parent')
	    $val = $req->id_objet;
	  // Si id_enfant, comparer l'id_objet avec l'id_parent de la boucle superieure
	  else if ($val == 'id_enfant')
	    $val = 'id_parent';
	  $val = '$'.$val;
	}
	
	// Traitement general des relations externes
	if ($s = $tables_relations[$type][$col]) {
	  $col_table = "rel_$type";
	  $req->from[] = "$s AS $col_table";
	  $req->where[] = "$req->table.$req->id_objet=$col_table.$req->id_objet";
	  $req->group = "\nGROUP BY $req->table.$req->id_objet";
	  $req->lien = true;
	}
	// Cas particulier pour les raccourcis 'type_mot' et 'titre_mot'
	else if ($type != 'mots' AND ($col == 'type_mot' OR $col == 'titre_mot' OR $col == 'id_groupe')) {
	  if ($type == 'forums')
	    $col_lien = "spip_mots_forum";
	  else if ($type == 'syndication')
	    $col_lien = "spip_mots_syndic";
	  else
	    $col_lien = 'spip_mots_'.$type;
	  $req->from[] = "$col_lien AS lien_mot";
	  $req->from[] = 'spip_mots AS mots';
	  $req->where[] = "$req->table.$req->id_objet=lien_mot.$req->id_objet";
	  $req->where[] = "lien_mot.id_mot=mots.id_mot";
	  $req->group = "\nGROUP BY $req->table.$req->id_objet";
	  $col_table = 'mots';
	  $req->lien = true;
	  if ($col == 'type_mot')
	    $col = 'type';
	  else if ($col == 'titre_mot')
	    $col = 'titre';
	  else if ($col == 'id_groupe')
	    $col = 'id_groupe';
	}
	
	// Cas particulier : selection des documents selon l'extension
	if ($type == 'documents' AND $col == 'extension') {
	  $col_table = 'types_d';
	}
	// HACK : selection des documents selon mode 'image' (a creer en dur dans la base)
	else if ($type == 'documents' AND $col == 'mode' AND $val == 'image') {
	  $val = 'vignette';
	}
	// Cas particulier : lier les articles syndiques au site correspondant
	else if ($type == 'syndic_articles' AND $col<>'id_syndic_article')
	  $col_table = 'source';
	
	// Cas particulier : id_enfant => utiliser la colonne id_objet
	if ($col == 'id_enfant')
	  $col = $req->id_objet;
	// Cas particulier : id_secteur = id_rubrique pour certaines tables
	else if (($type == 'breves' OR $type == 'forums') AND $col == 'id_secteur')
	  $col = 'id_rubrique';
	
	// Cas particulier : expressions de date
	if (ereg("^(date|mois|annee|age|age_relatif|jour_relatif|mois_relatif|annee_relatif)(_redac)?$", $col, $regs)) {
	  $col = $regs[1];
	  if ($regs[2]) {
	    $date_orig = "$req->table.date_redac";
	    $date_compare = 'date_redac';
	  }
	  else {
	    $date_orig = "$req->table.$req->date";
	    $date_compare = 'date';
	  }
	  
	  if ($col == 'date')
	    $col = $date_orig;
	  else if ($col == 'mois') {
	    $col = "MONTH($date_orig)";
	    $col_table = '';
	  }
	  else if ($col == 'annee') {
	    $col = "YEAR($date_orig)";
	    $col_table = '';
	  }
	  else if ($col == 'age') {
	    $col = "(LEAST((UNIX_TIMESTAMP(now())-UNIX_TIMESTAMP($date_orig))/86400, TO_DAYS(now())-TO_DAYS($date_orig), DAYOFMONTH(now())-DAYOFMONTH($date_orig)+30.4368*(MONTH(now())-MONTH($date_orig))+365.2422*(YEAR(now())-YEAR($date_orig))))";
	    $col_table = '';
	  }
	  else if ($col == 'age_relatif') {
	    $col = "LEAST((UNIX_TIMESTAMP('\$$date_compare')-UNIX_TIMESTAMP($date_orig))/86400, TO_DAYS('\$$date_compare')-TO_DAYS($date_orig), DAYOFMONTH('\$$date_compare')-DAYOFMONTH($date_orig)+30.4368*(MONTH('\$$date_compare')-MONTH($date_orig))+365.2422*(YEAR('\$$date_compare')-YEAR($date_orig)))";
	    $col_table = '';
	  }
	  else if ($col == 'jour_relatif') {
	    $col = "LEAST(TO_DAYS('\$$date_compare')-TO_DAYS($date_orig), DAYOFMONTH('\$$date_compare')-DAYOFMONTH($date_orig)+30.4368*(MONTH('\$$date_compare')-MONTH($date_orig))+365.2422*(YEAR('\$$date_compare')-YEAR($date_orig)))";
	    $col_table = '';
	  }
	  else if ($col == 'mois_relatif') {
	    $col = "(MONTH('\$$date_compare')-MONTH($date_orig)+12*(YEAR('\$$date_compare')-YEAR($date_orig)))";
	    $col_table = '';
	  }
	  else if ($col == 'annee_relatif') {
	    $col = "YEAR('\$$date_compare')-YEAR($date_orig)";
	    $col_table = '';
	  }
	}
	
	if ($type == 'forums' AND ($col == 'id_parent' OR $col == 'id_forum'))
	  $req->plat = true;
	
	// Operateur de comparaison
	if ($match[4]) {
	  $op = $match[4];
	  if ($op == '==') $op = ' REGEXP ';
	}
	else {
	  $op = '=';
	}
	
	if ($col_table) $col_table .= '.';
	$where = "$col_table$col$op'".addslashes($val)."'";
	if ($match[3] == '!') $where = "NOT ($where)";
	$req->where[] = $where;
      }
      
      // Selection du classement
      else if (ereg('^par[[:space:]]+([^}]*)$', $param, $match)) {
	$tri = trim($match[1]);
	if ($tri == 'hasard') { // par hasard
	  $req->select[] = "MOD($req->table.$req->id_objet * UNIX_TIMESTAMP(), 32767) & UNIX_TIMESTAMP() AS alea";
	  $req->order = "\nORDER BY alea";
	}
	else if ($tri == 'titre_mot'){ // par titre_mot
	  $req->order= "\nORDER BY mots.titre";
	}
	else if ($tri == 'type_mot'){ // par type_mot
	  $req->order= "\nORDER BY mots.type";
	}
	else if ($tri == 'points'){ // par points
	  $req->order= "\nORDER BY points";
	}
	else if (ereg("^num[[:space:]]+([^,]*)(,.*)?",$tri, $match2)) { // par num champ
	  $req->select[] = "0+$req->table.".$match2[1]." AS num";
	  $req->order = "\nORDER BY num".$match2[2];
	}
	else if (ereg("^[a-z0-9]+$", $tri)) { // par champ
	  $col = $tri;
	  if ($col == 'date') $col = $req->date;
	  $req->order = "\nORDER BY $req->table.$col";
	}
	else { // tris bizarres, par formule composee, virgules, etc.
	  $req->order = "\nORDER BY ".$tri;
	}
      }
      else {	include_ecrire ("inc_presentation.php3");
		install_debut_html("Paramètre incorrect");
		echo '<p>Le paramètre<FONT color="#FF000"> ' . 
		  entites_html($param) .
		  '</FONT> est incorrect dans <FONT color="#FF000">' .
		  entites_html($orig) .
		  '</FONT>.'; 
		install_fin_html();
		exit;
      }

    }
  }
}

// analyse de la pseudo-balise BOUCLE

function parser_boucle($texte, $id_parent) {

	// Detecter la boucle

	$p = strpos($texte, '<BOUCLE');
	if (!$p && (substr($texte, 0, strlen('<BOUCLE')) != '<BOUCLE')) {
		$result = new Texte;
		$result->texte = $texte;
		return $result;
	}

	$result = new Boucle;
	$result->id_parent = $id_parent;

	$debut = substr($texte, 0, $p);
	$milieu = substr($texte, $p);

	if (!ereg("^<BOUCLE([0-9]+|[-_][-_.a-zA-Z0-9]*)[[:space:]]*\(([^)]*)\)[[:space:]]*(([[:space:]]*\{[^}]*\})*)[[:space:]]*>", $milieu, $match)) {
		include_ecrire ("inc_presentation.php3");
		install_debut_html("Boucle incorrecte");
		echo '<p>La boucle ' . entites_html($milieu) . ' est incorrecte.';
		install_fin_html();
		exit;
	}

	$commande = $match[0];
	$id_boucle = $match[1];
	$nom = $match[2];
	$params = $match[3];

	// Decomposer les structures conditionnelles

	$s = "<B$id_boucle>";

	$p = strpos($debut, $s);
	if ($p || (substr($debut, 0, strlen($s)) == $s)) {
		$cond_avant = substr($debut, $p + strlen($s));
		$debut = substr($debut, 0, $p);
	}

	$milieu = substr($milieu, strlen($commande));
	$s = "</BOUCLE$id_boucle>";
	$p = strpos($milieu, $s);
	if ((!$p) && (substr($milieu, 0, strlen($s)) != $s)) die("<h2>BOUCLE$id_boucle: tag fermant manquant</h2>");

	$fin = substr($milieu, $p + strlen($s));
	$milieu = substr($milieu, 0, $p);

	$s = "</B$id_boucle>";
	$p = strpos($fin, $s);
	if ($p || (substr($fin, 0, strlen($s)) == $s)) {
		$cond_fin = substr($fin, 0, $p);
		$fin = substr($fin, $p + strlen($s));
	}

	$s = "<//B$id_boucle>";
	$p = strpos($fin, $s);
	if ($p || (substr($fin, 0, strlen($s)) == $s)) {
		$cond_altern = substr($fin, 0, $p);
		$fin = substr($fin, $p + strlen($s));
	}

	$result->commande = $commande;
	$result->avant = $debut;
	$result->apres = $fin;
	$result->id_boucle = ereg_replace("-","_",$id_boucle);

	// Déterminer le type de la boucle

	$type = strtolower($nom);
	if (substr($type, 0, 6) == 'boucle') {
	  // Récursion: pas de paramètre, donc presque rien à faire  
	  $result->type_requete = 'boucle';
	  $result->requete = substr($nom, 6);
	} else {
	  if ($type == 'sites') $type = 'syndication';
	  $req = new Requete;
	  $result->type_requete = $type;

	  pre_proces_type($type, &$req, $milieu);

	  // analyser les paramètres

	    parser_params($type, $params, &$req, &$result);
			  
	  // exploitation de l'analyse des paramètres

	  post_proces_type($type, &$req);

	  // HACK: hierarchie a une requete construite dynamiquement

	  if ($type == 'hierarchie') 
	    $result->requete =   $req->limit ;
	  else if ($req->select) 
	    $result->requete = 
	      ("\nSELECT\t".
	       join(",\n\t", $req->select).
	       "\nFROM\t".
		   join(",\n\t", $req->from) .
	       ((!$req->where) ? "" : 
		("\nWHERE\t".join("\n AND\t", $req->where))) .
	       $req->group .
	       $req->order .
	       ((!$req->limit) ? "" : ("\nLIMIT\t".$req->limit)));
	}

	$result->cond_avant = parser_texte($cond_avant, $id_parent);
	$result->cond_apres = parser_texte($cond_fin, $id_parent);
	$result->cond_altern = parser_texte($cond_altern, $id_parent);
	$result->milieu = parser_texte($milieu, $id_boucle);
	
	return $result;
}


function parser_champs($texte) {
	global $champs;
	global $champs_count;
	global $champs_valides;
	global $champs_traitement;
	global $champs_pretraitement;
	global $champs_posttraitement;

	$debut = '';
	$result=Array();
	while ($texte) {
		$r = ereg('(#([a-zA-Z_]+)(\*?))', $texte, $regs);
		if ($r) {
			unset($champ);
			$nom_champ = $regs[2];
			$flag_brut = $regs[3];
			$s = $regs[1];
			$p = strpos($texte, $s);
			if ($champs_valides[$nom_champ]) {
				$debut .= substr($texte, 0, $p);
				if ($debut) {
					$champ = new Texte;
					$champ->texte = $debut;
					$result[] = $champ;
				}
				$champ = new Champ;
				$champ->nom_champ = $nom_champ;
				$champ->fonctions = $champs_pretraitement[$nom_champ];
				if (!$flag_brut AND $champs_traitement[$nom_champ]) {
					reset($champs_traitement[$nom_champ]);
					while (list(, $f) = each($champs_traitement[$nom_champ])) {
						$champ->fonctions[] = $f;
					}
				}
				if ($champs_posttraitement[$nom_champ]) {
					reset($champs_posttraitement[$nom_champ]);
					while (list(, $f) = each($champs_posttraitement[$nom_champ])) {
						$champ->fonctions[] = $f;
					}
				}
				$champs_count++;
				$champ->id_champ = $champs_count;
				$champs[$champs_count] = $champ;
				$result[] = $champ;
				$debut = '';
			}
			else {
				$debut .= substr($texte, 0, $p + strlen($s));
			}
			$texte = substr($texte, $p + strlen($s));
		}
		else {
			$champ = new Texte;
			$champ->texte = $debut.$texte;
			if ($champ->texte) $result[] = $champ;
			break;
		}
	}
	return $result;
}


function parser_champs_etendus($texte) {
	global $champs;
	global $champs_count;
	global $champs_valides;
	global $champs_traitement;
	global $champs_pretraitement;
	global $champs_posttraitement;

	$debut = '';
	while ($texte) {
		$r = ereg('(\[([^\[]*)\(#([a-zA-Z_]+)(\*?)([^])]*)\)([^]]*)\])', $texte, $regs);

		if ($r) {
			$cond_avant = $regs[2];
			$nom_champ = $regs[3];
			$flag_brut = $regs[4];
			$fonctions = $regs[5];
			$cond_apres = $regs[6];
			$s = $regs[1];
			$p = strpos($texte, $s);
			if ($champs_valides[$nom_champ]) {
				$debut .= substr($texte, 0, $p);
				if ($debut) {
					$c = parser_champs($debut);
					reset($c);
					while (list(, $val) = each($c)) $result[] = $val;
				}
				$champ = new Champ;
				$champ->nom_champ = $nom_champ;
				$champ->cond_avant = parser_champs($cond_avant);
				$champ->cond_apres = parser_champs($cond_apres);
				$champ->fonctions = $champs_pretraitement[$nom_champ];
				if (!$flag_brut AND $champs_traitement[$nom_champ]) {
					reset($champs_traitement[$nom_champ]);
					while (list(, $f) = each($champs_traitement[$nom_champ])) {
						$champ->fonctions[] = $f;
					}
				}
				if ($champs_posttraitement[$nom_champ]) {
					reset($champs_posttraitement[$nom_champ]);
					while (list(, $f) = each($champs_posttraitement[$nom_champ])) {
						$champ->fonctions[] = $f;
					}
				}

				if ($fonctions) {
					$fonctions = explode('|', substr($fonctions, 1));
					reset($fonctions);
					while (list(, $f) = each($fonctions)) $champ->fonctions[] = $f;
				}
				$champs_count++;
				$champ->id_champ = $champs_count;
				$champs[$champs_count] = $champ;
				$result[] = $champ;
				$debut = '';
			}
			else {
				$debut .= substr($texte, 0, $p + strlen($s));
			}
			$texte = substr($texte, $p + strlen($s));
		}
		else {
			$c = parser_champs($debut.$texte);
			reset($c);
			while (list(, $val) = each($c)) $result[] = $val;
			break;
		}
	}
	return $result;
}

function parser_texte($texte, $id_boucle) {
	global $boucles;

	$i = 0;

	while ($texte) {
		$boucle = parser_boucle($texte, $id_boucle);
		if ($boucle->type == 'texte') {
			if ($c = parser_champs_etendus($boucle->texte)) {
				reset($c);
				while (list(, $val) = each($c)) {
					$result[$i] = $val;
					$i++;
				}
			}
			$texte = '';
		}
		else {
			if ($c = parser_champs_etendus($boucle->avant)) {
				reset($c);
				while (list(, $val) = each($c)) {
					$result[$i] = $val;
					$i++;
				}
			}
			$texte = $boucle->apres;
			$boucle->avant = '';
			$boucle->apres = '';
			$result[$i] = $boucle;
			$i++;
			if (!$boucles[$boucle->id_boucle])
				$boucles[$boucle->id_boucle] = $boucle;
			else die ('<h2>BOUCLE'.$boucle->id_boucle.': double definition</h2>');
		}
	}

	return $result;
}


function parser($texte) {

	global $champs_valides;
	global $champs_traitement, $champs_pretraitement, $champs_posttraitement;
	global $racine;


	//
	// Construire un tableau associatif des codes de champ utilisables
	//

	$c = array('NOM_SITE_SPIP', 'URL_SITE_SPIP', 'EMAIL_WEBMASTER', 'CHARSET',
		'ID_ARTICLE', 'ID_RUBRIQUE', 'ID_BREVE', 'ID_FORUM', 'ID_PARENT', 'ID_SECTEUR', 'ID_DOCUMENT', 'ID_TYPE',
		'ID_AUTEUR', 'ID_MOT', 'ID_SYNDIC_ARTICLE', 'ID_SYNDIC', 'ID_SIGNATURE', 'ID_GROUPE',
		'TITRE', 'SURTITRE', 'SOUSTITRE', 'DESCRIPTIF', 'CHAPO', 'TEXTE', 'PS', 'NOTES', 'INTRODUCTION', 'MESSAGE',
		'DATE', 'DATE_REDAC', 'DATE_MODIF', 'DATE_NOUVEAUTES', 'INCLUS',
		'LESAUTEURS', 'EMAIL', 'NOM_SITE', 'LIEN_TITRE', 'URL_SITE', 'LIEN_URL', 'NOM', 'BIO', 'TYPE', 'PGP',
		'FORMULAIRE_ECRIRE_AUTEUR', 'FORMULAIRE_FORUM', 'FORMULAIRE_SITE', 'PARAMETRES_FORUM', 'FORMULAIRE_RECHERCHE', 'RECHERCHE', 'FORMULAIRE_INSCRIPTION', 'FORMULAIRE_SIGNATURE',
		'LOGO_MOT', 'LOGO_RUBRIQUE', 'LOGO_RUBRIQUE_NORMAL', 'LOGO_RUBRIQUE_SURVOL',
		'LOGO_AUTEUR', 'LOGO_AUTEUR_NORMAL', 'LOGO_AUTEUR_SURVOL', 'LOGO_SITE',  'LOGO_BREVE', 'LOGO_BREVE_RUBRIQUE',  'LOGO_DOCUMENT',
		'LOGO_ARTICLE', 'LOGO_ARTICLE_RUBRIQUE', 'LOGO_ARTICLE_NORMAL', 'LOGO_ARTICLE_SURVOL',
		'URL_ARTICLE', 'URL_RUBRIQUE', 'URL_BREVE', 'URL_FORUM', 'URL_SYNDIC', 'URL_MOT', 'URL_DOCUMENT', 'EMBED_DOCUMENT',
		'IP', 'VISITES', 'POPULARITE', 'POPULARITE_ABSOLUE', 'POPULARITE_MAX', 'POPULARITE_SITE', 'POINTS', 'COMPTEUR_BOUCLE', 'TOTAL_BOUCLE', 'PETITION',
		'LARGEUR', 'HAUTEUR', 'TAILLE', 'EXTENSION',
		'DEBUT_SURLIGNE', 'FIN_SURLIGNE', 'TYPE_DOCUMENT', 'EXTENSION_DOCUMENT',
		'FORMULAIRE_ADMIN', 'LOGIN_PRIVE', 'LOGIN_PUBLIC', 'URL_LOGOUT', 'PUCE'
	);
	reset($c);
	while (list(, $val) = each($c)) {
		unset($champs_traitement[$val]);
		unset($champs_pretraitement[$val]);
		unset($champs_posttraitement[$val]);
		$champs_valides[$val] = $val;
	}


	//
	// Construire un tableau associatif des pre-traitements de champs
	//

	// Textes utilisateur : ajouter la securite anti-script
	$c = array('NOM_SITE_SPIP', 'URL_SITE_SPIP', 'EMAIL_WEBMASTER', 'CHARSET',
		'TITRE', 'SURTITRE', 'SOUSTITRE', 'DESCRIPTIF', 'CHAPO', 'TEXTE', 'PS', 'NOTES', 'INTRODUCTION', 'MESSAGE',
		'LESAUTEURS', 'EMAIL', 'NOM_SITE', 'LIEN_TITRE', 'URL_SITE', 'LIEN_URL', 'NOM', 'IP', 'BIO', 'TYPE', 'PGP',
		'RECHERCHE'
	);
	reset($c);
	while (list(, $val) = each($c)) {
		$champs_pretraitement[$val][] = 'trim';
		$champs_posttraitement[$val][] = 'interdire_scripts';
	}

	// Textes courts : ajouter le traitement typographique
	$c = array('NOM_SITE_SPIP', 'SURTITRE', 'TITRE', 'SOUSTITRE', 'NOM_SITE', 'LIEN_TITRE', 'NOM');
	reset($c);
	while (list(, $val) = each($c)) {
		$champs_traitement[$val][] = 'typo';
	}

	// Chapo : ne pas l'afficher si article virtuel
	$c = array('CHAPO');
	reset($c);
	while (list(, $val) = each($c)) {
		$champs_traitement[$val][] = 'nettoyer_chapo';
	}

	// Textes longs : ajouter le traitement typographique + mise en forme
	$c = array('DESCRIPTIF', 'CHAPO', 'TEXTE', 'PS', 'BIO', 'MESSAGE');
	reset($c);
	while (list(, $val) = each($c)) {
		$champs_traitement[$val][] = 'traiter_raccourcis';
	}

	// Dates : ajouter le vidage des dates egales a 00-00-0000
	$c = array('DATE', 'DATE_REDAC', 'DATE_MODIF', 'DATE_NOUVEAUTES');
	reset($c);
	while (list(, $val) = each($c)) {
		$champs_traitement[$val][] = 'vider_date';
	}

	// URL_SITE : vider les url == 'http://'
	$c = array('URL_SITE_SPIP', 'URL_SITE', 'LIEN_URL');
	reset($c);
	while (list(, $val) = each($c)) {
		$champs_traitement[$val][] = 'vider_url';
	}

	// URLs : remplacer les & par &amp;
	$c = array('URL_SITE_SPIP', 'URL_SITE', 'LIEN_URL', 'PARAMETRES_FORUM',
		'URL_ARTICLE', 'URL_RUBRIQUE', 'URL_BREVE', 'URL_FORUM', 'URL_SYNDIC', 'URL_MOT', 'URL_DOCUMENT');
	reset($c);
	while (list(, $val) = each($c)) {
		$champs_traitement[$val][] = 'htmlspecialchars';
	}

	// Parser le texte et retourner le tableau racine

	$racine = parser_texte($texte, '');
}
?>