Subversion Repositories Sites.tela-botanica.org

<?php

/***************************************************************************\

 *  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("_INC_HTML_SQUEL")) return;

define("_INC_HTML_SQUEL", "1");

# Ce fichier doit IMPERATIVEMENT contenir la fonction "phraser"

# qui transforme un squelette en un tableau d'objets de classe Boucle

# il est charge par un include calcule dans inc-calcul-squel

# pour permettre differentes syntaxes en entree

define('BALISE_BOUCLE', '<BOUCLE');

define('BALISE_FIN_BOUCLE', '</BOUCLE');

define('BALISE_PRE_BOUCLE', '<B');

define('BALISE_POST_BOUCLE', '</B');

define('BALISE_ALT_BOUCLE', '<//B');

define('TYPE_RECURSIF', 'boucle');

define('SPEC_BOUCLE','[[:space:]]*\(([^)]*)\)');

define('NOM_DE_BOUCLE', "[0-9]+|[-_][-_.a-zA-Z0-9]*");

# ecriture alambiquee pour rester compatible avec les hexadecimaux des vieux squelettes

define('NOM_DE_CHAMP', "#((" . NOM_DE_BOUCLE . "):)?(([A-F]*[G-Z_][A-Z_0-9]*)|[A-Z_]+)(\*?)");

define('CHAMP_ETENDU', '\[([^]\[]*)\(' . NOM_DE_CHAMP . '([^[)]*\)[^]\[]*)\]');

define('BALISE_INCLURE','<INCLU[DR]E[[:space:]]*\(([^)]*)\)');

function phraser_inclure($texte, $ligne, $result) {

	while (ereg(BALISE_INCLURE, $texte, $match)) {

		$p = strpos($texte,$match[0]);

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

		if ($p) $result = phraser_idiomes($debut, $ligne, $result);

		$ligne +=  substr_count($debut, "\n");

		$champ = new Inclure;

		$champ->ligne = $ligne;

		$ligne += substr_count($match[0], "\n");

		$champ->texte = $match[1];

		$texte = substr($texte, $p+strlen($match[0]));

		// on assimile {var=val} a une liste de un argument sans fonction

		phraser_args($texte,">","",$result,$champ);

		foreach ($champ->param as $k => $v) {

		  $var = $v[1][0];

		  if ($var->type != 'texte')

			erreur_squelette(_T('zbug_parametres_inclus_incorrects'),

					 $match[0]);

		  else {

		    ereg("^([^=]*)(=)?(.*)$", $var->texte,$m);

		    if ($m[2]) {

		      $champ->param[$k][0] = $m[1];

		      $val = $m[3];

		      if (ereg('^[\'"](.*)[\'"]$', $val, $m)) $val = $m[1];

		      $champ->param[$k][1][0]->texte = $val;

		    }

		    else

		      $champ->param[$k] = array($m[1]);

		  }

		}

		$texte = substr($champ->apres,1);

		$champ->apres = "";

		$result[] = $champ;

	}

	return (($texte==="") ? $result : phraser_idiomes($texte, $ligne, $result));

}

function phraser_polyglotte($texte,$ligne, $result) {

	while (eregi('<multi>([^<]*)</multi>', $texte, $match)) {

		$p = strpos($texte, $match[0]);

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

		if ($p) {

			$champ = new Texte;

			$champ->texte = $debut;

			$champ->ligne = $ligne;

			$result[] = $champ;

		}

		$champ = new Polyglotte;

		$ligne += substr_count($champ->texte, "\n");

		$champ->ligne = $ligne;

		$ligne += substr_count($match[0], "\n");

		$lang = '';

		$bloc = $match[1];

		$texte = substr($texte,$p+strlen($match[0]));

		while (preg_match("/^[[:space:]]*([^[{]*)[[:space:]]*[[{]([a-z_]+)[]}](.*)$/si", $bloc, $regs)) {

		  $trad = $regs[1];

		  if ($trad OR $lang)

			$champ->traductions[$lang] = $trad;

		  $lang = $regs[2];

		  $bloc = $regs[3];

		}

		$champ->traductions[$lang] = $bloc;

		$result[] = $champ;

	}

	if ($texte!=="") {

			$champ = new Texte;

			$champ->texte = $texte;

			$champ->ligne = $ligne;

			$result[] = $champ;

	}

	return $result;

}

function phraser_idiomes($texte,$ligne,$result) {

	// Reperer les balises de traduction <:toto:>

	while (eregi("<:(([a-z0-9_]+):)?([a-z0-9_]+)((\|[^:>]*)?:>)", $texte, $match)) {

		$p = strpos($texte, $match[0]);

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

		if ($p) $result = phraser_champs($debut, $ligne, $result);

		$champ = new Idiome;

		$ligne += substr_count($debut, "\n");

		$champ->ligne = $ligne;

		$ligne += substr_count($match[0], "\n");

		$texte = substr($texte,$p+strlen($match[0]));

		$champ->nom_champ = strtolower($match[3]);

		$champ->module = $match[2] ? $match[2] : 'public/spip/ecrire';

		// pas d'imbrication pour les filtres sur langue

		phraser_args($match[5], ":", '', array(), $champ);

		$result[] = $champ;

	}

	if ($texte!=="")  $result = phraser_champs($texte,$ligne,$result);

	return $result;

}

function phraser_champs($texte,$ligne,$result) {

	while (ereg(NOM_DE_CHAMP, $texte, $match)) {

	  $p = strpos($texte, $match[0]);

	  $suite = substr($texte,$p+strlen($match[0]));

	  if ($match[5] || (strpos($suite[0], "[0-9]") === false)) {

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

		if ($p)	$result = phraser_polyglotte($debut, $ligne, $result);

		$ligne += substr_count($debut, "\n");

		$champ = new Champ;

		$champ->ligne = $ligne;

		$ligne += substr_count($match[0], "\n");

		$champ->nom_boucle = $match[2];

		$champ->nom_champ = $match[3];

		$champ->etoile = $match[5];

		$texte = $suite;

		$result[] = $champ;

	  } else {

	    // faux champ

	    $result = phraser_polyglotte (substr($texte, 0, $p+1), $ligne, $result);

	    $texte = (substr($texte, $p+1));

	  }

	}

	if ($texte!=="") $result = phraser_polyglotte($texte, $ligne, $result);

	return $result;

}

// Gestion des imbrications:

// on cherche les [..] les plus internes et on les remplace par une chaine

// %###N@ ou N indexe un tableau comportant le resultat de leur analyse

// on recommence tant qu'il y a des [...] en substituant a l'appel suivant

function phraser_champs_etendus($texte, $ligne,$result) {

	if ($texte==="") return $result;

	$sep = '##';

	while (strpos($texte,$sep)!== false)

		$sep .= '#';

	return array_merge($result, phraser_champs_interieurs($texte, $ligne, $sep, array()));

}

//  Analyse les filtres d'un champ etendu et affecte le resultat

// renvoie la liste des lexemes d'origine augmentee

// de ceux trouves dans les arguments des filtres (rare)

// sert aussi aux arguments des includes et aux criteres de boucles

// Tres chevelu

function phraser_args($texte, $fin, $sep, $result, &$pointeur_champ) {

  $texte = ltrim($texte);

  while (($texte!=="") && strpos($fin, $texte[0]) === false) {

      preg_match(",^(\|?[^{)|]*)(.*)$,ms", $texte, $match);

      $suite = ltrim($match[2]);

      $fonc = trim($match[1]);

      if ($fonc[0] == "|") $fonc = ltrim(substr($fonc,1));

      $res = array($fonc);

      $args = $suite ;

      // cas du filtre sans argument ou du critere /

      if (($suite[0] != '{')  || ($fonc  && $fonc[0] == '/'))

	{

	  // si pas d'argument, alors il faut une fonction ou un double |

	  if (!$match[1])

	    erreur_squelette(_T('zbug_info_erreur_squelette'), $texte);

	  // pas d'arg et pas d'autres filtres ==> critere infixe comme "/"

          if (($fin != ':') &&

	      ((!$suite) || strpos(")|", $suite[0]) === false)) break;

	} else {

	$args = ltrim(substr($suite,1));

	$collecte = array();

	while ($args && $args[0] != '}') {

		if ($args[0] == '"')

			preg_match ('/^(")([^"]*)(")(.*)$/ms', $args, $regs);

		else if ($args[0] == "'")

			preg_match ("/^(')([^']*)(')(.*)$/ms", $args, $regs);

		else {

		  preg_match("/^([[:space:]]*)([^,([{}]*([(\[{][^])}]*[])}])?[^$fin,}]*)([,}$fin].*)$/ms", $args, $regs);

		  if (!strlen($regs[2]))

		    {

		      erreur_squelette(_T('zbug_info_erreur_squelette'), $args);

		      $args = '';

		      exit;

		      }

		}

		$arg = $regs[2];

		if (trim($regs[1])) {

			$champ = new Texte;

			$champ->texte = $arg;

			$champ->apres = $champ->avant = $regs[1];

			$result[] = $champ;

			$collecte[] = $champ;

			$args = ltrim($regs[count($regs)-1]);

		} else {

		  if (!ereg(NOM_DE_CHAMP ."[{|]", $arg, $r)) {

		    // 0 est un aveu d'impuissance. A completer

		    $arg = phraser_champs_exterieurs($arg, 0, $sep, $result);

		    $args = ltrim($regs[count($regs)-1]);

		    $collecte = array_merge($collecte, $arg);

		    $result = array_merge($result, $arg);

		  }

		  else {

		    $n = strpos($args,$r[0]);

		    $pred = substr($args, 0, $n);

		    $par = ',}';

		    if (ereg('^(.*)\($', $pred, $m))

		      {$pred = $m[1]; $par =')';}

		    if ($pred) {

			$champ = new Texte;

			$champ->texte = $pred;

			$champ->apres = $champ->avant = "";

			$result[] = $champ;

			$collecte[] = $champ;

		    }

		    $rec = substr($args, $n + strlen($r[0]) -1);

		    $champ = new Champ;

		    $champ->nom_boucle = $r[2];

		    $champ->nom_champ = $r[3];

		    $champ->etoile = $r[5];

		    phraser_args($rec, $par, $sep, array(), $champ);

		    $args = $champ->apres ;

		    $champ->apres = '';

		    if ($par==')') $args = substr($args,1);

		    $collecte[] = $champ;

		    $result[] = $champ;

		  }

		}

		if ($args[0] == ',') {

		  $args = ltrim(substr($args,1));

		  if ($collecte)

		    {$res[] = $collecte; $collecte = array();}

		}

	}

	if ($collecte) {$res[] = $collecte; $collecte = array();}

	$args = substr($args,1);

      }

      $n = strlen($suite) - strlen($args);

      $pointeur_champ->param[] = $res;

      // pour les balises avec faux filtres qui boudent ce dur larbeur

      $pointeur_champ->fonctions[] = array($fonc, substr($suite, 0, $n));

      $texte = ltrim($args);

  }

  # laisser l'appelant virer le caractere fermant

  $pointeur_champ->apres = $texte;

  return $result;

}

function phraser_champs_exterieurs($texte, $ligne, $sep, $nested) {

	$res = array();

	while (($p=strpos($texte, "%$sep"))!==false) {

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

	  if ($p) $res = phraser_inclure($debut, $ligne, $res);

	  $ligne += substr_count($debut, "\n");

	  ereg("^%$sep([0-9]+)@(.*)$", substr($texte,$p),$m);

	  $res[]= $nested[$m[1]];

	  $texte = $m[2];

	}

	return (($texte==="") ?  $res : phraser_inclure($texte, $ligne, $res));

}

function phraser_champs_interieurs($texte, $ligne, $sep, $result) {

  $i = 0; // en fait count($result)

  $x = "";

	while (true) {	  $j=$i;   $n = $ligne;

	  while (ereg(CHAMP_ETENDU, $texte, $match)) {

		$p = strpos($texte, $match[0]);

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

		if ($p) {$result[$i] = $debut;$i++; }

		$champ = new Champ;

		// ca ne marche pas encore en cas de champ imbrique

		$champ->ligne = $x ? 0 :($n+substr_count($debut, "\n"));

		$champ->nom_boucle = $match[3];

		$champ->nom_champ = $match[4];

		$champ->etoile = $match[6];

		// phraser_args indiquera ou commence apres

		$result = phraser_args($match[7], ")", $sep, $result, $champ);

		$champ->avant = phraser_champs_exterieurs($match[1],$n,$sep,$result);

		$debut = substr($champ->apres,1);

		$n += substr_count(substr($texte, 0, strpos($texte, $debut)), "\n");

		$champ->apres = phraser_champs_exterieurs($debut,$n,$sep,$result);

		$result[$i] = $champ;

		$i++;

		$texte = substr($texte,$p+strlen($match[0]));

	  }

	  if ($texte!=="") {$result[$i] = $texte; $i++;}

	  $x ='';

	  while($j < $i)

	    { $z= $result[$j];

	      // j'aurais besoin de connaitre le nombre de lignes...

	      if (is_object($z)) $x .= "%$sep$j@" ; else $x.=$z ;

	      $j++;}

	  if (ereg(CHAMP_ETENDU, $x)) $texte = $x;

	  else return phraser_champs_exterieurs($x, $ligne, $sep, $result);}

}

// analyse des criteres de boucle,

function phraser_criteres($params, &$result) {

	$args = array();

	$type = $result->type_requete;

	foreach($params as $v) {

		$var = $v[1][0];

		$param = ($var->type != 'texte') ? "" : $var->texte;

		if ((count($v) > 2) && (!eregi("[^A-Za-z]IN[^A-Za-z]",$param)))

		  {

// plus d'un argument et pas le critere IN:

// detecter comme on peut si c'est le critere implicite LIMIT debut, fin

			if (($var->type != 'texte') ||

			    (strpos("0123456789-", $param[strlen($param)-1])

			     !== false)) {

			  $op = ',';

			  $not = "";

			} else {

			  preg_match("/^([!]?)([a-zA-Z][a-zA-Z0-9]*)[[:space:]]*(.*)$/ms", $param, $m);

			  $op = $m[2];

			  $not = $m[1];

			  if ($m[3]) $v[1][0]->texte = $m[3]; else array_shift($v[1]);

			}

			array_shift($v);

			$crit = new Critere;

			$crit->op = $op;

			$crit->not = $not;

			$crit->param = $v;

			$args[] = $crit;

		  } else {

		  if ($var->type != 'texte') {

		    // cas 1 seul arg ne commencant pas par du texte brut:

		    // erreur ou critere infixe "/"

		    if (($v[1][1]->type != 'texte') || (trim($v[1][1]->texte) !='/'))

		      erreur_squelette('criteres',$var->nom_champ);

		    else {

		      $crit = new Critere;

		      $crit->op = '/';

		      $crit->not = "";

		      $crit->param = array(array($v[1][0]),array($v[1][2]));

		      $args[] = $crit;

		    }

		  } else {

	// traiter qq lexemes particuliers pour faciliter la suite

	// les separateurs

			if ($var->apres)

				$result->separateur[] = $param;

			elseif (($param == 'tout') OR ($param == 'tous'))

				$result->tout = true;

			elseif ($param == 'plat')

				$result->plat = true;

	// Boucle hierarchie, analyser le critere id_article - id_rubrique

	// - id_syndic, afin, dans les cas autres que {id_rubrique}, de

	// forcer {tout} pour avoir la rubrique mere...

			elseif (($type == 'hierarchie') &&

				($param == 'id_article' OR $param == 'id_syndic'))

				$result->tout = true;

			elseif (($type == 'hierarchie') && ($param == 'id_rubrique'))

				{;}

			else {

			  // pas d'emplacement statique, faut un dynamique

			  /// mais il y a 2 cas qui ont les 2 !

			  if (($param == 'unique') || (ereg('^!?doublons *', $param)))

			    {

			      // cette variable sera inseree dans le code

			      // et son nom sert d'indicateur des maintenant

			      $result->doublons = '$doublons_index';

			      if ($param == 'unique') $param = 'doublons';

			    }

			  elseif ($param == 'recherche')

			    // meme chose (a cause de #nom_de_boucle:URL_*)

			      $result->hash = true;

			  if (ereg('^ *([0-9-]+) *(/) *(.+) *$', $param, $m)) {

			    $crit = phraser_critere_infixe($m[1], $m[3],$v, '/', '', '');

			  } elseif (ereg('^(`?[A-Za-z_][A-Za-z_0-9]*\(?[A-Za-z_]*\)?`?)[[:space:]]*(\??)(!?)(<=?|>=?|==?|IN)[[:space:]]*"?([^<>=!"]*)"?$', $param, $m)) {

			    $crit = phraser_critere_infixe($m[1], $m[5],$v,

							   (($m[1] == 'lang_select') ? $m[1] : trim($m[4])),

							   $m[3], $m[2]);

			  } elseif (preg_match("/^([!]?)[[:space:]]*([A-Za-z_][A-Za-z_0-9]*)[[:space:]]*(\??)(.*)$/ism", $param, $m)) {

		  // contient aussi les comparaisons implicites !

			    array_shift($v);

			    if ($m[4])

			      $v[0][0]->texte = $m[4];

			    else {

			      array_shift($v[0]);

			      if (!$v[0]) array_shift($v);

			    }

			    $crit = new Critere;

			    $crit->op = $m[2];

			    $crit->param = $v;

			    $crit->not = $m[1];

			    $crit->cond = $m[3];

			  }

			  else {

			    erreur_squelette(_T('zbug_critere_inconnu',

						array('critere' => $param)));

			  }

			  $args[] = $crit;

			}

		  }

		}

	}

	$result->criteres = $args;

}

function phraser_critere_infixe($arg1, $arg2, $args, $op, $not, $cond)

{

	$args[0] = new Texte;

	$args[0]->texte = $arg1;

	$args[0] = array($args[0]);

	$args[1][0]->texte = $arg2;

	$crit = new Critere;

	$crit->op = $op;

	$crit->not = $not;

	$crit->cond = $cond;

	$crit->param = $args;

	return $crit;

}

function phraser($texte, $id_parent, &$boucles, $nom, $ligne=1) {

	$all_res = array();

	while (($p = strpos($texte, BALISE_BOUCLE)) !== false) {

		$result = new Boucle;

		$result->id_parent = $id_parent;

# attention: reperer la premiere des 2 balises: pre_boucle ou boucle

		$n = ereg(BALISE_PRE_BOUCLE . '[0-9_]', $texte, $r);

		if ($n) $n = strpos($texte, $r[0]);

		if (($n === false) || ($n > $p)) {

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

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

		  $k = strpos($milieu, '(');

		  $id_boucle = trim(substr($milieu,

					   strlen(BALISE_BOUCLE),

					   $k - strlen(BALISE_BOUCLE)));

		  $milieu = substr($milieu, $k);

		  /* a adapter: si $n pointe sur $id_boucle ...

		if (strpos($milieu, $s)) {

			erreur_squelette(_T('zbug_erreur_boucle_syntaxe'),

				$id_boucle .

				_T('zbug_balise_b_aval'));

		}

		  */

		} else {

		  $debut = substr($texte, 0, $n);

		  $milieu = substr($texte, $n);

		  $k = strpos($milieu, '>');

		  $id_boucle = substr($milieu,

				       strlen(BALISE_PRE_BOUCLE),

				       $k - strlen(BALISE_PRE_BOUCLE));

		  if (!ereg(BALISE_BOUCLE . $id_boucle . "[[:space:]]*\(", $milieu, $r))

		    erreur_squelette((_T('zbug_erreur_boucle_syntaxe')), $id_boucle);

		  $p = strpos($milieu, $r[0]);

		  $result->avant = substr($milieu, $k+1, $p-$k-1);

		  $milieu = substr($milieu, $p+strlen($id_boucle)+strlen(BALISE_BOUCLE));

		}

		$result->id_boucle = $id_boucle;

		ereg(SPEC_BOUCLE, $milieu, $match);

                $milieu = substr($milieu, strlen($match[0]));

		$type = $match[1];

		if ($p = strpos($type, ':'))

		  {

		    $result->sql_serveur = substr($type,0,$p);

		    $soustype = strtolower(substr($type,$p+1));

		  }

		else

		  $soustype = strtolower($type);

		if ($soustype == 'sites') $soustype = 'syndication' ; # alias

		//

		// analyser les criteres et distinguer la boucle recursive

		//

		if (substr($soustype, 0, 6) == TYPE_RECURSIF) {

			$result->type_requete = TYPE_RECURSIF;

			$result->param[0] = substr($type, strlen(TYPE_RECURSIF));

			$milieu = substr($milieu, strpos($milieu, '>')+1);

			$params = "";

		} else {

			$result->type_requete = $soustype;

			phraser_args($milieu,">","",$all_res,$result);

			$params = substr($milieu,0,strpos($milieu,$result->apres));

			$milieu = substr($result->apres,1);

			$result->apres = "";

			phraser_criteres($result->param, $result);

		}

		//

		// Recuperer la fin :

		//

		$s = BALISE_FIN_BOUCLE . $id_boucle . ">";

		$p = strpos($milieu, $s);

		if ($p === false) {

			erreur_squelette(_T('zbug_erreur_boucle_syntaxe'),

					 _T('zbug_erreur_boucle_fermant',

						array('id'=>$id_boucle)));

		}

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

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

		//

		// 1. Recuperer la partie conditionnelle apres

		//

		$s = BALISE_POST_BOUCLE . $id_boucle . ">";

		$p = strpos($suite, $s);

		if ($p !== false) {

			$result->apres = substr($suite, 0, $p);

			$suite = substr($suite, $p + strlen($s));

		}

		//

		// 2. Recuperer la partie alternative

		//

		$s = BALISE_ALT_BOUCLE . $id_boucle . ">";

		$p = strpos($suite, $s);

		if ($p !== false) {

			$result->altern = substr($suite, 0, $p);

			$suite = substr($suite, $p + strlen($s));

		}

		$result->ligne = $ligne + substr_count($debut, "\n");

		$m = substr_count($milieu, "\n");

		$b = substr_count($result->avant, "\n");

		$a = substr_count($result->apres, "\n");

		// envoyer la boucle au debugueur

		if ($GLOBALS['var_mode']== 'debug') {

		  boucle_debug ($nom, $id_parent, $id_boucle,

				$type,

				$params,

				$result->avant,

				$milieu,

				$result->apres,

				$result->altern);

		}

		$result->avant = phraser($result->avant, $id_parent,$boucles, $nom, $result->ligne);

		$result->apres = phraser($result->apres, $id_parent,$boucles, $nom, $result->ligne+$b+$m);

		$result->altern = phraser($result->altern,$id_parent,$boucles, $nom, $result->ligne+$a+$m+$b);

		$result->milieu = phraser($milieu, $id_boucle,$boucles, $nom, $result->ligne+$b);

		if ($boucles[$id_boucle]) {

			erreur_squelette(_T('zbug_erreur_boucle_syntaxe'),

					 _T('zbug_erreur_boucle_double',

					 	array('id'=>$id_boucle)));

		} else

			$boucles[$id_boucle] = $result;

		$all_res = phraser_champs_etendus($debut, $ligne, $all_res);

		$all_res[] = $result;

		$ligne += substr_count(substr($texte, 0, strpos($texte, $suite)), "\n");

		$texte = $suite;

	}

	return phraser_champs_etendus($texte, $ligne, $all_res);

}

?>