Nouvelle page 2

<?php
///////////////////////////////////////////////////////////////////////////////
// Class ebs_connect - émulation base de données (Easy Base System) //
// ------------------------------------------------------------------------- //
// Copyright (C) 2000, 2001 Prologin.fr <systeme_ebs@prologin.fr> //
// ------------------------------------------------------------------------- //
// Prologin.fr <http://www.Prologin.fr/> //
// ------------------------------------------------------------------------- //
// Ce programme est fourni en licence GPL, vous pouvez le redistribuer //
// et/ou le modifier conformément à la GNU (Licence Public Générale). //
// //
// Ce programme est distribué avec l'espoir qu'il sera utile, mais il l'est //
// sans aucune garantie, sans même la garantie de commercialisation ou //
// d'utilité pour un but quelconque. //
///////////////////////////////////////////////////////////////////////////////

DEFINE ("EBS_VERSION", "##EBS FILE tech 2.1 - nov 2001, by Prologin.fr##");

class ebs_connect {
// déclaration des variables de la class
var $nom = "ebs_no_file"; //nom du fichier à modifier
var $affect = 0; // compteur des champs ayant subit des modifications
var $results = array(); //tableau dans lequel sont stockées les valeurs des champs récupérés par la commande "select"
var $tab_tri = array(); // zone mémoire ou est stocké la clé de l'ordre de classement des données récupérées

////////////////////////////////
/////-----------------------////
////////////////////////////////

//## nom du fichier à modifier
function ebs_connect($var="") {
$this->nom=$var;
}

//## suppression des valeurs clés utilisées dans le système ebs
function sup_diez($val) {
$val = str_replace("#","",$val);
$val = str_replace("[START_EBS_VALUES]","",$val);
$val = str_replace("[END_EBS_VALUES]","",$val);
return $val;
}

//## fichier inexistant ou non nommé => erreur
function verif_exist() {
if (!@file_exists($this->nom))
die ("#EBS erreur => le fichier choisi n'existe pas ou son nom n'a pas été renseigné, veuillez modifier les paramètres suivant : - fonction \"ebs_connect()\" a renseigner.");
}

//## champ appelé inexistant => erreur
function verif_exist2($champs,$nbre_declarations,$declarations,$texte) {
$i=0;
while (($i < count($champs)) && $champs != "")
{
$exact=0;
$a=1;
while ($a <= $nbre_declarations)
{
if ($champs[$i] == $declarations[$a])
$exact++;
$a++;
}
if ($exact == "0")
die ($texte);
$i++;
}
}

//## ouverture du fichier pour lire son contenu
function verif_exact() {
$fd = @fopen($this->nom, "r");
$result_scan = fread($fd, filesize ($this->nom));
fclose($fd);
$result_scan = str_replace("<?php ", "", $result_scan);
return $result_scan;
}

//## récupération des valeurs enregistrées auparavant
function recup_values($result_scan)
{
if (ereg("\[START_EBS_VALUES\](.)+\[END_EBS_VALUES\]", $result_scan, $values_enr))
$values_enr = str_replace("[END_EBS_VALUES]", "", $values_enr[0]);
return $values_enr;
}

//## vérification de la version du fichier EBS
function verif_version($result_scan) {
if (!eregi("##EBS FILE tech ([[:digit:]]+)\.([[:digit:]]+) - ([[:alpha:]]{3}) ([[:digit:]]{4}), by Prologin.fr##", $result_scan, $version))
die ("#EBS erreur => le fichier ebs n'est pas valide ou n'est pas disponible : - impossible de détecter la version utilisée, il existe peut être des connexions multiples, réessayez l'insertion");
return $version[0];
}

//## vérification du nombre de champs déclarés dans le fichier
function verif_nb_declare($declarations) {
$nbre_declarations = count($declarations) - 2; // on récupère les déclarations, le tableau est valide à (n-2)
if ($nbre_declarations < 1)
die ("#EBS erreur => le fichier ebs n'est pas valide : - aucun champ n'a été déclaré");
return $nbre_declarations;
}

////////////////////////////////
/////-----------------------////
////////////////////////////////

///////////////////////////////
// création d'un fichier EBS //
///////////////////////////////
function ebs_create($name="",$champs="",$auto="") {

// on réinitialise le compteur de champs modifiés
$this->affect=0;
// controle de l'existence du fichier => erreur s'il existe
if (@file_exists($name))
die("#EBS erreur => le fichier ebs n'a pas pu être créé : - le fichier existe déjà");

// on tente de créer le fichier, opération impossible => erreur
$fd = @fopen($name,"w") or die("#EBS erreur => le fichier ebs n'a pas pu être créé : - le répertoire de destination n'existe pas ou vous n'avez pas les droits nécessaires pour écrire à l'intérieur");

// on tente de créer le fichier, aucun champ n'a été précisé => erreur
if ($champs == "")
die("#EBS erreur => le fichier ebs n'a pas pu être créé : - vous devez préciser des champs pour le fichier");

fwrite($fd, "<?php ");

$i=0;
//boucle pour inscrire les champs de déclaration
while ($i < count($champs))
{
fwrite($fd, "#=#$champs[$i]");
$i++;
if ($i == count($champs))
fwrite($fd, "#=#");
}

// si il y a un champ auto-incrémenté => inscription ici
if ($auto != "")
fwrite($fd, "#-#auto:$auto:0#-#");

// inscription du reste des champs
fwrite($fd, "[START_EBS_VALUES][END_EBS_VALUES]".EBS_VERSION." ?>");
fclose($fd);
}

//////////////////////////////////<?php
// suppression d'un fichier EBS //
//////////////////////////////////
function ebs_delete($name="") {

// on réinitialise le compteur de champs modifiés
$this->affect=0;
// fichier inexistant => erreur
if (!@file_exists($name))
die("#EBS erreur => le fichier n'a pas pu être effacé : - le fichier n'existe pas");

// seules les machines Unix acceptent la commande unlink()
if (!unlink($name))
die("#EBS erreur => le fichier n'a pas pu être effacé : - vous n'avez pas les droits nécessaires ou vous ne travaillez pas sur une machine Unix.");
}

//////////////////////////////////////////////////<?php
// insertion des données dans le fichier choisi //
//////////////////////////////////////////////////
function insert($values) {

// on réinitialise le compteur de champ modifiés
$this->affect=0;
// vérification de l'existence du fichier fichier existe
$this->verif_exist();
// s'il existe on récupère son contenu
$result_scan=$this->verif_exact();

// combien existe-t-il de champs déclarés dans le fichier ?
$declarations = explode("#=#",$result_scan);
$nbre_declarations = $this->verif_nb_declare($declarations);

// récupération du nom et de la valeur du champ auto-incrémenté s'il existe
if (eregi("#-#auto:(.)+:([[:digit:]]+)#-#", $result_scan))
{
// nom du champ
eregi(":(.)+:", $result_scan, $champ1);
$champ_auto_name = str_replace(":","",$champ1[0]);
// sa valeur
eregi(":([[:digit:]]+)#-#", $result_scan, $champ1);
$champ_auto_value = str_replace(":","",$champ1[0]);
$champ_auto_value = str_replace("#-#","",$champ_auto_value);
// on transforme la chaine "$champ_auto_value" en integer
settype ($champ_auto_value, integer);
$champ_auto_value++;
// on signale par cette variable qu'un champ auto-incrémenté existe
$ok_auto = 1;
}

// si le tableau d'insertion comporte plus de champs à inscrire que n'en comporte les déclarations du fichier EBS => erreur
if (count($values) > $nbre_declarations)
die ("#EBS insert erreur : - vous souhaitez insérer plus de champs que ceux déclarés dans le fichier EBS");

//récupération des valeurs préalablement enregistrées dans le fichier
$values_enr = $this->recup_values($result_scan);

// vérification que la version du fichier est inscrite
$version = $this->verif_version($result_scan);

// tout est ok ? on inscrit les données dans le fichier => si le tableau d'insertion est vide ou comporte moins de champs
// que n'en comporte les déclarations du fichier EBS => pas d'erreur, le traitement s'effectue, les champs non renseignés
// sont considérés comme nuls
/////
// on lance la réécriture du fichier
/////
$fd = @fopen($this->nom,"w");

fwrite($fd, "<?php ");

// on boucle pour ré-inscrire les champs déclarés
$i=1;
while ($i <= $nbre_declarations)
{
fwrite($fd, "#=#$declarations[$i]");
$i++;
// si on arrive au dernier à inscrire => on rajoute un "#=#"
if ($i > $nbre_declarations)
fwrite($fd, "#=#");
}

// si champ auto-incrémenté => on l'inscrit ici
if ($ok_auto == "1")
fwrite($fd, "#-#auto:$champ_auto_name:$champ_auto_value#-#");

// inscription des valeurs enregistrées auparavant
fwrite($fd, "$values_enr");

// si le fichier ne comporte pas encore d'enregistrement, on ajoute "[START_EBS_VALUES]#/#"
if ($values_enr[0] == "")
fwrite($fd, "[START_EBS_VALUES]#/#");

// on boucle suivant le nombre de champs déclarés préalablement
$i=0;
while ($i < $nbre_declarations)
{
// le caractère "#" n'est pas accepté => on supprime tous ceux que l'ont peut rencontrer
$values[$i] = $this->sup_diez($values[$i]);
// si le champ est auto-incrémenté, on inscrit la valeur du champ mise en mémoire
if ($values[$i] == "[auto]")
fwrite($fd, "$champ_auto_value#/#");
else
fwrite($fd, "$values[$i]#/#");
$i++;
//si l'on arrive au dernier champ => on ajoute la balise de cloture
if ($i == $nbre_declarations)
fwrite($fd, "[END_EBS_VALUES]");
}

// inscription de la version du fichier EBS => si cette version est inscrite le fichier peut être utilisé
fwrite($fd, "$version ?>");
fclose($fd);
}

///////////////////////////////<?php
// modification d'un fichier //
///////////////////////////////
function update($champs="",$values="",$where="") {

// on réinitialise le compteur de champ modifiés
$this->affect=0;
// on vérifie si le fichier existe
$this->verif_exist();
// s'il existe on récupère son contenu
$result_scan=$this->verif_exact();

// combien existe-t-il de champs déclarés dans le fichier ?
$declarations = explode("#=#",$result_scan);
$nbre_declarations = $this->verif_nb_declare($declarations);

// si il n'y a pas de champ à modifier => erreur
if ($champs == "")
die ("#EBS update erreur : - vous n'avez pas précisé de champs à modifier");

// si le nombre de champs à modifier est différent de celui des valeurs qui lui sont attribuées => erreur
if (count($champs) != count($values))
die ("#EBS update erreur : - le nombre de champs à modifier est différent de celui des valeurs qui lui sont attribuées");

// vérification de l'existence des champs devant être modifiés
$this->verif_exist2($champs,$nbre_declarations,$declarations,"#EBS update erreur : - au moins un des champs devant être modifié n'existe pas");

// on récupère les valeurs préalablement enregistrées dans le fichier
$values_enr = $this->recup_values($result_scan);

// on vérifie si la version du fichier est inscrite
$version = $this->verif_version($result_scan);

// on récupère le nom du champ auto-incrémenté s'il existe
eregi("#-#auto:(.)+:([[:digit:]]+)#-#", $result_scan, $champ_auto);

/////
// on lance la réécriture du fichier
/////
$fd = @fopen($this->nom,"w");

fwrite($fd, "<?php ");

// on boucle pour ré-inscrire les champs déclarés
$i=1;
while ($i <= $nbre_declarations)
{
fwrite($fd, "#=#$declarations[$i]");
$i++;
// si on arrive au dernier à inscrire => on rajoute un "#=#"
if ($i > $nbre_declarations)
fwrite($fd, "#=#");
}

// si champ auto-incrémenté existe => on l'inscrit ici
if ($champ_auto[0] != "")
fwrite($fd, "$champ_auto[0]");

// on récupère dans un tableau chacun des champs enregistré dans le fichier
$tab_valeurs = explode("#/#", $values_enr);

fwrite($fd, "[START_EBS_VALUES]");

////////////////
// DEBUT TEST //
////////////////
// début de la réécriture des enregistrements
$compt = 0; //compteur permettant de savoir quel champ est en cours de modifications
$i=1;
while ($i <= (count($tab_valeurs) - 2))
{
$compt++;
$traitement_ok = 0;
// si le compteur est supérieur au nombre de déclarations, on le réinitialise à 1
if ($compt > $nbre_declarations)
$compt=1;
if ($i == "1")
fwrite($fd, "#/#");

// avant de réinscrire l'enregistrement, on controle s'il fait partie de ceux à modifier
$a = 0;
while ($a < count($champs))
{
// le caractère "#" n'est pas accepté => on supprime tous ceux que l'ont peut rencontrer
$values[$a] = $this->sup_diez($values[$a]);

//si le champ de la valeur que l'on souhaite modifier est identique à l'un des champs à modifier => on continue les tests
if ($champs[$a] == $declarations[$compt])
{
// si il y a une condition supplémentaire (champs spécifiques) à modifier, on traite l'exception ici
if ($where == "" or count($where) < 1)
{
// s'il n'y a pas de conditions, on modifie systématiquement la valeur
fwrite($fd, "$values[$a]#/#");
$traitement_ok = 1;
$this->affect++;
}
else
{
$b = 0;
$champs_ok = 0;
// on parcourt chacun des champs du tableau de condition
while ($b < count($where))
{
$c = 1;
$d = $i - $compt + 1;
// on parcourt chacun des champs déclarés
while ($c <= $nbre_declarations)
{
$condition = explode("=",$where[$b]);
// si la condition est égale à la valeur du champ correspondant, c'est ok
if (($condition[0] == $declarations[$c]) && ($condition[1] == $tab_valeurs[$d]))
{
$champs_ok++;
break;
}
$d++;
$c++;
}
$b++;
}
if ($champs_ok == count($where))
{
fwrite($fd, "$values[$a]#/#");
$traitement_ok = 1;
$this->affect++;
}
}
}
$a++;
}

//si le champ n'a pas été réinscrit auparavant, on le rééinscrit maintenant
if ($traitement_ok == "0")
fwrite($fd, "$tab_valeurs[$i]#/#");

$i++;
}
//////////////
// FIN TEST //
//////////////

fwrite($fd, "[END_EBS_VALUES]");

// on inscrit la version du fichier EBS => si cette version est inscrite le fichier peut être utilisé -> pas de conflits
fwrite($fd, "$version ?>");
fclose($fd);
}

////////////////////////////////////////<?php
// suppression d'une ligne de données //
////////////////////////////////////////
function delete($delete="") {

// on réinitialise le compteur de champ modifiés
$this->affect=0;
// on vérifie si le fichier existe
$this->verif_exist();
// s'il existe on récupère son contenu
$result_scan=$this->verif_exact();

// combien existe-t-il de champs déclarés dans le fichier ?
$declarations = explode("#=#",$result_scan);
$nbre_declarations = $this->verif_nb_declare($declarations);

// vérification de l'existence des champs inclus dans la condition, si aucun champ n'est précisé, inutile d'effectuer cette vérification, l'ensemble des champs est supprimé
if ($delete != "")
{
$i = 0;
while ($i < count($delete))
{
$tab = explode("=", $delete[$i]);
$champs[$i] = $tab[0];
$i++;
}
$this->verif_exist2($champs,$nbre_declarations,$declarations,"#EBS delete erreur : - au moins l'une des conditions de suppression n'est pas valide");
}

// on récupère les valeurs préalablement enregistrées dans le fichier
$values_enr = $this->recup_values($result_scan);

// on vérifie si la version du fichier est inscrite
$version = $this->verif_version($result_scan);

// on récupère le nom du champ auto-incrémenté s'il existe
eregi("#-#auto:(.)+:([[:digit:]]+)#-#", $result_scan, $champ_auto);

/////
// on lance la réécriture du fichier
/////
$fd = @fopen($this->nom,"w");

fwrite($fd, "<?php ");

// on boucle pour ré-inscrire les champs déclarés
$i=1;
while ($i <= $nbre_declarations)
{
fwrite($fd, "#=#$declarations[$i]");
$i++;
// si on arrive au dernier à inscrire => on rajoute un "#=#"
if ($i > $nbre_declarations)
fwrite($fd, "#=#");
}

// si champ auto-incrémenté existe => on l'inscrit ici
if ($champ_auto[0] != "")
fwrite($fd, "$champ_auto[0]");

// on récupère dans un tableau chacun des champs enregistré dans le fichier
$tab_valeurs = explode("#/#", $values_enr);

fwrite($fd, "[START_EBS_VALUES]");

// lorsque cette variable = 1, on ajoute "#/#" au fichier
$nb_inscr=0;
// si aucun champ spécifique ne doit être supprimé => on supprime tout => on ne réécrit aucune valeur
if ($delete != "" or count($delete) < 1)
{
////////////////
// DEBUT TEST //
////////////////
// début de la réécriture des enregistrements
$compt = 0; //compteur permettant de savoir quel champ est en cours de modifications
$i=1;
while ($i <= (count($tab_valeurs) - 2))
{
$compt++;
// si le compteur est supérieur au nombre de déclarations, on le réinitialise à 1
if ($compt > $nbre_declarations)
$compt=1;

$b=0;
$champs_ok=0;
// on parcourt chacun des champs du tableau de condition
while ($b < count($delete))
{
$c = 1;
$d = $i - $compt + 1;
// on parcourt chacun des champs déclarés
while ($c <= $nbre_declarations)
{
$condition = explode("=",$delete[$b]);
// si la condition est égale à la valeur du champ correspondant, c'est ok
if (($condition[0] == $declarations[$c]) && ($condition[1] == $tab_valeurs[$d]))
{
$champs_ok++;
break;
}
$d++;
$c++;
}
$b++;
}
if ($champs_ok == "0")
{
$nb_inscr++;
if ($nb_inscr == "1")
fwrite($fd, "#/#");
fwrite($fd, "$tab_valeurs[$i]#/#");
$traitement_ok = 1;
}
else
{
// si le champ n'est pas réinscrit => champ effacé, on incrémente le compteur
$this->affect++;
}
$i++;
}
//////////////
// FIN TEST //
//////////////
}
else
{
// si tous les enregistrement sont supprimés, la variable affect comporte le même chiffre que le nombre de champs enregistrés
$this->affect = ceil((count($tab_valeurs) - 2) / $nbre_declarations);
$ok_affect=1;
}

fwrite($fd, "[END_EBS_VALUES]");

if ($ok_affect != "1")
$this->affect = ceil($this->affect / $nbre_declarations);

// on inscrit la version du fichier EBS => si cette version est inscrite le fichier peut être utilisé -> pas de conflits
fwrite($fd, "$version ?>");
fclose($fd);
}

//////////////////////////////<?php
// récupération des données //
//////////////////////////////
function select($where="",$order="",$desc="ASC") {
// on réinitialise le tableau de résultats
$this->results=array();
// on réinitialise le tableau de clé de classement
$this->tab_tri=array();
// on réinitialise le compteur de champ modifiés
$this->affect=0;
// on vérifie si le fichier existe
$this->verif_exist();
// s'il existe on récupère son contenu
$result_scan=$this->verif_exact();
// s'il y a un ordre de tri, on le place en mémoire
if ($order != "")
$this->tri=$order;

// combien existe-t-il de champs déclarés dans le fichier ?
$declarations = explode("#=#",$result_scan);
$nbre_declarations = $this->verif_nb_declare($declarations);

// vérification de l'existence du champ de classement
$exact=0;
$a=1;
while ($a <= $nbre_declarations)
{
if ($order == $declarations[$a])
{
// la position nous sert un peu + loin dans cette fonction
$position = $a;
$exact++;
}
$a++;
}
if ($exact == "0" && $order != "")
die ("#EBS select erreur : - le champ de classement des valeurs n'existe pas dans la table");

if ($desc != "DESC" && $desc != "ASC")
die ("#EBS select erreur : - l'ordre de classemement n'est pas correct, sa valeur doit être égale à \"ASC\" (ordre normal) ou \"DESC\" (ordre inverse)");

// vérification de l'existence des conditions pouvant être déclarées
$i=0;
while (($i < count($where)) && $where != "")
{
$exact=0;
$a=1;
$word = explode("=",$where[$i]);
while ($a <= $nbre_declarations)
{
if ($word[0] == $declarations[$a])
$exact++;
$a++;
}
if ($exact == "0")
die ("#EBS select erreur : - au moins l'une des conditions de sélection n'est pas correcte ou est mal renseignée");
$i++;
}

// on récupère les valeurs préalablement enregistrées dans le fichier
$values_enr = $this->recup_values($result_scan);

// on vérifie si la version du fichier est inscrite
$version = $this->verif_version($result_scan);

// on récupère le nom du champ auto-incrémenté s'il existe
eregi("#-#auto:(.)+:([[:digit:]]+)#-#", $result_scan, $champ_auto);

// on récupère dans un tableau chacun des champs enregistré dans le fichier
$tab_valeurs = explode("#/#", $values_enr);

/////
// on lance la récupération des valeurs sélectionnées
/////
$compt = 0; //compteur permettant de savoir quel champ est en cours de modifications
$i=1;
$compteur_values=1;
while ($i <= (count($tab_valeurs) - 2))
{
$compt++;
// si le compteur est supérieur au nombre de déclarations, on le réinitialise à 1
if ($compt > $nbre_declarations)
$compt=1;

// s'il n'y a pas de conditions particulières à la sélection, on récupère tout
if ((count($where) < 1) or ($where == ""))
{
$this->results[$i] = $tab_valeurs[$i];
$this->affect++;
}
else
{
$a=0;
$champs_ok = 0;
while ($a < count($where))
{
$c = 1;
$d = $i - $compt + 1;
// on parcourt chacun des champs déclarés
while ($c <= $nbre_declarations)
{
$condition = explode("=",$where[$a]);
// si la condition est égale à la valeur du champ correspondant, c'est ok
if (($condition[0] == $declarations[$c]) && ($condition[1] == $tab_valeurs[$d]))
{
$champs_ok++;
}
$d++;
$c++;
}
$a++;
}

if ($champs_ok >= count($where))
{
$this->results[$compteur_values] = $tab_valeurs[$i];
$compteur_values++;
$this->affect++;
}
}

$i++;
}
$this->affect = ceil($this->affect / $nbre_declarations);

// si il existe un ordre de classement, on écrit la "clé" de classement dans la variable $tab_tri, nous avons
// toujours en mémoire le n° de la position dans les déclarations de la valeur du champ de classement (variable $position)
if ($order != "")
{
$i = 1;
$a = $position;
while ($i <= $this->affect)
{
$tab_result[$i] = $this->results[$a];
$i++;
$a = $a + $nbre_declarations;
}

if (count($tab_result) > 0)
{
// on classe le tableau
if ($desc == "DESC")
arsort($tab_result);
else
asort($tab_result);

// on récupère les clés pour les inscrires dans le tableau de sauvegarde "$tab_tri"
$i = 1;
while(list($cle) = each($tab_result))
{
$this->tab_tri[$i]=$cle;
$i++;
}
}
}
}

/////////////////////////////////////////////////////
// récupération des données spécifiques à un champ //
/////////////////////////////////////////////////////
function recup_select($champ="") {

// on vérifie si le fichier existe
$this->verif_exist();
// s'il existe on récupère son contenu
$result_scan=$this->verif_exact();

// combien existe-t-il de champs déclarés dans le fichier ?
$declarations = explode("#=#",$result_scan);
$nbre_declarations = $this->verif_nb_declare($declarations);

// si il n'y a pas de champ à récupérer => erreur
if ($champ == "")
die ("#EBS recup_select erreur : - vous n'avez pas précisé de champ à récupérer");

// vérification de l'existence du champ à récupérer
$exact=0;
$a=1;
while ($a <= $nbre_declarations)
{
if ($champ == $declarations[$a])
{
$position = $a;
$exact++;
}
$a++;
}
if ($exact == "0")
die ("#EBS recup_select erreur : - le champ que vous souhaitez récupérer n'existe pas");

$i = 1;
$a = $position;
while ($i <= $this->affect)
{
$tab_result[$i] = $this->results[$a];
$i++;
$a = $a + $nbre_declarations;
}

$tab_save = $tab_result;

if (count($this->tab_tri) > 0)
{
$i = 1;
while($i <= $this->affect)
{
$temp = $tab_save[$i];
$tab_result[$i] = $tab_save[$this->tab_tri[$i]];
$i++;
}
}

return $tab_result;
}

////////////////////////
// alter_insert table //
////////////////////////
function alter_insert($insert="",$values="") {

// on réinitialise le compteur de champ modifiés
$this->affect=0;
// on vérifie si le fichier existe
$this->verif_exist();
// s'il existe on récupère son contenu
$result_scan=$this->verif_exact();

// si le nombre de champs à insérer est différent de celui des valeurs qui lui sont attribuées => erreur
if (count($insert) != count($values))
die ("#EBS alter_insert erreur : - le nombre de champs à insérer est différent de celui des valeurs qui lui sont attribuées");

// combien existe-t-il de champs déclarés dans le fichier ?
$declarations = explode("#=#",$result_scan);
$nbre_declarations = $this->verif_nb_declare($declarations);

// si l'un des champs à insérer existe déjà => erreur
$i=0;
while (($i < count($insert)) && $insert != "")
{
$exact=0;
$a=1;
while ($a <= $nbre_declarations)
{
if ($insert[$i] == $declarations[$a])
$exact++;
$a++;
}
if ($exact > "0")
die ("#EBS alter_insert erreur : - au moins l'un des champs devant être insérer existe déjà dans la table");
$i++;
}

// on rajoute les valeurs du tableau "insert"
$i=0;
$valeur = $nbre_declarations;
while ($i < count($insert))
{
$valeur++;
$declarations[$valeur]=$insert[$i];
$i++;
}
// on rajoute le nbre de champ du tableau "insert"
$nbre_declarations += count($insert);

// on récupère les valeurs préalablement enregistrées dans le fichier
$values_enr = $this->recup_values($result_scan);

// on vérifie si la version du fichier est inscrite
$version = $this->verif_version($result_scan);

// on récupère le nom du champ auto-incrémenté s'il existe
eregi("#-#auto:(.)+:([[:digit:]]+)#-#", $result_scan, $champ_auto);

// on récupère dans un tableau chacun des champs enregistré dans le fichier
$tab_valeurs = explode("#/#", $values_enr);

// on inscrit le nombre de champs modifiés
$this->affect=ceil((count($tab_valeurs) - 1) / $nbre_declarations);

/////
// on lance la réécriture du fichier
/////
$fd = @fopen($this->nom,"w");

fwrite($fd, "<?php ");

// on boucle pour ré-inscrire les champs déclarés
$i=1;
while ($i <= $nbre_declarations)
{
fwrite($fd, "#=#$declarations[$i]");
$i++;
// si on arrive au dernier à inscrire => on rajoute un "#=#"
if ($i > $nbre_declarations)
fwrite($fd, "#=#");
}

// si champ auto-incrémenté existe => on l'inscrit ici
if ($champ_auto[0] != "")
fwrite($fd, "$champ_auto[0]");

fwrite($fd, "[START_EBS_VALUES]");

/////
// on lance la boucle d'insertion des valeurs du fichier + celles rajoutées
/////
$compt=0; // compteur permettant de savoir quel champ est en cours de modifications
$compt2=0; // compteur permettant de renseigner la clé du tableau de nouvelles valeurs à insérer
$i=1;
$compteur_values=1;
while ($i <= (count($tab_valeurs) - 2))
{
$compt++;
// si le compteur est supérieur au nombre de déclarations, on le réinitialise à 1
if ($compt > $nbre_declarations)
{
$compt=1;
$compt2=0;
}
if ($i == "1")
fwrite($fd, "#/#");

if ($compt <= ($nbre_declarations - count($insert)))
{
fwrite($fd, "$tab_valeurs[$i]#/#");
$i++;
}
else
{
// le caractère "#" n'est pas accepté => on supprime tous ceux que l'ont peut rencontrer
$values[$compt2] = $this->sup_diez($values[$compt2]);
fwrite($fd, "$values[$compt2]#/#");
$compt2++;
}
}
$i=0;
while ($i < count($insert))
{
$values[$compt2] = $this->sup_diez($values[$compt2]);
fwrite($fd, "$values[$compt2]#/#");
$compt2++;
$i++;
}

fwrite($fd, "[END_EBS_VALUES]");

// on inscrit la version du fichier EBS => si cette version est inscrite le fichier peut être utilisé -> pas de conflits
fwrite($fd, "$version ?>");
fclose($fd);
}

////////////////////////<?php
// alter_delete table //
////////////////////////
function alter_delete($champs="") {

// on réinitialise le compteur de champ modifiés
$this->affect=0;
// on vérifie si le fichier existe
$this->verif_exist();
// s'il existe on récupère son contenu
$result_scan=$this->verif_exact();

// combien existe-t-il de champs déclarés dans le fichier ?
$declarations = explode("#=#",$result_scan);
$nbre_declarations = $this->verif_nb_declare($declarations);

// vérification de l'existence des champs devant être supprimés
$this->verif_exist2($champs,$nbre_declarations,$declarations,"#EBS alter_delete erreur : - au moins l'un des champs devant être supprimé n'existe pas");

// on récupère les valeurs préalablement enregistrées dans le fichier
$values_enr = $this->recup_values($result_scan);

// on vérifie si la version du fichier est inscrite
$version = $this->verif_version($result_scan);

// on récupère le nom du champ auto-incrémenté s'il existe
eregi("#-#auto:(.)+:([[:digit:]]+)#-#", $result_scan, $champ_auto);

// on récupère dans un tableau chacun des champs enregistré dans le fichier
$tab_valeurs = explode("#/#", $values_enr);

// on inscrit le nombre de champs modifiés
$this->affect=ceil((count($tab_valeurs) - 2) / $nbre_declarations);

// on diminue le nombre le nbre de déclarations
$nbre_declarations -= count($champs);

/////
// on lance la réécriture du fichier
/////
$fd = @fopen($this->nom,"w");

fwrite($fd, "<?php ");

// on boucle pour ré-inscrire les champs déclarés
$i=1;
while ($i <= $nbre_declarations)
{
$a=0;
$ok=1;
while ($a < count($champs))
{
if ($declarations[$i] == $champs[$a])
$ok=0;
$a++;
}
if ($ok == "1")
fwrite($fd, "#=#$declarations[$i]");
$i++;
// si on arrive au dernier à inscrire => on rajoute un "#=#"
if ($i > $nbre_declarations)
fwrite($fd, "#=#");
}

// si champ auto-incrémenté existe => on l'inscrit ici
if ($champ_auto[0] != "")
fwrite($fd, "$champ_auto[0]");

fwrite($fd, "[START_EBS_VALUES]");

/////
// on lance la boucle d'insertion des valeurs du fichier - celles rajoutées
/////
$compt=0; // compteur permettant de savoir quel champ est en cours de modifications
$i=1;
while ($i <= (count($tab_valeurs) - 2))
{
$compt++;
// si le compteur est supérieur au nombre de déclarations, on le réinitialise à 1
if ($compt > ($nbre_declarations + count($champs)))
$compt=1;
if ($i == "1")
fwrite($fd, "#/#");

$a=0;
$ok=1;
while ($a < count($champs))
{
if ($champs[$a] == $declarations[$compt])
$ok=0;
$a++;
}

if ($ok == "1")
fwrite($fd, "$tab_valeurs[$i]#/#");

$i++;
}

fwrite($fd, "[END_EBS_VALUES]");

// on inscrit la version du fichier EBS => si cette version est inscrite le fichier peut être utilisé -> pas de conflits
fwrite($fd, "$version ?>");
fclose($fd);
}
}
?>