<?php
/* ------------------
include_once("../2013_01/cnx_class.php");// cnx - fonctions php et read parametre

exemple d'appel:
$cnxFiles->moveUploadSingle($strFichier);
où $cnxFiles est une classe contenant la fonction moveUploadSingle()
-------------------- */
include_once("../2013_01/passwordFAI.php"); //password for FAI

class claude {
    var $version;
    var $author;
    var $license;
 
    function claude() { //affectation de la valeur aux variables - porte toujours le nom de la classe
        $this->version = "2013-02-14";
        $this->author = "claudecnx jpconnexion";
        $this->license = 'licence claudecnx:  <a href="http://jpconnxion.free.fr/license/license_cnx.html" target="_blank" title="Licence et conditions d\'emploi">Licence Utilisation cnx</a>';
    } //function claude   
} //class claude
$cnx = new claude; //instanciation de la classe cnx

class cnxDivers { //imbrication pour essai
    const const_imbrication = 1; //permet de tester le chargement de la classe notamment dans le cas où la classe serait dans un autre fichier que cnx()
    var $var1; //définition des variables
    var $var2;
    function cnxDivers(){ //affectation des variables propres à la classe imbrication
        $var1 = 1;
        $var2 = "voir";
    } //function classImbrication
    
    function calcul($n1, $n2){
        $n1 = $n1 + $n2;
        //echo $n1;
        return $n1;
    } // function calcul
    
    function merge($a, $b){
        //echo $a.$b;
        return $a.$b;
    }
    
    function isWhat(){ //retourne le type de la variable passée en parametre
        $nombreArgs = func_num_args(); //nombre d'arguments que reçoit la fonction
        if ($nombreArgs == 0) {
            echo "pas de parametre";
            return "no argument";
        }
        else $test = func_get_arg(0);
        $type = "inconnu"; 
        if (isset($test)){
                if (is_numeric($test)) $type = "Nombre";
                if (is_int($test))    $type = $type." Entier"; //entier
                if (is_integer($test))    $type = $type." Integer";
                if (is_float($test))    $type = $type." Float"; //virgule flottante
                if (is_real($test))    $type = $type." Reel"; //réel
                if (is_double ($test))    $type = $type." Double"; //double
                if (is_long($test))    $type = $type." Long"; //long
                if (is_scalar($test))    $type = $type." Scalaire"; //scalaire (type spécial pouvant contenir les type int, float, string ou bool)
                if (is_bool($test))    $type = "Bool"; //Teste si la valeur est booléenne (true ou false, et non 0 ou 1)
                if (is_string($test))    $type = "String"; //Teste si la valeur est une chaîne ("abcdfsdf4561.1f16s")
                if (is_object($test))    $type = "Object"; //Teste si variable est de type Objet (class MonObjet)
                if (is_array($test))    $type = "Array"; //Teste s'il s'agit d'un tableau (array())
                if (is_resource($test))    $type = "Ressource PHP MySQL"; //Teste s'il s'agit d'une ressource PHP (liaison MySQL par exemple)
                if (is_null($test))    $type = "Null"; //Teste si la valeur est null (null)
                if (is_callable($test))    $type = "Fonction"; //Indique si la variable peut-être appellée comme fonction
        }
        else $type="Indefini Undefined variable";
        //echo $type;
        return $type;
    } //function isWhat
    
    function getMicroTime() { // retourne un temps en secondes et millisecondes
        $mtime = microtime();
        $mtime = explode(" ",$mtime);
        $mtime = $mtime[1] + $mtime[0];
        return ($mtime);
    }
    
    function factorielle($nbre){
        global $cnxDivers;
        if($nbre === 0)    return 1; //Si $nbre = 0 on retourne 1 car soit 1! = 1, soit on est arrivés à la fin du calcul
        else    return $nbre*$cnxDivers->factorielle($nbre-1); //Sinon on retourne le nombre multiplié par le reste de sa factorielle (avec $nbre décrémenté)
    }
    
    
    function getIp(){
         if (getenv('HTTP_CLIENT_IP'))    $ipClient = getenv('HTTP_CLIENT_IP');
         else if(getenv('HTTP_X_FORWARDED_FOR'))    $ipClient = getenv('HTTP_X_FORWARDED_FOR');
         else if(getenv('HTTP_X_FORWARDED'))    $ipClient = getenv('HTTP_X_FORWARDED');
         else if(getenv('HTTP_X_CLUSTER_CLIENT_IP'))    $ipClient = getenv('HTTP_X_CLUSTER_CLIENT_IP');
         else if(getenv('HTTP_FORWARDED_FOR'))    $ipClient = getenv('HTTP_FORWARDED_FOR');
         else if(getenv('HTTP_FORWARDED'))    $ipClient = getenv('HTTP_FORWARDED');
         else if(getenv('REMOTE_ADDR'))    $ipClient = getenv('REMOTE_ADDR');
         else    $ipClient = 'UNKNOWN';
         return $ipClient; 
    }
    
} //class cnxDivers
$cnxDivers = new cnxDivers;

class cnxFiles { //classes files
    const const_files = 1; //permet de tester le chargement de la classe notamment dans le cas où la classe serait dans un autre fichier que cnx()
    var $var1; //définition des variables
    var $var2;
    function cnxFiles(){ //affectation des variables propres à la classe
        $var1 = "voie";
        $var2 = "voir";
    } //function files
    
    function curPageName() { //nom de la page courante avec son extension
        /* -------------
        $texte = $cnxFiles->curPageName();
        print $texte;
        --------------- */
        return substr($_SERVER["SCRIPT_NAME"],strrpos($_SERVER["SCRIPT_NAME"],"/")+1);
    } //curPageName
    
    function curPageURL() { //URL de la page courante
        /* ----------------
        $texte = $cnxFiles->curPageURL();
        print $texte;
        --------------------- */
        $URL_page = 'http';
        if (isset($_SERVER["HTTPS"]) && $_SERVER["HTTPS"] == "on") {$URL_page .= "s";}
        $URL_page .= "://";
        if ($_SERVER["SERVER_PORT"] != "80") {
            $URL_page .= $_SERVER["SERVER_NAME"].":".$_SERVER["SERVER_PORT"].$_SERVER["REQUEST_URI"];
        } else {
            $URL_page .= $_SERVER["SERVER_NAME"].$_SERVER["REQUEST_URI"];
        }
        return $URL_page;
    } //function curPageURL

    function moveUploadSingle(){ //déplace le fichier uploadé du dossier temporaire vers le dossier courant sur le serveur
        /* ----------------------------
        inputFileName est le name du contrôle de formulaire de type input file associé au téléchargement!
        Déplace le fichier uploadé du dossier temporaire vers le dossier courant sur le serveur
        ------------------------- --------------------------
        if (isset($_FILES[$inputFileName])){ //teste si le formulaire peut télécharger un fichier
            $kontrol_file = $_FILES[$inputFileName]; //controle file dans le formulaire - ne fonctionne que si input file est unique dans le formulaire
            => $kontrol_file = $_FILES[$inputFileName] = $inputFileName et contient un array
            il faut pour cela que la ligne $$cnx_FILES_Upload = $v soit activée dans read_parametre, autrement seule la ligne $_FILES[$inputFileName] fonctionne
        ---------------------------------- */
        global $cnx_FILES_Upload; //rend la variable $cnx_FILES_Upload accessible à cette fonction - $cnx_FILES_Upload provient de read_parametre section
        
        $nombreArgs = func_num_args(); //nombre d'arguments que reçoit la fonction
        if ($nombreArgs == 0)    $inputFileName = $cnx_FILES_Upload; //aucun argument de reçu, prend par défaut la valeur $cnx_FILES_Upload de read parametre qui contient un String représentant le name du dernier input file
        else     $inputFileName = func_get_arg(0); //retourne le premier argument passé en paramètre à la fonction
        
        if (is_string($inputFileName))     $kontrol_file = $_FILES[$inputFileName]; //en fait $cnx_FILES_Upload est transmis en paramètre
        else $kontrol_file = $inputFileName; //controle file input dans le formulaire
        
        if (isset($kontrol_file)) { //teste si le formulaire peut télécharger un fichier
            $tmp_file = $kontrol_file['tmp_name']; //nom du fichier temporaire qui sera téléchargé
            $type_file = $kontrol_file['type']; // extension du fichier à télécharge
            $name_file = $kontrol_file['name']; //nom du fichier à télécharger du système client
            $size_file = $kontrol_file['size']; //taille du fichier à télécharger
            $error_file = $kontrol_file['error']; //une erreur est elle survenue - pas d'erreur si 0
            /* ----------------------------
            cherche le dossier courant sur le serveur
            par dossier courant, il faut comprendre le dossier contenant la présente page web
            -------------------- */
            $page_courante = $this->curPageName(); //nom de la page courante avec son extension
            $script_name = $_SERVER['SCRIPT_NAME']; //chemin de la page courante y compris son nom et son extension
            $dossier_courant = substr($script_name, 0, - strlen($page_courante));  // retourne le dossier contenant la page courante
            
            /* -------------------------
            vérification de l'extension du fichier à uploader
            il est ainsi possible de traiter différement certains types de fichiers
            ------------------------------ */
            $extensions_valides = array( 'csv' , 'txt', 'html','php','js','gif', 'jpg', 'avi', 'flv', 'mp3', 'xls', 'doc' );
            $extension_upload = substr(strrchr($name_file, '.')  ,1); //extension du fichier à télécharger
            if (in_array($extension_upload,$extensions_valides) ){ //vérification de l'extension de fichier à télécharger
                // echo "L'extension est dans la liste des extensions valides! \n </br>";
            } else {
                //echo "L'extension n'est pas dans la liste des extensions valides! \n </br>";
            }
            /* ---------------
            transfert du fichier temporaire vers le dossier courant du serveur
            --------------------- */
            if ($error_file == UPLOAD_ERR_OK) { //UPLOAD_ERR_OK = 0 - pas d'erreur lors du uploadage temporaire du fichier
                $uploads_dir = $_SERVER['DOCUMENT_ROOT'].$dossier_courant;
                $final_name = "$uploads_dir$name_file"; //chemin complet de la page sur le serveur exprimé dans le système de fichier du serveur (ex sous Unix)
                $reponse = move_uploaded_file($tmp_file, $final_name); //déplacement du fichier temporaire dans le dossier courant
                if ($reponse) { //transfert réussi! nous fournissons le lien HTTP:// du fichier sur le serveur
                    $lien = $this->curPageURL(); //URL de la page courante
                    $page_courante = $this->curPageName(); //nom de la page courante
                    $lien = substr($lien, 0, - strlen($page_courante));  // retourne le dossier contenant la page courante sans le nom de la page courante
                    $lien = $lien.$name_file; //ajoute le nom du fichier uploadé au dossier contenant la page courante
                    echo "<p>Upload du fichier <span style='color:#00f'><strong> <a href='$lien' target='_blank'>$name_file</a></strong></span> </p>";
                    return "$final_name"; //retourne la position du fichier dans le système de fichier du serveur (ex Unix...)
                }
            }
            /* -----------------------
            Gestion des erreurs sur le serveur lors de l'Upload
            ------- */
            if($error_file == UPLOAD_ERR_INI_SIZE){
                echo "Valeur : 1. Le fichier telecharge excede la taille de upload_max_filesize, configuree dans le php.ini. ";
                return false;
            }
            if ($error_file == UPLOAD_ERR_FORM_SIZE){
                echo "Valeur : 2. Le fichier telecharge excede la taille de MAX_FILE_SIZE, qui a ete specifiee dans le formulaire HTML. ";
                return false;
            }
            if($error_file == UPLOAD_ERR_PARTIAL){
                echo "Valeur : 3. Le fichier n'a ete que partiellement telecharge. ";
                return false;
            }
            if ($error_file == UPLOAD_ERR_NO_FILE){
                echo "Valeur : 4. Aucun fichier n'a ete telecharge. ";
                return false;
            }
            if ($error_file == UPLOAD_ERR_NO_TMP_DIR){
                echo "Valeur : 6. Un dossier temporaire est manquant. Introduit en PHP 5.0.3. ";
                return false;
            }
            if($error_file == UPLOAD_ERR_CANT_WRITE){
                echo "Valeur : 7. Echec de l'ecriture du fichier sur le disque. Introduit en PHP 5.1.0. ";
                return false;
            }
            if ($error_file == UPLOAD_ERR_EXTENSION){
                echo "Valeur : 8. Une extension PHP a arrete l'envoi de fichier. PHP ne propose aucun moyen de determiner quelle extension est en cause. L'examen du phpinfo() peut aider. Introduit en PHP 5.2.0. ";
                return false;
            }
        }    
    } //function moveUploadSingle
    
    function saveFile(){ // écrit ou ajoute une String dans un fichier
        /* ------------------
        $a = $cnxFiles->saveFile($textFile, $fichier); 
        $textFile as String
        $fichier as String
        $mode as String
        $mode = r => read; w => write; a => add-ajout; le signe + indique lecture et écriture pour chacune des options
        --------------------- */
        $nombreArgs = func_num_args(); //nombre d'arguments que reçoit la fonction
        $textFile = func_get_arg(0); //retourne le premier argument passé en paramètre à la fonction
        $fichier = func_get_arg(1);
        $mode = func_get_arg(2);
        if ($fichier) { //le deuxième paramètre comportant le nom du fichier existe
            $handle = fopen($fichier, $mode); //Ouvre le fichier suivant le mode choisit (rien ne sera éffacé). - Si le fichier n'existe pas, on tente de le créer. 
            $textFile = htmlspecialchars_decode($textFile, ENT_QUOTES); // Convertit les entités HTML spéciales en caractères
            fwrite($handle, $textFile); //écrit dans le fichier
            fclose($handle); //ferme le fichier
            /*
            $pageCourante = $cnxFiles->curPageName();
            $pageURL = $cnxFiles->curPageURL();
            $dossierCourant = substr($pageURL, 0, -strlen($pageCourante));
            $fichierURL = $dossierCourant.$fichier;
            */
            //echo $fichier;
            return $fichier;
        }
    }
    
    function readFile(){ //lecture du contenu d'un fichier as String
        /* -----------------
        $a = $cnxFiles->readFile($fichier); 
        ------- */
        $nombreArgs = func_num_args(); //nombre d'arguments que reçoit la fonction
        $fichier = func_get_arg(0); //retourne le premier argument passé en paramètre à la fonction
        //echo $fichier."<br/>";
        $fp = fopen($fichier,"r"); //ouvre le fichier en lecture
        $page = ""; //contiendra le contenu du fichier
        while (!feof($fp)) { //on parcourt toutes les lignes
          $page .= fgets($fp); // lecture du contenu de la ligne
        }
        //echo "c'est fini!</br>";
        //echo $page;
        return $page;
    }
    
    function readCSV(){ //lit un fichier CSV intégralement
        /* --------------------
        $texte = $cnxFiles->readCSV("data.csv");
        print $texte;
        ------------------------ */
        $nombreArgs = func_num_args(); //nombre d'arguments que reçoit la fonction
        $file = func_get_arg(0); //retourne le premier argument passé en paramètre à la fonction
        if ($nombreArgs > 1) $length = func_get_arg(1);
        else $length = 0;
        if ($nombreArgs > 2) $delimiter = func_get_arg(2);
        else $delimiter = ";";
        if ($nombreArgs > 3) $enclosure = func_get_arg(3);
        else $enclosure = '"';
        if ($nombreArgs > 4) $escape = func_get_arg(4);
        
        $row = 1;
        if (($handle = fopen($file, "r")) !== FALSE) {
            $texte = "";
            while (($data = fgetcsv($handle, $length, "$delimiter","$enclosure")) !== FALSE) { //array fgetcsv
                $num = count($data);
                $texte = $texte . "<p> $num champs à la ligne $row: <br /></p>\n";
                $row++;
                for ($c=0; $c < $num; $c++) {
                    $texte = $texte . $data[$c] . "<br />\n";
                }
            }
            fclose($handle);
            //print $texte;
            return $texte;
        }
    } //function readCSV
    
    function readCSV_firstLine(){ //lit la première ligne d'un fichier CSV
        /* ------------------
        $texte = $cnxFiles->readCSV_firstLine("data.csv");
        print $texte;
        ----------------------- */
        $nombreArgs = func_num_args(); //nombre d'arguments que reçoit la fonction
        $file = func_get_arg(0); //retourne le premier argument passé en paramètre à la fonction
        if ($nombreArgs > 1) $length = func_get_arg(1);
        else $length = 0;
        if ($nombreArgs > 2) $delimiter = func_get_arg(2);
        else $delimiter = ";";
        if ($nombreArgs > 3) $enclosure = func_get_arg(3);
        else $enclosure = '"';
        if ($nombreArgs > 4) $escape = func_get_arg(4);
        
        if (($handle = fopen($file, "r")) !== FALSE) {
            ($data = fgetcsv($handle, $length, "$delimiter","$enclosure")) !== FALSE ; //array fgetcsv - attention à la position des parenthèse autour de $data
            $num = count($data);
            $texte = "<p> $num champs à la ligne 1: <br /></p>\n";
            for ($c=0; $c < $num; $c++) {
                $texte = $texte . $data[$c] . "<br />\n";
            }
            fclose($handle);
            return $texte;
        }
    } //function readCSV_firstLine
    
    function readCSV_firstLine_asTable(){ //lit la première ligne d'un fichier CSV et la retourne comme une table
        /* -------------
        $texte = $cnxFiles->readCSV_firstLine_asTable("data.csv");
        print $texte;
        --------------- */
        $nombreArgs = func_num_args(); //nombre d'arguments que reçoit la fonction
        $file = func_get_arg(0); //retourne le premier argument passé en paramètre à la fonction
        if ($nombreArgs > 1) $length = func_get_arg(1);
        else $length = 0;
        if ($nombreArgs > 2) $delimiter = func_get_arg(2);
        else $delimiter = ";";
        if ($nombreArgs > 3) $enclosure = func_get_arg(3);
        else $enclosure = '"';
        if ($nombreArgs > 4) $escape = func_get_arg(4);
        
        if (($handle = fopen($file, "r")) !== FALSE) {
            ($data = fgetcsv($handle, $length, "$delimiter","$enclosure")) !== FALSE ; //array fgetcsv - attention à la position des parenthèse autour de $data
            $num = count($data);
            $texte =  "<table border=1>\n";
            //echo "<tr>\n";
            for ($c=0; $c < $num; $c++) {
                $texte = $texte . "<td>$data[$c]</td>\n";
            }
            fclose($handle);
            $texte = $texte . "</tr>\n";
            $texte = $texte . "</table>\n";
        }
        return $texte;
    } //function readCSV_firstLine_asTable
    
    function readCSV_firstLine_asSQL(){ //lit la première ligne d'un fichier CSV et retourne les noms des champs comme partie de SQL
        /* -----------------
        $texte = $cnxFiles->readCSV_firstLine_asSQL("data.csv");
        print $texte;
        --------------------- */
        $nombreArgs = func_num_args(); //nombre d'arguments que reçoit la fonction
        $file = func_get_arg(0); //retourne le premier argument passé en paramètre à la fonction - ici le nom du fichier CSV
        if ($nombreArgs > 1) $length = func_get_arg(1); //limite la lecture du fichier - si 0 lit tout le fichier
        else $length = 0;
        if ($nombreArgs > 2) $delimiter = func_get_arg(2); //delimiteur de champ CSV - généralement ;
        else $delimiter = ";";
        if ($nombreArgs > 3) $enclosure = func_get_arg(3); //caractère encadrant un champ - généralement "champ" - peu utilisé
        else $enclosure = '"';
        if ($nombreArgs > 4) $escape = func_get_arg(4); //le caractère de fin de fichier \ ou \n - ne transmettre que \ - peu utilisé
        
        if (($handle = fopen($file, "r")) !== FALSE) {
            ($data = fgetcsv($handle, $length, "$delimiter","$enclosure")) !== FALSE ; //array fgetcsv - attention à la position des parenthèse autour de $data
            $num = count($data);
            for ($c=0; $c < $num; $c++) {
                if ($c == 0)    $champs =  "`$data[$c]`  TEXT NOT NULL";
                else $champs =  $champs . ", `$data[$c]`  TEXT NOT NULL";
            }
            fclose($handle);
            $champs = "(" . $champs . ") "; //ENGINE = MYISAM ou ENGINE = InnoDB
            //echo $champs."</br>"; //(`Prenom` TEXT NOT NULL, `Nom` TEXT NOT NULL, `Rue` TEXT NOT NULL, `Ville` TEXT NOT NULL) ENGINE = InnoDB;
            return $champs;
        }
    } //readCSV_firstLine_asSQL
    
    function listDossier($path){ //liste un dossier
        /* ------------------
            exemple d'utlisation
            $path = '.'; //On définit la racine
            $tableau_elements = $cnxFiles->listDossier($path); //Appel à notre fonction
            $file = fopen('./arborescence.txt', 'w+'); //On ouvre un fichier et on y copie le tableau
            fwrite($file, implode($tableau_elements, "\n"));
            fclose($file);
            ----- */
        global $cnxFiles;
        $tableau_elements = array(); //Déclare le tableau qui contiendra tous les éléments de nos dossiers
        $dir = opendir($path); //ouvre le dossier
        while (($element_dossier = readdir($dir)) !== FALSE){ //Pour chaque élément du dossier...
            if ($element_dossier != '.' && $element_dossier != '..' && is_dir($path.'/'.$element_dossier)){ //Si l'élément est lui-même un dossier (en excluant les dossiers parent et actuel), on appelle la fonction de listage en modifiant la racine du dossier à ouvrir
                $tableau_elements = array_merge($tableau_elements, $cnxFiles->listDossier($path.'/'.$element_dossier)); //On fusionne ici le tableau grâce à la fonction array_merge. Au final, tous les résultats de nos appels récursifs à la fonction listage fusionneront dans le même tableau
            }
            elseif ($element_dossier != '.' && $element_dossier != '..'){ //Sinon, l'élément est un fichier : on l'enregistre dans le tableau
                $tableau_elements[] = $path.'/'.$element_dossier;
            }
         }
         closedir($dir); //Ferme le dossier
         return $tableau_elements; //Retourne le tableau
    }
    
} //end of class files
$cnxFiles = new cnxFiles();

class cnxMysql { //gestion des bases de données
    const const_SQL = 1; //permet de tester le chargement de la classe notamment dans le cas où la classe serait dans un autre fichier que cnx()
    var $var1; //définition des variables
    var $var2;
    var $linkIdentifier ; //indicateur de connection
    var $database; //base de données qui est connectée
    
    function cnxMysql(){ //affectation des variables propres à la classe imbrication
        $var1 = 1;
        $var2 = "voir";
        
    } //function 
    
    function mysqlConnect(){ //connexion de la base de données du sevreur mySQL
        global $cnxMysql;
        global $ip_client;
        global $passwordFAI;
        if ($ip_client == "127.0.0.1") {
            //echo "IP client: $ip_client"."</br>";
            $hostname = 'localhost'; // l'adresse de votre serveur php
            $username = 'root'; // votre login : root sur localhost
            $password = ''; // votre pass : vide sur localhost
            $bdd = 'claudecnx'; // le nom de la base de données
        } //if ($ip_client == "127.0.0.1")
        else {
            $hostname = 'free.fr'; // IP du serveur mysql ou encore $sql_host="sql.free.fr"; pour free
            $username = "jpconnexion";//nom d'utilisateur déclaré lors de la création de la base
            $password = $passwordFAI; // votre password : vide sur localhost
            $bdd = 'jpconnexion'; // le nom de la base de donnéees
        }
        
        $link = mysql_connect("$hostname","$username","$password"); //Connexion Ã  la base de données
        mysql_select_db("$bdd") OR die( "ERREUR de connexion : " . mysql_error () ); //connexion à  la base de donnéees
        $cnxMysql->database = $bdd; //mémorise la base de données connectée
        return $link; //retourne un pointeur
    } //end of mysqlConnect()
    
    function mysqlLoadDataInfile(){ //Charge data form file in table mysql
        /* ------------------ 
        appel:
        if (isset($fichiercsv)){ //$fichiercsv est défini dans read_parametre et contient le name du controle de formulaire de type input file
            $actualisation = $cnxMysql->mysqlLoadDataInfile($fichiercsv, $tableListe, $delimiteurCSV); //met à jour $tableListe avec les données de $uploadedFile
        }
        ------------------ */
        $nombreArgs = func_num_args(); //nombre d'arguments que reçoit la fonction
        $fichier = func_get_arg(0);
        $table = func_get_arg(1);
        if ($nombreArgs > 2)    $delimiteurCSV = func_get_arg(2); //
        else     $delimiteurCSV = ";"; //valeur par défaut

        global $cnxFiles; //permet l'accés à la classe $cnxFiles
        $uploadedFile = $cnxFiles->moveUploadSingle($fichier); //télécharge le fichier sur le serveur - même dossier que ce script
        if ($uploadedFile){
            $length = 0; // longueur des données à lire - 0 signifie pas de limitation
            $delimiter = "$delimiteurCSV"; //Spécifie le séparateur (un seul caractère). 
            $enclosure = '"'; //Spécifie le caractère d'encadrement de texte (un seul caractère). - '\"'
            $escape = '\\n'; //Définit le caractère d'échappement (un seul caractère). Par défaut, c'est un antislash='\n'. - '\\n'

            $listeChamps = $cnxFiles->readCSV_firstLine_asSQL($uploadedFile, $length, $delimiter, $enclosure, $escape); //lit la première ligne et retourne le nom de champs as SQL request
        
            global $cnxMysql;
            $link = $cnxMysql->mysqlConnect();
            
            $sql= "CREATE TABLE IF NOT EXISTS `$table` $listeChamps"; //(`Prenom` TEXT NOT NULL, `Nom` TEXT NOT NULL, `Rue` TEXT NOT NULL, `Ville` TEXT NOT NULL) ENGINE = InnoDB;
            $result = mysql_query($sql) or die('Erreur SQL : '.mysql_error());
    
            if (($handle = fopen($uploadedFile, "r")) !== FALSE) {
                ($data = fgetcsv($handle, $length, "$delimiter","$enclosure")) !== FALSE ; //array fgetcsv - attention à la position des parenthèses autour de $data
                $numFields = count($data); //nombre de champs dans le fichier CSV
                //echo "<p> $numFields champs à la ligne 1: <br /></p>\n";
                while (!feof($handle)) { //tant qu'on est pas a la fin du fichier :
                    $uneLigne = fgets($handle); // On recupere toute la ligne
                    $uneLigne = trim($uneLigne); //supprime espace et autres caractères indésirable
                    $arrayValeurs = explode("$delimiter", $uneLigne); //On met dans un tableau les differentes valeurs trouvés (ici séparées par un ';') 
                    $num_arrayValeurs = count($arrayValeurs);
                    if ($numFields == $num_arrayValeurs){ //vérifie que la ligne contient autant de champ que la ligne de titre
                        $valeurChamps = "";
                        for ($x = 0; $x < $numFields; $x++){
                            if( strstr($arrayValeurs[$x], "'"))    $arrayValeurs[$x] = htmlspecialchars("$arrayValeurs[$x]", ENT_QUOTES); //transforme ' en  &#039;
                            if( strstr($arrayValeurs[$x], '"'))    $arrayValeurs[$x] = htmlspecialchars("$arrayValeurs[$x]"); //tranforme " en "&quot;"
                            $valeurChamps = "$valeurChamps'$arrayValeurs[$x]',"; //il faut supprimer la dernière virgule sinon erreur SQL
                        }
                        $valeurChamps = substr($valeurChamps, 0, -1);    //$rest = substr("abcdef", 0, -1);  // retourne "abcde" -- supprime le dernier caractère ici la virgule
                        $sql="INSERT INTO `$table` VALUES ($valeurChamps)"; //pour mémoire ` s'obtient avec ALT+96 - encadre le nom d'une table ou d'une base
                        //echo "texte de la requete: ".$sql."</br>";
                        $result = mysql_query($sql) or die('Erreur SQL : '.mysql_error());; // la ligne est finie donc on passe a la ligne suivante (boucle)
                    }
                }
                fclose($handle);
                
            }
            mysql_close($link);
            return "table SQL: <font color='green'> $table </font> updated with <font color='green'> $uploadedFile </font> ";
        }
    } //end of loadDataInfile
    
    function mysqlAsTable(){ //retourne le jeu d'enregistrement sous forme <table> La première ligne contient les champs
        /* ----------------------
        appel:
        $requete = "select * from data ";
        $texte = $cnxMysql->mysqlAsTable($requete); 
        -------------------- */
        $nombreArgs = func_num_args(); //nombre d'arguments que reçoit la fonction
        $sql = func_get_arg(0);
        
        global $cnxMysql;
        $link = $cnxMysql->mysqlConnect();

        $result = mysql_query($sql) or die('Erreur SQL : '.mysql_error()); //choix de la base de donnees
        $rows = mysql_num_rows($result); //compte le nombre d'enregistrements de la requête
        if ($rows >0){ //retourne false si la requête ne retourne aucun champ
            /* génère la <table> et le nom des champs */
            $fields = mysql_num_fields($result); //compte le nombre de champs
            $texteTable = "<table border=1> <caption style='caption-side:bottom; font-weight:bold; text-decoration:underline;'>The request [ $sql ] contains $rows recordings and $fields fields.</caption><thead><tr align=center >";//ecrit le titre du tableau avec le nom des champs
            for ($i=0; $i < $fields; $i++){
                $champ[$i] = mysql_field_name($result, $i); //retourne le nom du champ dans la requete mysql
                $texteTable = $texteTable ."<th> $champ[$i] </th>"; //liste tous les champs
            }
            $texteTable = $texteTable . "</tr></thead><tbody>";
            
            /* écrit les données */
            while ($row = mysql_fetch_array($result, MYSQL_BOTH)) { //écrit le corps du tableau avec le contenu des enregistrements
               $texteTable = $texteTable . "<tr>";
                for ($i=0; $i < $fields; $i++){ //$fields contient le nombre de champs
                    $texteTable = $texteTable . "<td> $row[$i] </td>"; //$row est la ligne d'enregistrement retourné par la requete
                }
                $texteTable = $texteTable . "</tr>";
            }
            $texteTable = $texteTable . "</tbody><tfoot></tfoot></table>";    
        }
        else $texteTable =  "requete valide - 0 enregistrement trouvé!";
        mysql_close($link);
        return $texteTable;
    } // end of mysqlAsTable
    
    function mysqlAsXML(){ //retourne la requête sous forme de fichier xml()
        /* -------------------
        appel:
        $requete = "select * from data ";
        $ret = $cnxMysql->sqlAsXML($requete, "texte.xml"); //génère un fichier - retourne le nom du fichier
        $ret = $cnxMysql->sqlAsXML($requete, false); //génère du XML - retourne la chaine XML
        
        si le fichier existe "texte.xml" écrit le fichier, le crée si besoin
        Si ce deuxième paramètre est omis, écrit le texte correspondant à la chaine xml et retourne cette chaine xml
        
        en cas d'erreur mysql écrit le code erreur mysql
        
        Si la requête ne retourne pas de données, retourne et/ou écrit 0;
        ---------------- */
        $nombreArgs = func_num_args(); //nombre d'arguments que reçoit la fonction
        $sql = func_get_arg(0);
        if ($nombreArgs > 1)    $fichier = func_get_arg(1); //teste si un fichier est demandé
        else $fichier = false;

        global $cnxMysql;
        $link = $cnxMysql->mysqlConnect();
        
        $result = mysql_query($sql) or die('Erreur SQL : '.mysql_error()); //choix de la base de donnees
        $rows = mysql_num_rows($result); //compte le nombre d'enregistrements de la requête
        
        if ($fichier){
            $retourLigne = "\r\n";
            $parentheseOuvrante = "<";
        } else {
            $retourLigne = "</br>";
            $parentheseOuvrante = "&lt;"; // "<"
        }

        if ($rows > 0){ //retourne 0 si la requête ne retourne aucun champ
            $fields = mysql_num_fields($result); //compte le nombre de champs
            $texteXML = $parentheseOuvrante.'?xml version="1.0" encoding="ISO-8859-1"?>'.$retourLigne;

            $texteXML =  $texteXML."$parentheseOuvrante!-- Requete : $sql --> $retourLigne"; //
            $texteXML =  $texteXML."$parentheseOuvrante!-- Cette requete contient $rows enregistrements.  --> $retourLigne";
            $texteXML =  $texteXML."$parentheseOuvrante!-- Cette requete contient $fields champs.  --> $retourLigne";
            $texteXML =  $texteXML.$parentheseOuvrante."rows>$retourLigne";
            
            $replace = "___";
            $texteXML = $texteXML.$parentheseOuvrante."row>$retourLigne";
            for ($i=0; $i < $fields; $i++){ //écrit le nom des champs dans la ligne[0]
                $champ[$i] = mysql_field_name($result, $i); //retourne le nom du champ dans la requete mysql
                $champJS[$i] = str_replace(" ", $replace, $champ[$i]); //champ nom composé type "last adress" devient last$$$adress - compatibilité avec variable javascript
                $texteXML = $texteXML."$parentheseOuvrante$champJS[$i]>$champ[$i]$parentheseOuvrante/$champJS[$i]>$retourLigne";
            }
            $texteXML = $texteXML."$parentheseOuvrante/row>$retourLigne";

            while($row = mysql_fetch_array($result, MYSQL_BOTH) ) { //lit les enregistrements
                $texteXML = $texteXML.$parentheseOuvrante."row>$retourLigne";
                for ($i=0; $i < $fields; $i++){ //$fields contient le nombre de champs
                    $texteXML = $texteXML."$parentheseOuvrante$champJS[$i]>$row[$i]$parentheseOuvrante/$champJS[$i]>$retourLigne";
                }
                $texteXML = $texteXML.$parentheseOuvrante."/row>$retourLigne";
            }
            
            $texteXML =  "$texteXML$parentheseOuvrante/rows> $retourLigne";
            
            if ($fichier) { //le deuxième paramètre comportant le nom du fichier existe
                $handle = fopen($fichier, "w"); //ouvre ou créé le fichier - efface le contenu précédant
                $texteXML = htmlspecialchars_decode($texteXML, ENT_QUOTES); // Convertit les entités HTML spéciales en caractères
                fwrite($handle, $texteXML); //écrit dans le fichier
                fclose($handle); //ferme le fichier
                mysql_close($link);
                return $fichier;
            } 
            else {
                mysql_close($link);
                return $texteXML; //retourne la chaine de caractère xml
            }
        }
        else {
            mysql_close($link);
            return 0;
        }
    } //end of mysqlAsXML()
    
    function mysqlAsCSV() { //retourne la requête sous forme de fichier CSV - La première ligne contient les champs
        /* -------------------
        appel:
        $requete = "select * from book ";
        $ret = $cnxMysql->mysqlAsCSV($requete, "texte.csv"); //génère un fichier - retourne le nom du fichier
        $ret = $cnxMysql->mysqlAsCSV($requete, false); //génère du XML  retourne la chaine CSV
        
        si le fichier existe "texte.csv" écrit le fichier, le crée si besoin et renvoi true (1)
        Si ce deuxième paramètre est omis, écrit le texte correspondant à la chaine csv et retourne cette chaine csv
        
        3ieme argument: true affiche en php, false empêche l'affichage "echo" - par défaut true donc affichage
        
        en cas d'erreur mysql écrit le code erreur mysql
        
        Si la requête ne retourne pas de données, retourne et/ou écrit 0;
        ---------------- */
        global $cnxFiles;
        $nombreArgs = func_num_args(); //nombre d'arguments que reçoit la fonction
        $sql = func_get_arg(0);
        if ($nombreArgs > 1)    $fichier = func_get_arg(1);
        else $fichier = false;
        
        global $cnxMysql;
        $link = $cnxMysql->mysqlConnect();
        
        $result = mysql_query($sql) or die('Erreur SQL : '.mysql_error()); //choix de la base de donnees
        $rows = mysql_num_rows($result); //compte le nombre d'enregistrements de la requête
        
        $fichier ? $retourLigne = "\r\n": $retourLigne = "</br>";
    
        if ($rows > 0){ //retourne 0 si la requête ne retourne aucun champ
            $fields = mysql_num_fields($result); //compte le nombre de champs
            $texteCSV = "";
            //if ($fichier == false)    $texteCSV = $texteCSV . "Cette requete contient $rows enregistrements. </p>";
            
            for ($i=0; $i < $fields; $i++){
                $champ[$i] = mysql_field_name($result, $i); //retourne le nom du champ dans la requete mysql
                $texteCSV = $texteCSV . "$champ[$i];"; //liste tous les champs
            }
            $texteCSV = substr($texteCSV, 0, -1); //supprime le dernier caractère, ici ;
            $texteCSV = $texteCSV ."$retourLigne";

            while( ($row = mysql_fetch_array($result, MYSQL_BOTH)) ) { //lit les enregistrements
                for ($i=0; $i < $fields; $i++){ //$fields contient le nombre de champs
                    $texteCSV = $texteCSV . "$row[$i];"; //$row est le nombre d'enregistrements retourné par la requete
                }
                $texteCSV = substr($texteCSV, 0, -1); //supprime le dernier caractère, ici ;
                
                $texteCSV = $texteCSV . "$retourLigne";
            }
            
            if ($fichier) { //le deuxième paramètre comportant le nom du fichier existe
                $handle = fopen($fichier, "w"); //ouvre ou créé le fichier - efface le contenu précédant
                $texteCSV = htmlspecialchars_decode($texteCSV, ENT_QUOTES); // Convertit les entités HTML spéciales en caractères
                fwrite($handle, $texteCSV); //écrit dans le fichier
                fclose($handle); //ferme le fichier
                /*
                $pageCourante = $cnxFiles->curPageName();
                $pageURL = $cnxFiles->curPageURL();
                $dossierCourant = substr($pageURL, 0, -strlen($pageCourante));
                $fichierURL = $dossierCourant.$fichier;
                */
                mysql_close($link);
                return $fichier;
            } 
            else {
                mysql_close($link);
                return $texteCSV; //retourne la chaine de caractère CSV
            }
        }
        else {
            mysql_close($link);
            return 0; //pas de résultat pour la requête
        }
    } //end of mysqlAsCSV()                                            

    function mysqlAsArray(){ //retourne la requête sous forme Array()
        $nombreArgs = func_num_args(); //nombre d'arguments que reçoit la fonction
        $sql = func_get_arg(0);
        
        global $cnxMysql;
        $link = $cnxMysql->mysqlConnect();
        
        $result = mysql_query($sql) or die('Erreur SQL : '.mysql_error()); //choix de la base de donnees
        $rows = mysql_num_rows($result); //compte le nombre d'enregistrements de la requête
        
        if ($rows > 0){ //retourne 0 si la requête ne retourne aucun champ
            $fields = mysql_num_fields($result); //compte le nombre de champs
            $retourChariot = "";
            $enteteHTML = '<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /></head><body>';
            $finHTML = "</body></html>";
            
            $texteArray = "Cette requete contient $rows enregistrements. </p>";
            $texteArray = "";
            
            /* -----------------------
            génère Array() pour javascript 
            La première ligne contient le nom des champs
            cnxResult[i][0] => fourni le nom des champs de la requête
            ------------------ */
            $texteArray = "$texteArray var cnxResult = new Array(); $retourChariot";
            $replace = "___";
            for ($i=0; $i < $fields; $i++){ //écrit le nom des champs dans la ligne[0]
                $champ[$i] = mysql_field_name($result, $i); //retourne le nom du champ dans la requete mysql
                $champJS[$i] = str_replace(" ", $replace, $champ[$i]); //champ nom composé type "last adress" devient last$$$adress - compatibilité avec variable javascript
                $texteArray = "$texteArray var $champJS[$i] = new Array(); $retourChariot"; //liste tous les champs
                $texteArray = "$texteArray cnxResult[$i] = $champJS[$i]; $retourChariot";
                $texteArray = "$texteArray $champJS[$i][0] = \"$champ[$i]\"; $retourChariot"; //insère le nom des champs en ligne 0
            }
            
            $j = 1;
            while( ($row = mysql_fetch_array($result, MYSQL_BOTH)) ) { //lit les enregistrements
                for ($i=0; $i < $fields; $i++){ //$fields contient le nombre de champs
                    //$champ[$i] = mysql_field_name($result, $i); //compte le nombre de champs
                    $row[$i] = trim($row[$i]); //élimine certains caractères indésirables qui provoquent une erreur avec certains type de processeurs (ex pentium 4)
                    $texteArray = "$texteArray $champJS[$i][$j] = \"$row[$i]\"; $retourChariot"; //$rows est le nombre d'enregistrements retourné par la requete; $row pointe sur un seul de ces enregistrements
                }
                $j++; //compte le nombre d'enregistrement retourner par la requete; compte les lignes
            }
            mysql_close($link);
            return $texteArray;
        }
        else{
            mysql_close($link);
            return 0;
        }
    } // end of mysqlAsArray()
    
} //end of class dataBase
$cnxMysql = new cnxMysql();

class cnxAjax { //imbrication pour essai
    const const_imbrication = 1; //permet de tester le chargement de la classe notamment dans le cas où la classe serait dans un autre fichier que cnx()
    var $var1; //définition des variables
    var $var2;
    function cnxAjax(){ //affectation des variables propres à la classe imbrication
        $var1 = 1;
        $var2 = "voir";
    } //function classImbrication
    
    function appelFunction(){ //exécute une fonction php ou la fonction d'une classe php, puis appelle retourServeur
        /* -----------------------
        function_exists()
        iscallable()
        prb pour tester l'existence d'une méthode (classes) car en 2 temps
        
        Pour les fonctions il suffit de faire : eval("calcul(1,2)"); le paramètre de eval() est de type String
        Pour les méthodes (classes) il faut écrire: eval("\$cnx->imbrication->calcul(1, 2);"); - d'où le traitement particulier pour les classes
        
        $cnxAjax->appelFunction($cnxArg, $cnxFunc); // lance l'appel d'une fonction PHP ou dune fonction de classe php
        ------------------- */
        $nombreArgs = func_num_args(); //nombre d'arguments que reçoit la fonction
        $cnxArg = func_get_arg(0);
        $cnxFunc = func_get_arg(1);
        $classeName = false; //nom de la classe php qui appelle la fonction, si pas fonction de classe => false

        if (isset($cnxFunc)) { //teste si une fonction est transmise en paramètre - fonction as string - $$cnxArg[0] contient le nom de la fonction
            $stringFunction = "$cnxFunc(";
            $longueur = count($cnxArg)-1;
            for ($numero = 1; $numero < $longueur; $numero++){ // boucle pour afficher les arguments de la fonction PHP
                if (is_string($cnxArg[$numero]))    $cnxArg[$numero] = '"'.$cnxArg[$numero].'"';
                $stringFunction = $stringFunction . $cnxArg[$numero] . ", ";
            }

            if (is_string($cnxArg[$longueur]))    $cnxArg[$longueur] = '"'.$cnxArg[$longueur].'"';
            $stringFunction = $stringFunction . $cnxArg[$longueur].");"; //dernier argument de la fonction -boucler si pas d'argument! - maintenant la fonction est écrire as sring
            
            $pos = strpos($stringFunction,  "->"); //si le nom de la fonction contient "->" cette fonction appartient à une classe - c'est une méthode!
            if ($pos !== false)    { //une position a été trouvée donc le sigle "->" existe: c'est une classe php
                $firstCaractere = $stringFunction{0}; //récupère le caractère à la position {$pos} - autrement: substr(string,start,length) 
                if ($firstCaractere == "$")    $stringFunction = substr($stringFunction,1); //supprime "$" si ce sigle est le premier caractère de la chaine
                $classeName =  substr($stringFunction, 0, $pos); //extrait le nom de la classe si elle existe
                $stringFunction = "\$" . $stringFunction; //il faut transmettre : eval("\$cnx->imbrication->calcul(1, 2);");
            }
            
            //echo "$stringFunction - $classeName";
            if ($classeName)    global $$classeName; //accès à la classe si elle existe
            
            //echo "Fonction being call : ".$stringFunction."<br/>";

            $stringFunction = "return $stringFunction;"; //il faut un return dans l'expression eval() pour obtenir le résultat de la function même si cette dernière retourne déjà une variable avec une instruction return
            $retourServeur = eval($stringFunction); //si classe il faut \ devant $classe->....... => "\$classe->....."
            //echo $retourServeur; //il faut écrire pour que Ajax retourne une valeur à javascript
            global $cnxAjax;
            $cnxAjax->retourServeur($retourServeur); //sert à écrire la réponse sur la page php pour retour vers Ajax

        }
    }
    
    function retourServeur(){ // retour du serveur vers javascript, en fait méthode echo!
        $nombreArgs = func_num_args(); //nombre d'arguments que reçoit la fonction
        $retourServeur = func_get_arg(0);
        
        if (is_array($retourServeur)){ //$retourServeur est un Array() - un tableau
                global $cnxAjax;
                $retourServeur = $cnxAjax->listArray2js($retourServeur);
        }
        echo $retourServeur; //il faut écrire pour que Ajax retourne une valeur à javascript
    }
    
    function listArray2js(){ //parcours un Array() pour en lister les éléments et le retourne comme un Array() javascript - eval(texte);
        /* -----------------------
            Un Array() ou tableau est en fait une entité regroupant des variables écrites sous la forme:
            $tab[$key] = $value;
            $key pouvant être alphanumérique
            array_keys() retourne un tableau contenant toutes les clefs de l'Array passé en paramètre;
            Le tableau retourné par array_keys() est lui du type [$cleNumérique] = $contenu; $contenu étant les clefs "$key" du tableau passé en paramètre.
            La clef de array_keys() étant numérique il est alors facile de lister toutes les clefs "$key" de l'Array transmis en paramètre.
            Lors de cette boucle sur les clefs nous testons si le contenu associé à ces clefs est lui-même un Array
            Si tel est le cas nous faisons un appel récursif à cette fonction: listArray2js() qui entre dans une nouvelle boucle de listage de clef
            Lorsque l'on sort d'une boucle de listage de clef, il faut revenir à la précédante valeur de clef.
            Pour cela nous devons calculer la prochaine clef en retranchant la dernière valeur de $key ajoutée dans le bouclage.
            Pour que cette valeur soit effectivement prise en considération nous devons déclaré $cle comme global.
            En effet chaque appel lors d'une boucle à la fonction listArray2js() est considéré comme un appel à une autre fonction.
            Donc toutes les variables calculées dans cet appel récursif sont ignorés y compris notre réactualisation de la variable $cle lorsque nous quittons la boucle
            global $cle permet justement de prendre en compte cette actualisation de $cle
            
            Pour retourner un tableu (x,y) faire:
            $tab = array();
            $tab["x"] = array();
            $tab["y"] = array();
            $tab["x"][0]= 7;
            $tab["y"][0]= 6;
            ---------------------- */
        global $cle; //global pour récupérer la valeur de $cle lorsque on sort d'un appel récursif
        global $cnxAjax;
        $nombreArgs = func_num_args(); //nombre d'arguments que reçoit la fonction
        $tab = func_get_arg(0);
        $cle = ($nombreArgs > 1) ? func_get_arg(1) : ""; //si un deuxième argument existe $cle prend sa valeur
        
        $retourLigne = ""; //ne sert que pour écrire sur une page web =>    $retourLigne = "</br>";     pour un retour vers javascript  =>    $retourLigne = "";
        $texteArray = ($cle == "") ? "var cnxResult = new Array(); $retourLigne" : "cnxResult$cle = new Array(); $retourLigne"; //initialise $texteArray
        
        foreach ($tab as $key => $value){
            if (is_array($value)){ // si array() appel récursif à la fonction
                $cle .= "[\"$key\"]";
                $texteArray .= $cnxAjax->listArray2js($value, $cle);
            }
            else { //on écrit le résultat
                if ($cle)    $texteArray .= "cnxResult$cle"."[".$key."]"." = \"$value\"; $retourLigne";
                else    $texteArray .= "cnxResult[$key] = \"$value\"; $retourLigne";
            }
        } //la boucle foreach est finie
        $pos = strrpos($cle,  "["); //cherche la position de la dernière occurence
        $cle =  substr($cle, 0, $pos); //retranche le nom de la précédante $key
        return $texteArray;
    }
}
$cnxAjax = new cnxAjax();

{ //read parameters et liaison avec Ajax
    if (isset($_GET)) { //recherche les données de type GET transmises( lien html)!
        foreach ($_GET as $c => $v) {
            //echo $c, " : ", $v, " in GET méthode. <br>\n";
            $$c=$v; //si une fonction est appelée, génère une variable $cnxFunc
            $cnxArg[] = $v; //sert aux appels de fonction php - transmet le nom de la fonction php appelée et la liste des arguments à utiliser
        }
    } //if (isset($_GET))
    
    if (isset($_POST)) { //recherche les données de type POST transmises (formulaire)!
        foreach ($_POST as $c => $v) {
            //echo $c, " : ", $v, " in POST méthode. <br>\n";
            $$c=$v; //si une fonction est appelée, génère une variable $cnxFunc
            $cnxArg[] = $v; //sert aux appels de fonction php - transmet le nom de la fonction php appelée et la liste des arguments à utiliser
        }
    } //if (isset($_POST))
    
    if (isset($_FILES)) {//recherche les données de type FILES transmises (formulaire)!
        foreach ($_FILES as $cnx_FILES_Upload => $v) { //génère la variable $c
            //echo $cnx_FILES_Upload, " : ", $v, " in FILES méthode. <br>\n";
            
            $$cnx_FILES_Upload = $v; // le contenu de "input type file" est un array => $v est un array et $$cnx_FILES_Upload génère une variuable $kontrol_file ou kontrol_file est le name du contrôle de formulaire de type input file
            if (isset($uploadAuto))    {  //upload automatique des fichiers
                if ($uploadAuto == true)    $cnx->files->moveUploadSingle(); //transfère le fichier uploadé dans le dossier du script courant
            }
            /*
            le contenu de $cnx_FILES_Upload est le name du controle input file
            $$cnx_FILES_Upload génère donc une variable nommée $name où name est la propriété name du input file
            $v est un array - le contenu de "input type file" est un array 
            
            ainsi si le name du input file est "fichiercsv" nous aurons:
            $cnx_FILES_Upload = "fichiercsv";
            $$cnx_FILES_Upload = $fichiercsv = $kontrol_file = $_FILES['fichiercsv'] //qui contiendra un array
    
            $kontrol_file = $_FILES['fichiercsv']; //controle file dans le formulaire
            $tmp_file = $kontrol_file['tmp_name']; //nom du fichier temporaire qui sera téléchargé
            $type_file = $kontrol_file['type']; // extension du fichier à télécharge
            $name_file = $kontrol_file['name']; //nom du fichier à télécharger du système client
            $size_file = $kontrol_file['size']; //taille du fichier à télécharger
            $error_file = $kontrol_file['error']; //une erreur est elle survenue - pas d'erreur si 0
            */
        }  
    } //if (isset($_FILES))
    
    if (isset($_COOKIE)) { //recherche les données de type Cookies!
        foreach ($_COOKIE as $c => $v) {
            //echo $c, " : ", $v, " in COOKIE méthode. <br>\n";
            $$c=$v;
        }
    } //if (isset($_COOKIE))
    
    if (isset($_SESSION)) { //recherche les données de type session!
        foreach ($_SESSION as $c => $v) {
            //echo $c, " : ", $v, " in SESSION méthode. <br>\n";
            $$c=$v;
        }
    } //if (isset($_SESSION))
    
    if (isset($cnxArg) ) { // 
        if(isset($cnxFunc) ){ // la variable $cnxFunc est employée - appel d'une fonction PHP depuis js/ajax
            //echo "texte de la fonction : ".$cnxArg." : ".$cnxFunc."<br/>";
            $cnxAjax->appelFunction($cnxArg, $cnxFunc); // lance l'appel d'une fonction PHP ou d'une fonction de classe php
        }
    } //if (isset($cnxArg))
}

?>