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.   *

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

//

// Fichier principal du compilateur de squelettes

//

// Ce fichier ne sera execute qu'une fois

if (defined("_INC_COMPILO")) return;

define("_INC_COMPILO", "1");

// reperer un code ne calculant rien, meme avec commentaire

define('CODE_MONOTONE', "^(\n//[^\n]*\n)?\(?'([^'])*'\)?$");

// Definition de la structure $p, et fonctions de recherche et de reservation

// dans l'arborescence des boucles

include_local("inc-compilo-index.php3");  # index ? structure ? pile ?

// definition des boucles

include_local("inc-boucles.php3");

// definition des criteres

include_local("inc-criteres.php3");

// definition des balises

include_local("inc-balises.php3");

// definition de l'API

include_local("inc-compilo-api.php3");

# definition des tables

include_ecrire('inc_serialbase.php3');

// outils pour debugguer le compilateur

#include_local("inc-compilo-debug.php3"); # desactive

//

// Calculer un <INCLURE()>

//

function calculer_inclure($struct, $descr, &$boucles, $id_boucle) {

	$fichier = $struct->texte;

	if (!($path = find_in_path($fichier)))

	  {

		spip_log("ERREUR: <INCLURE($fichier)> impossible");

		erreur_squelette(_T('zbug_info_erreur_squelette'),

				 "<INCLURE($fichier)> - "

				 ._T('fichier_introuvable', array('fichier' => $fichier)));

		return "'<!-- Erreur INCLURE(".texte_script($fichier).") -->'";

	}

	$l = array();

	foreach($struct->param as $val) {

		$var = array_shift($val);

		$l[] = "\'$var\' => \'' . addslashes(" .

		    ($val ? calculer_liste($val[0], $descr, $boucles, $id_boucle) :

		    (($var =='lang') ?

		     '$GLOBALS["spip_lang"]' :

		     index_pile($id_boucle, $var, $boucles)))

		    . ") . '\\'";

		}

	return "\n'<".

		"?php\n\t\$contexte_inclus = array(" .

		join(",\n\t",$l) .

		");" .

		"\n\tinclude(\\'$path\\');" .

		"\n?'." . "'>'";

 }

//

// calculer_boucle() produit le corps PHP d'une boucle Spip

// Sauf pour les recursives, ce corps est un Select SQL + While PHP

// remplissant une variable $t0 retournee en valeur

//

function calculer_boucle($id_boucle, &$boucles) {

  $boucle = &$boucles[$id_boucle];

  $return = $boucle->return;

  $type_boucle = $boucle->type_requete;

  if ($type_boucle == 'boucle') {

	    $corps = "\n	\$t0 = " . $return . ";";

	    $init = "";

  } else {

	$primary = $boucle->primary;

	$constant = ereg(CODE_MONOTONE,$return);

	// Cas {1/3} {1,4} {n-2,1}...

	$flag_cpt = $boucle->mode_partie || // pas '$compteur' a cause du cas 0

	  strpos($return,'compteur_boucle');

	//

	// Creer le debut du corps de la boucle :

	//

	$corps = '';

	if ($flag_cpt)

		$corps = "\n		\$Numrows['$id_boucle']['compteur_boucle']++;";

	if ($boucle->mode_partie)

		$corps .= "

		if (\$Numrows['$id_boucle']['compteur_boucle']-1 >= \$debut_boucle

		AND \$Numrows['$id_boucle']['compteur_boucle']-1 <= \$fin_boucle) {";

	// Calculer les invalideurs si c'est une boucle non constante

	if ($primary && !$constant)

		$corps .= "\n\t\t\$Cache['$primary'][" .

		  (($primary != 'id_forum')  ?

		   index_pile($id_boucle, $primary, $boucles) :

		   ("calcul_index_forum(" .

		// Retournera 4 [$SP] mais force la demande du champ a MySQL

		    index_pile($id_boucle, 'id_article', $boucles) . ',' .

		    index_pile($id_boucle, 'id_breve', $boucles) .  ',' .

		    index_pile($id_boucle, 'id_rubrique', $boucles) .',' .

		    index_pile($id_boucle, 'id_syndic', $boucles) .

		    ")")) .

		  "] = 1; // invalideurs\n";

	if ($boucle->doublons)

		$corps .= "		\$doublons[".$boucle->doublons."] .= ','. " .

		index_pile($id_boucle, $primary, $boucles)

		. "; // doublons\n";

	if (count($boucle->separateur))

	  $code_sep = ("'" . ereg_replace("'","\'",join('',$boucle->separateur)) . "'");

	$init = '';

	$fin = '';

	// La boucle doit-elle selectionner la langue ?

	// -. par defaut, les boucles suivantes le font

	// "peut-etre", c'est-a-dire si forcer_lang == false.

	// - . a moins d'une demande explicite

	if (!$constant && $boucle->lang_select != 'non' &&

	    (($boucle->lang_select == 'oui')  ||

		    (

			$type_boucle == 'articles'

			OR $type_boucle == 'rubriques'

			OR $type_boucle == 'hierarchie'

			OR $type_boucle == 'breves'

			)))

	  {

	      $corps .=

		  (($boucle->lang_select != 'oui') ?

			"\t\tif (!\$GLOBALS['forcer_lang'])\n\t " : '')

		  . "\t\t\$GLOBALS['spip_lang'] = (\$x = "

		  . index_pile($id_boucle, 'lang', $boucles)

		  . ') ? $x : $old_lang;';

		// Memoriser la langue avant la boucle pour la restituer apres

	      $init .= "\n	\$old_lang = \$GLOBALS['spip_lang'];";

	      $fin .= "\n	\$GLOBALS['spip_lang'] = \$old_lang;";

	  }

	// gestion optimale des separateurs et des boucles constantes

	$corps .=

		((!$boucle->separateur) ?

			(($constant && !$corps) ? $return :

			 	("\n\t\t" . '$t0 .= ' . $return . ";")) :

		 ("\n\t\t\$t1 " .

			((strpos($return, '$t1.') === 0) ?

			 (".=" . substr($return,4)) :

			 ('= ' . $return)) .

		  ";\n\t\t" .

		  '$t0 .= (($t1 && $t0) ? ' . $code_sep . " : '') . \$t1;"));

	// Fin de parties

	if ($boucle->mode_partie)

		$corps .= "\n		}\n";

	// Gestion de la hierarchie (voir inc-boucles.php3)

	if ($boucle->hierarchie)

		$init .= "\n	".$boucle->hierarchie;

	// si le corps est une constante, ne pas appeler le serveur N fois!

	if (ereg(CODE_MONOTONE,$corps, $r)) {

		if (!$r[2]) {

			if (!$boucle->numrows)

				return 'return "";';

			else

				$corps = "";

		} else {

			$boucle->numrows = true;

			$corps = "\n	".'for($x=$Numrows["'.$id_boucle.'"]["total"];$x>0;$x--)

			$t0 .= ' . $corps .';';

		}

	} else {

		$corps = '

	// RESULTATS

	while ($Pile[$SP] = @spip_abstract_fetch($result,"' .

		  $boucle->sql_serveur .

		  '")) {' .

		  "\n$corps\n	}\n" .

		  $fin ;

	}

	//

	// Requete

	//

	if (!$order = $boucle->order

	AND !$order = $boucle->default_order)

		$order = array();

	$init .= $boucle->hash .

	  "\n\n	// REQUETE

	\$result = spip_abstract_select(\n\t\tarray(\"".

		# En absence de champ c'est un decompte :

	  	# prendre la primary pour avoir qqch

	  	# (COUNT incompatible avec le cas general

		($boucle->select ?

		 join("\",\n\t\t\"", $boucle->select) :

		 ($boucle->id_table . "." .

		 (($p = strpos($primary, ',')) ?

		  substr($primary, 0, $p) : $primary))) .

		'"), # SELECT

		array("' .

		join('","', array_unique($boucle->from)) .

		'"), # FROM

		array(' .

		(!$boucle->where ? '' : ( '"' . join('",

		"', $boucle->where) . '"')) .

		"), # WHERE

		'".addslashes($boucle->group)."', # GROUP

		array(" .

	  	join(', ', $order) .

		"), # ORDER

		" . (strpos($boucle->limit, 'intval') === false ?

			"'".$boucle->limit."'" :

			$boucle->limit). ", # LIMIT

		'".$boucle->sous_requete."', # sous

		'" . (!$boucle->having ? "" : "(COUNT(*)> $boucle->having)")."', # HAVING

		'".$boucle->id_table."', # table

		'".$boucle->id_boucle."', # boucle

		'".$boucle->sql_serveur."'); # serveur";

	$init .= "\n	".'$t0 = "";

	$SP++;';

	if ($flag_cpt)

		$init .= "\n	\$Numrows['$id_boucle']['compteur_boucle'] = 0;";

	if ($boucle->mode_partie)

		$init .= calculer_parties($boucles, $id_boucle);

	else if ($boucle->numrows)

		$init .= "\n	\$Numrows['" .

			$id_boucle .

			"']['total'] = @spip_abstract_count(\$result,'" .

			$boucle->sql_serveur .

			"');";

	//

	// Conclusion et retour

	//

	$corps .= "\n	@spip_abstract_free(\$result,'" .

	     $boucle->sql_serveur . "');";

  }

  return $init . $corps .

	## inserer le code d'envoi au debusqueur du resultat de la fonction

	(($GLOBALS['var_mode_affiche'] != 'resultat') ? "" : "

		boucle_debug_resultat('$id_boucle', 'resultat', \$t0);") .

    "\n	return \$t0;";

}

//

// fonction traitant les criteres {1,n} (analyses dans inc-criteres)

//

## a deplacer dans inc-criteres ??

function calculer_parties($boucles, $id_boucle) {

	$boucle = &$boucles[$id_boucle];

	$partie = $boucle->partie;

	$mode_partie = $boucle->mode_partie;

	$total_parties = $boucle->total_parties;

	// Notes :

	// $debut_boucle et $fin_boucle sont les indices SQL du premier

	// et du dernier demandes dans la boucle : 0 pour le premier,

	// n-1 pour le dernier ; donc total_boucle = 1 + debut - fin

	// nombre total avant partition

	$retour = "\n\n	// Partition\n	" .

		'$nombre_boucle = @spip_abstract_count($result,"' .

		$boucle->sql_serveur .

		'");';

	ereg("([+-/])([+-/])?", $mode_partie, $regs);

	list(,$op1,$op2) = $regs;

	// {1/3}

	if ($op1 == '/') {

		$pmoins1 = is_numeric($partie) ? ($partie-1) : "($partie-1)";

		$totpos = is_numeric($total_parties) ? ($total_parties) :

		  "($total_parties ? $total_parties : 1)";

		$retour .= "\n	"

		  .'$debut_boucle = ceil(($nombre_boucle * '

		  . $pmoins1 . ')/' . $totpos . ");";

		$fin = 'ceil (($nombre_boucle * '

			. $partie . ')/' . $totpos . ") - 1";

	}

	// {1,x}

	elseif ($op1 == '+') {

		$retour .= "\n	"

			. '$debut_boucle = ' . $partie . ';';

	}

	// {n-1,x}

	elseif ($op1 == '-') {

		$retour .= "\n	"

			. '$debut_boucle = $nombre_boucle - ' . $partie . ';';

	}

	// {x,1}

	if ($op2 == '+') {

		$fin = '$debut_boucle'

		  . (is_numeric($total_parties) ?

		     (($total_parties==1) ? "" :(' + ' . ($total_parties-1))):

		     ('+' . $total_parties . ' - 1'));

	}

	// {x,n-1}

	elseif ($op2 == '-') {

		$fin = '$debut_boucle + $nombre_boucle - '

		  . (is_numeric($total_parties) ? ($total_parties+1) :

		     ($total_parties . ' - 1'));

	}

	// Rabattre $fin_boucle sur le maximum

	$retour .= "\n	"

		.'$fin_boucle = min(' . $fin . ', $nombre_boucle - 1);';

	// calcul du total boucle final

	$retour .= "\n	"

		.'$Numrows[\''.$id_boucle.'\']["total"] = max(0,$fin_boucle - $debut_boucle + 1);';

	return $retour;

}

// Production du code PHP a partir de la sequence livree par le phraseur

// $boucles est passe par reference pour affectation par index_pile.

// Retourne une expression PHP,

// (qui sera argument d'un Return ou la partie droite d'une affectation).

function calculer_liste($tableau, $descr, &$boucles, $id_boucle='') {

	if (!$tableau) return "''";

	$codes = compile_cas($tableau, $descr, $boucles, $id_boucle);

	$n = count($codes);

	if (!$n) return "''";

	if ($GLOBALS['var_mode_affiche'] != 'validation')

	  return

		(($n==1) ? $codes[0] :

			 "(" . join (" .\n$tab", $codes) . ")");

	else return "debug_sequence('$id_boucle', '" .

	  ($descr['nom']) .

	  "', " .

	  intval($descr['niv']) .

	  ",  array(" .

	  join(" ,\n$tab", $codes) . "))";

}

function compile_cas($tableau, $descr, &$boucles, $id_boucle='') {

        $codes = array();

	// cas de la boucle recursive

	if (is_array($id_boucle))

	  $id_boucle = $id_boucle[0];

	$type = $boucles[$id_boucle]->type_requete;

	$descr['niv']++;

	for ($i=0; $i<=$descr['niv']; $i++) $tab .= "\t";

	// chaque commentaire introduit dans le code doit commencer

	// par un caractere distinguant le cas, pour exploitation par debug.

	foreach ($tableau as $p) {

		switch($p->type) {

		// texte seul

		case 'texte':

			$code = "'".ereg_replace("([\\\\'])", "\\\\1", $p->texte)."'";

			$commentaire= strlen($p->texte) . " signes";

			$avant='';

			$apres='';

			$altern = "''";

			break;

		case 'polyglotte':

			$code = "";

			foreach($p->traductions as $k => $v) {

			  $code .= ",'" .

			    ereg_replace("([\\\\'])", "\\\\1", $k) .

			    "' => '" .

			    ereg_replace("([\\\\'])", "\\\\1", $v) .

			    "'";

			}

			$code = "multi_trad(array(" .

 			  substr($code,1) .

			  "))";

			$commentaire= '&';

			$avant='';

			$apres='';

			$altern = "''";

			break;

		// inclure

		case 'include':

			$code = calculer_inclure($p, $descr, $boucles, $id_boucle);

			$commentaire = '!' . $p->texte;

			$avant='';

			$apres='';

			$altern = "''";

			break;

		// boucle

		case 'boucle':

			$nom = $p->id_boucle;

			$newdescr = $descr;

			$newdescr['id_mere'] = $nom;

			$newdescr['niv']++;

			$code = 'BOUCLE' .

			  ereg_replace("-","_", $nom) . $descr['nom'] .

			  '($Cache, $Pile, $doublons, $Numrows, $SP)';

			$commentaire= "?$nom";

			$avant = calculer_liste($p->avant,

				$newdescr, $boucles, $id_boucle);

			$apres = calculer_liste($p->apres,

				$newdescr, $boucles, $id_boucle);

			$newdescr['niv']--;

			$altern = calculer_liste($p->altern,

				$newdescr, $boucles, $id_boucle);

			break;

		case 'idiome':

			$p->code = "_T('" . $p->module . ":" .$p->nom_champ . "')";

			$p->id_boucle = $id_boucle;

			$p->boucles = &$boucles;

			$p->statut = 'php'; // ne pas manger les espaces avec trim()

			$commentaire = ":";

			$code = applique_filtres($p);

			$avant='';

			$apres='';

			$altern = "''";

			break;

		case 'champ';

			// cette structure pourrait etre completee des le phrase' (a faire)

			$p->id_boucle = $id_boucle;

			$p->boucles = &$boucles;

			$p->descr = $descr;

			$p->statut = 'html';

			$p->type_requete = $type;

			$code = calculer_champ($p);

			$commentaire = '#' . $p->nom_champ . $p->etoile;

			$avant = calculer_liste($p->avant,

				$descr, $boucles, $id_boucle);

			$apres = calculer_liste($p->apres,

				$descr, $boucles, $id_boucle);

			$altern = "''";

			break;

		default:

		  erreur_squelette(_T('zbug_info_erreur_squelette'));

		} // switch

		if ($avant == "''") $avant = '';

		if ($apres == "''") $apres = '';

		if ($avant||$apres||($altern!="''"))

		  {

		    $t = '$t' . $descr['niv'];

		    $res = (!$avant ? "" : "$avant . ") .

		      $t .

		      (!$apres ? "" : " . $apres");

		    $code = "(($t = $code) ?\n\t$tab($res) :\n\t$tab($altern))";

		  }

		if ($code != "''")

		  $codes[]= (($GLOBALS['var_mode_affiche'] == 'validation') ?

			     "array(" . $p->ligne . ", '$commentaire', $code)"

			     : (($GLOBALS['var_mode_affiche'] == 'code') ?

				"\n// $commentaire\n$code" :

				$code));

	} // foreach

	return $codes;

}

// affichage du code produit

function code_boucle(&$boucles, $id, $nom)

{

	$boucle = &$boucles[$id];

	// Indiquer la boucle en commentaire

	$pretty = '';

	if ($boucle->type_requete != 'boucle')

	  {

	    // Resynthetiser les criteres

	    foreach ($boucle->param as $param) {

	      $s = "";

	      $sep = "";

	      foreach ($param as $t) {

		if (is_array($t)) { // toujours vrai normalement

		  $s .= $sep;

		  $c = $t[0];

		  if ($c->apres)

		    $s .= ($c->apres . $c->texte . $c->apres);

		  else {

		// faudrait decompiler aussi les balises...

		    foreach ($t as $c)

		      $s .=  ($c->type == 'texte') ? $c->texte : '#...';

		  }

		  $sep = ", ";

		}

	      }

	      $pretty .= ' {' . $s . '}';

	    }

	  }

	$pretty = "BOUCLE$id(".strtoupper($boucle->type_requete) . ")" .

		ereg_replace("[\r\n]", " ", $pretty);

	return $pretty;

}

// Prend en argument le source d'un squelette, sa grammaire et un nom.

// Retourne une fonction PHP/SQL portant ce nom et calculant une page HTML.

// Pour appeler la fonction produite, lui fournir 2 tableaux de 1 e'le'ment:

// - 1er: element 'cache' => nom (du fichier ou` mettre la page)

// - 2e: element 0 contenant un environnement ('id_article => $id_article, etc)

// Elle retourne alors un tableau de 4 e'le'ments:

// - 'texte' => page HTML, application du squelette a` l'environnement;

// - 'squelette' => le nom du squelette

// - 'process_ins' => 'html' ou 'php' selon la pre'sence de PHP dynamique

// - 'invalideurs' =>  de'pendances de cette page, pour invalider son cache.

// (voir son utilisation, optionnelle, dans invalideur.php)

// En cas d'erreur, elle retourne un tableau des 2 premiers elements seulement

function calculer_squelette($squelette, $nom, $gram, $sourcefile) {

# 3 variables qui sont en fait des constantes après chargement

  global $table_primary, $table_des_tables, $tables_des_serveurs_sql;

	// Phraser le squelette, selon sa grammaire

	// pour le moment: "html" seul connu (HTML+balises BOUCLE)

	$boucles = array();

	spip_timer('calcul_skel');

	include_local("inc-$gram-squel.php3");

	$racine = phraser($squelette, '',$boucles, $nom);

	// tableau des informations sur le squelette

	$descr = array('nom' => $nom, 'documents' => false, 'sourcefile' => $sourcefile);

	// une boucle documents est conditionnee par tout le reste!

	foreach($boucles as $idb => $boucle) {

		if (($boucle->type_requete == 'documents') && $boucle->doublons)

			{ $descr['documents'] = true; break; }

	}

	// Commencer par reperer les boucles appelees explicitement

	// car elles indexent les arguments de maniere derogatoire

	foreach($boucles as $id => $boucle) {

		if ($boucle->type_requete == 'boucle') {

			$rec = &$boucles[$boucle->param[0]];

			if (!$rec) {

				return array(_T('zbug_info_erreur_squelette'),

						($boucle->param[0]

						. ' '. _T('zbug_boucle_recursive_undef')));

			} else {

				$rec->externe = $id;

				$descr['id_mere'] = $id;

				$boucles[$id]->return =

						calculer_liste(array($rec),

							 $descr,

							 $boucles,

							 $boucle->param);

			}

		}

	}

	foreach($boucles as $id => $boucle) {

		$type = $boucle->type_requete;

		if ($type != 'boucle') {

			$boucles[$id]->id_table = $table_des_tables[$type];

			if ($boucles[$id]->id_table) {

				$boucles[$id]->primary = $table_primary[$type];

			} else {

				// table non Spip.

				$boucles[$id]->id_table = $type;

				$serveur = $boucle->sql_serveur;

				$x = &$tables_des_serveurs_sql[$serveur ? $serveur : 'localhost'][$type]['key'];

				$boucles[$id]->primary = ($x["PRIMARY KEY"] ? $x["PRIMARY KEY"] : $x["KEY"]);

			}

			if ($boucle->param) {

				$res = calculer_criteres($id, $boucles);

				if (is_array($res)) return $res; # erreur

			}

			$descr['id_mere'] = $id;

			$boucles[$id]->return =

			  calculer_liste($boucle->milieu,

					 $descr,

					 $boucles,

					 $id);

			}

	}

	// idem pour la racine

	$descr['id_mere'] = '';

	$corps = calculer_liste($racine, $descr, $boucles);

	// Calcul du corps de toutes les fonctions PHP,

	// en particulier les requetes SQL et TOTAL_BOUCLE

	// de'terminables seulement maintenant

	//  Les 4 premiers parame`tres sont passe's par re'fe'rence

	// (les 1er et 3e pour modif, les 2 et 4 pour gain de place)

	foreach($boucles as $id => $boucle) {

		// appeler la fonction de definition de la boucle

		$f = 'boucle_'.strtoupper($boucle->type_requete);

		// si pas de definition perso, definition spip

		if (!function_exists($f)) $f = $f.'_dist';

		// laquelle a une definition par defaut

		if (!function_exists($f)) $f = 'boucle_DEFAUT';

		$boucles[$id]->return =

			"function BOUCLE" . ereg_replace("-","_",$id) . $nom .

			'(&$Cache, &$Pile, &$doublons, &$Numrows, $SP) {' .

			$f($id, $boucles) .

			"\n}\n\n";

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

		  boucle_debug_compile ($id, $nom, $boucles[$id]->return);

	}

	$code = "";

	foreach($boucles as $id => $boucle) {

		$code .= "\n//\n// <BOUCLE " .

#		  code_boucle($boucles, $id, $nom). # pas au point

		  $boucle->type_requete .

		  ">\n//\n" .

		  $boucle->return;

	}

	$secondes = spip_timer('calcul_skel');

	spip_log("calcul skel $sourcefile ($secondes)");

	$squelette_compile = "<"."?php

/*

 * Squelette : $sourcefile

 * Date :      ".http_gmoddate(@filemtime($sourcefile))." GMT

 * Compile :   ".http_gmoddate(time())." GMT ($secondes)

 * " . (!$boucles ?  "Pas de boucle" :

	("Boucles :   " . join (', ', array_keys($boucles)))) ."

 */ " .

	  $code . "

//

// Fonction principale du squelette $sourcefile

//

function $nom (\$Cache, \$Pile, \$doublons=array(), \$Numrows='', \$SP=0) {

\$t0 = $corps;

	return array(

		'texte' => \$t0,

		'squelette' => '$nom',

		'process_ins' => ((strpos(\$t0,'<'.'?')=== false) ? 'html' : 'php'),

		'invalideurs' => \$Cache

	);

}

?".">";

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

	  squelette_debug_compile($nom, $sourcefile, $squelette_compile, $squelette);

	return $squelette_compile;

}

?>