/****************************************************************************************
 VFORM est un script de contrôle de formulaire

 Version 1.15

 Copyright (C) 2006-2016  Sylvain FATOME

 This program is free software; you can redistribute it and/or modify it under the terms
 of the GNU General Public License as published by the Free Software Foundation;
 either version 2 of the License, or (at your option) any later version.

 This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 See the GNU General Public License for more details.

 You should have received a copy of the GNU General Public License along with this program;
 if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 Boston, MA  02110-1301, USA.

 Contact : galawa@free.fr

 Web : http://smi.no-ip.org
 ****************************************************************************************/

// Suppression des espaces en début en fin de chaîne
function RLtrim(texte) {
    return texte.replace(/(^\s*)|(\s*$)/g, "");
}

// Convertion caractère accentués en octal
function ConvertAccents(texte) {
    var i;
    var texte_ok = '';

    for (i = 0; i < texte.length; i++) {
        switch (texte.charAt(i)) {
            case '¢':
                texte_ok += '\242';
                break;
            case '£':
                texte_ok += '\243';
                break;
            case '¥':
                texte_ok += '\245';
                break;
            case '¼':
                texte_ok += '\274';
                break;
            case '½':
                texte_ok += '\275';
                break;
            case '¾':
                texte_ok += '\276';
                break;
            case '¡':
                texte_ok += '\241';
                break;
            case '«':
                texte_ok += '\253';
                break;
            case '»':
                texte_ok += '\273';
                break;
            case '¿':
                texte_ok += '\277';
                break;
            case 'À':
                texte_ok += '\300';
                break;
            case 'Á':
                texte_ok += '\301';
                break;
            case 'Â':
                texte_ok += '\302';
                break;
            case 'Ã':
                texte_ok += '\303';
                break;
            case 'Ä':
                texte_ok += '\304';
                break;
            case 'Å':
                texte_ok += '\305';
                break;
            case 'Æ':
                texte_ok += '\306';
                break;
            case 'Ç':
                texte_ok += '\307';
                break;
            case 'È':
                texte_ok += '\310';
                break;
            case 'É':
                texte_ok += '\311';
                break;
            case 'Ê':
                texte_ok += '\312';
                break;
            case 'Ë':
                texte_ok += '\313';
                break;
            case 'Ì':
                texte_ok += '\314';
                break;
            case 'Í':
                texte_ok += '\315';
                break;
            case 'Î':
                texte_ok += '\316';
                break;
            case 'Ï':
                texte_ok += '\317';
                break;
                break;
            case 'Ð':
                texte_ok += '\320';
                break;
            case 'Ñ':
                texte_ok += '\321';
                break;
            case 'Ò':
                texte_ok += '\322';
                break;
            case 'Ó':
                texte_ok += '\323';
                break;
            case 'Ô':
                texte_ok += '\324';
                break;
            case 'Õ':
                texte_ok += '\325';
                break;
            case 'Ö':
                texte_ok += '\326';
                break;
            case 'Ø':
                texte_ok += '\330';
                break;
            case 'Ù':
                texte_ok += '\331';
                break;
            case 'Ú':
                texte_ok += '\332';
                break;
            case 'Û':
                texte_ok += '\333';
                break;
            case 'Ü':
                texte_ok += '\334';
                break;
            case 'Ý':
                texte_ok += '\335';
                break;
            case 'Þ':
                texte_ok += '\336';
                break;
            case 'ß':
                texte_ok += '\337';
                break;
            case 'à':
                texte_ok += '\340';
                break;
            case 'á':
                texte_ok += '\341';
                break;
            case 'â':
                texte_ok += '\342';
                break;
            case 'ã':
                texte_ok += '\343';
                break;
            case 'ä':
                texte_ok += '\344';
                break;
            case 'å':
                texte_ok += '\345';
                break;
            case 'æ':
                texte_ok += '\346';
                break;
            case 'ç':
                texte_ok += '\347';
                break;
            case 'è':
                texte_ok += '\350';
                break;
            case 'é':
                texte_ok += '\351';
                break;
            case 'ê':
                texte_ok += '\352';
                break;
            case 'ë':
                texte_ok += '\353';
                break;
            case 'ì':
                texte_ok += '\354';
                break;
            case 'í':
                texte_ok += '\355';
                break;
            case 'î':
                texte_ok += '\356';
                break;
            case 'ï':
                texte_ok += '\357';
                break;
            case 'ð':
                texte_ok += '\360';
                break;
            case 'ñ':
                texte_ok += '\361';
                break;
            case 'ò':
                texte_ok += '\362';
                break;
            case 'ó':
                texte_ok += '\363';
                break;
            case 'ô':
                texte_ok += '\364';
                break;
            case 'õ':
                texte_ok += '\365';
                break;
            case 'ö':
                texte_ok += '\366';
                break;
            case 'ø':
                texte_ok += '\370';
                break;
            case 'ù':
                texte_ok += '\371';
                break;
            case 'ú':
                texte_ok += '\372';
                break;
            case 'û':
                texte_ok += '\373';
                break;
            case 'ü':
                texte_ok += '\374';
                break;
            case 'ý':
                texte_ok += '\375';
                break;
            case 'þ':
                texte_ok += '\376';
                break;
            case 'ÿ':
                texte_ok += '\377';
                break;
            default:
                texte_ok += texte.charAt(i);
                break;
        }
    }

    return texte_ok;
}

// Vérifie si une valeur est bien dans une fourchette
function ValInMinMax(valeur, mini, maxi) {
    if ((typeof(mini) != 'undefined') || (typeof(maxi) != 'undefined')) {
        // On vérifie que min et maxi sont définis. Si oui, on vérifie que mini <= Maxi
        if ((typeof(mini) != 'undefined') && (typeof(maxi) != 'undefined')) {
            if ((!isNaN(mini)) && (!isNaN(maxi))) {
                if (mini > maxi)
                    {
                        return false;
                    }
                if (valeur < mini)
                    {
                        return false;
                    }
                if (valeur > maxi)
                    {
                        return false;
                    }
            }
        }
        else {
            // Il n'y a que le mini
            if (typeof(mini) != 'undefined') {
                if (!isNaN(mini))
                    {
                        if (valeur < mini) {
                            return false;
                        }
                    }
            }
            // Il n'y a que le maxi
            if (typeof(maxi) != 'undefined') {
                if (!isNaN(maxi))
                    {
                        if (valeur > maxi) {
                            return false;
                        }
                    }
            }
        }
    }
    return true;
}

// Vérifie si la chaîne est au format hexadécimal
function IsHexa(str) {
    var expr = new RegExp("^[a-f0-9]+$", "gi");
    return expr.test(str);


}

// Vérifie si la chaîne est au format hexadécimal couleur
function IsHexaCol(str) {
    var expr = new RegExp("^[\#][a-f0-9]{6}$", "gi");
    return expr.test(str);


}

// Vérifie si la chaîne est au format entier non signé
function IsUnsigned(str) {
    var expr = new RegExp("^[0-9]*$", "gi");
    return expr.test(str);


}

// Vérifie si la chaîne est au format entier signé
function IsInteger(str) {
    var expr = new RegExp("^[\+\-]?[0-9]*$", "gi");
    return expr.test(str);


}

// Vérifie si la chaîne est au format réel signé
function IsReal(str) {
    var expr = new RegExp("^[\+\-]?[0-9]+(\.[0-9]{0,})?$", "gi");
    return expr.test(str);


}

// Vérifie si la chaîne est au format réel non signé
function IsRealUnsigned(str) {
    var expr = new RegExp("^[0-9]+(\.[0-9]{0,})?$", "gi");
    return expr.test(str);


}

// Vérifie une date
function IsDate(date, masque) {
    var jour, mois, annee;
    var expr;
    var tab_date;
    var dt_test;
    if (!date)
        {
            return false;
        }

    expr = '';
    tab_date = [];
    switch (masque) {
        case "mmddyy":
            expr = new RegExp("^[0-9]{6}$");
            // On vérifie le format
            if (!expr.test(date)) {
                return false;
            }
            else {
                mois = Number(date.substr(0, 2));
                jour = Number(date.substr(2, 2));
                annee = Number(date.substr(4, 2)) + 2000;
            }
            break;
        case "mmddyyyy":
            expr = new RegExp("^[0-9]{8}$");
            // On vérifie le format
            if (!expr.test(date)) {
                return false;
            }
            else {
                mois = Number(date.substr(0, 2));
                jour = Number(date.substr(2, 2));
                annee = Number(date.substr(4, 4));
            }
            break;
        case "jjmmaa":
            expr = new RegExp("^[0-9]{6}$");
            if (!expr.test(date)) {
                return false;
            }
            else {
                jour = Number(date.substr(0, 2));
                mois = Number(date.substr(2, 2));
                annee = Number(date.substr(4, 2)) + 2000;
            }
            break;
        case "jjmmaaaa":
            expr = new RegExp("^[0-9]{8}$");
            if (!expr.test(date)) {
                return false;
            }
            else {
                jour = Number(date.substr(0, 2));
                mois = Number(date.substr(2, 2));
                annee = Number(date.substr(4, 4));
            }
            break;
        case "mm-dd-yy":
            expr = new RegExp("^[0-9]{2}\-[0-9]{2}\-[0-9]{2}$");
            // On vérifie le format
            if (!expr.test(date)) {
                return false;
            }
            else {
                tab_date = date.split('-');
                mois = Number(tab_date[0]);
                jour = Number(tab_date[1]);
                annee = Number(tab_date[2]) + 2000;
            }
            break;
        case "mm/dd/yy":
            expr = new RegExp("^[0-9]{2}\/[0-9]{2}\/[0-9]{2}$");
            // On vérifie le format
            if (!expr.test(date)) {
                return false;
            }
            else {
                tab_date = date.split('/');
                mois = Number(tab_date[0]);
                jour = Number(tab_date[1]);
                annee = Number(tab_date[2]) + 2000;
            }
            break;
        case "dd-mm-yy":
            expr = new RegExp("^[0-9]{2}\-[0-9]{2}\-[0-9]{2}$");
            // On vérifie le format
            if (!expr.test(date)) {
                return false;
            }
            else {
                tab_date = date.split('-');
                mois = Number(tab_date[1]);
                jour = Number(tab_date[0]);
                annee = Number(tab_date[2]) + 2000;
            }
            break;
        case "dd/mm/yy":
            expr = new RegExp("^[0-9]{2}\/[0-9]{2}\/[0-9]{2}$");
            // On vérifie le format
            if (!expr.test(date)) {
                return false;
            }
            else {
                tab_date = date.split('/');
                mois = Number(tab_date[1]);
                jour = Number(tab_date[0]);
                annee = Number(tab_date[2]) + 2000;
            }
            break;
        case "mm-dd-yyyy":
            expr = new RegExp("^[0-9]{2}\-[0-9]{2}\-[0-9]{4}$");
            // On vérifie le format
            if (!expr.test(date)) {
                return false;
            }
            else {
                tab_date = date.split('-');
                mois = Number(tab_date[0]);
                jour = Number(tab_date[1]);
                annee = Number(tab_date[2]);
            }
            break;
        case "mm/dd/yyyy":
            expr = new RegExp("^[0-9]{2}\/[0-9]{2}\/[0-9]{4}$");
            // On vérifie le format
            if (!expr.test(date)) {
                return false;
            }
            else {
                tab_date = date.split('/');
                mois = Number(tab_date[0]);
                jour = Number(tab_date[1]);
                annee = Number(tab_date[2]);
            }
            break;
        case "dd-mm-yyyy":
            expr = new RegExp("^[0-9]{2}\-[0-9]{2}\-[0-9]{4}$");
            // On vérifie le format
            if (!expr.test(date)) {
                return false;
            }
            else {
                tab_date = date.split('-');
                mois = Number(tab_date[1]);
                jour = Number(tab_date[0]);
                annee = Number(tab_date[2]);
            }
            break;
        case "dd/mm/yyyy":
            expr = new RegExp("^[0-9]{2}\/[0-9]{2}\/[0-9]{4}$");
            // On vérifie le format
            if (!expr.test(date)) {
                return false;
            }
            else {
                tab_date = date.split('/');
                mois = Number(tab_date[1]);
                jour = Number(tab_date[0]);
                annee = Number(tab_date[2]);
            }
            break;
        case "jj-mm-aa":
            expr = new RegExp("^[0-9]{2}\-[0-9]{2}\-[0-9]{2}$");
            if (!expr.test(date)) {
                return false;
            }
            else {
                tab_date = date.split('-');
                jour = Number(tab_date[0]);
                mois = Number(tab_date[1]);
                annee = Number(tab_date[2]) + 2000;
            }
            break;
        case "jj/mm/aa":
            expr = new RegExp("^[0-9]{2}\/[0-9]{2}\/[0-9]{2}$");
            if (!expr.test(date)) {
                return false;
            }
            else {
                tab_date = date.split('/');
                jour = Number(tab_date[0]);
                mois = Number(tab_date[1]);
                annee = Number(tab_date[2]) + 2000;
            }
            break;
        case "jj-mm-aaaa":
            expr = new RegExp("^[0-9]{2}\-[0-9]{2}\-[0-9]{4}$");
            if (!expr.test(date)) {
                return false;
            }
            else {
                tab_date = date.split('-');
                jour = Number(tab_date[0]);
                mois = Number(tab_date[1]);
                annee = Number(tab_date[2]);
            }
            break;
        case "jj/mm/aaaa":
            expr = new RegExp("^[0-9]{2}\/[0-9]{2}\/[0-9]{4}$");
            if (!expr.test(date)) {
                return false;
            }
            else {
                tab_date = date.split('/');
                jour = Number(tab_date[0]);
                mois = Number(tab_date[1]);
                annee = Number(tab_date[2]);
            }
            break;
        default :
            return false;
            break;
    }
    // On contrôle la validité du jour
    if ((jour == 0) || (jour > 31)) {
        return false;
    }
    else {
        // vérification du nombre de jour dans le mois
        dt_test = new Date(annee, Number(mois - 1), jour);
        if (dt_test.getMonth() != Number(mois - 1))
            {
                return false;
            }
    }

    // On contrôle la validité du mois
    return !((mois == 0) || (mois > 12));
}

// Vérifie si une date est bien dans une fourchette
function DateInMinMax(date, dmini, dmaxi, masque) {
    var jour, mois, annee, jourmn, moismn, anneemn, jourmx, moismx, anneemx;
    var tab_date;
    var tab_dmini;
    var tab_dmaxi;
    var datetst;
    var datemn;
    var datemx;
    if ((typeof(dmini) != 'undefined') || (typeof(dmaxi) != 'undefined')) {
        if ((IsDate(date, masque)) && ((IsDate(dmini, masque)) || (typeof(dmini) == 'undefined')) && ((IsDate(dmaxi, masque)) || (typeof(dmaxi) == 'undefined'))) {
            tab_date = [];
            tab_dmini = [];
            tab_dmaxi = [];
            switch (masque) {
                case "mmddyy":
                    mois = Number(date.substr(0, 2));
                    jour = Number(date.substr(2, 2));
                    annee = Number(date.substr(4, 2)) + 2000;
                    if (typeof(dmini) != 'undefined') {
                        moismn = Number(dmini.substr(0, 2));
                        jourmn = Number(dmini.substr(2, 2));
                        anneemn = Number(dmini.substr(4, 2)) + 2000;
                    }
                    if (typeof(dmaxi) != 'undefined') {
                        moismx = Number(dmaxi.substr(0, 2));
                        jourmx = Number(dmaxi.substr(2, 2));
                        anneemx = Number(dmaxi.substr(4, 2)) + 2000;
                    }
                    break;
                case "mmddyyyy":
                    mois = Number(date.substr(0, 2));
                    jour = Number(date.substr(2, 2));
                    annee = Number(date.substr(4, 4));
                    if (typeof(dmini) != 'undefined') {
                        moismn = Number(dmini.substr(0, 2));
                        jourmn = Number(dmini.substr(2, 2));
                        anneemn = Number(dmini.substr(4, 4));
                    }
                    if (typeof(dmaxi) != 'undefined') {
                        moismx = Number(dmaxi.substr(0, 2));
                        jourmx = Number(dmaxi.substr(2, 2));
                        anneemx = Number(dmaxi.substr(4, 4));
                    }
                    break;
                case "jjmmaa":
                    jour = Number(date.substr(0, 2));
                    mois = Number(date.substr(2, 2));
                    annee = Number(date.substr(4, 2)) + 2000;
                    if (typeof(dmini) != 'undefined') {
                        moismn = Number(dmini.substr(0, 2));
                        jourmn = Number(dmini.substr(2, 2));
                        anneemn = Number(dmini.substr(4, 2)) + 2000;
                    }
                    if (typeof(dmaxi) != 'undefined') {
                        moismx = Number(dmaxi.substr(0, 2));
                        jourmx = Number(dmaxi.substr(2, 2));
                        anneemx = Number(dmaxi.substr(4, 2)) + 2000;
                    }
                    break;
                case "jjmmaaaa":
                    jour = Number(date.substr(0, 2));
                    mois = Number(date.substr(2, 2));
                    annee = Number(date.substr(4, 4));
                    if (typeof(dmini) != 'undefined') {
                        moismn = Number(dmini.substr(0, 2));
                        jourmn = Number(dmini.substr(2, 2));
                        anneemn = Number(dmini.substr(4, 4));
                    }
                    if (typeof(dmaxi) != 'undefined') {
                        moismx = Number(dmaxi.substr(0, 2));
                        jourmx = Number(dmaxi.substr(2, 2));
                        anneemx = Number(dmaxi.substr(4, 4));
                    }
                    break;
                case "mm-dd-yy":
                case "mm-dd-yyyy":
                    tab_date = date.split('-');
                    mois = Number(tab_date[0]);
                    jour = Number(tab_date[1]);
                    annee = Number(tab_date[2]);
                    if (annee < 2000)
                        {
                            annee += 2000;
                        }
                    tab_dmini = dmini.split('-');
                    if (typeof(dmini) != 'undefined') {
                        moismn = Number(tab_dmini[0]);
                        jourmn = Number(tab_dmini[1]);
                        anneemn = Number(tab_dmini[2]);
                        if (anneemn < 2000)
                            {
                                anneemn += 2000;
                            }
                    }
                    if (typeof(dmaxi) != 'undefined') {
                        tab_dmaxi = dmaxi.split('-');
                        moismx = Number(tab_dmaxi[0]);
                        jourmx = Number(tab_dmaxi[1]);
                        anneemx = Number(tab_dmaxi[2]);
                        if (anneemx < 2000)
                            {
                                anneemx += 2000;
                            }
                    }
                    break;
                case "mm/dd/yy":
                case "mm/dd/yyyy":
                    tab_date = date.split('/');
                    mois = Number(tab_date[0]);
                    jour = Number(tab_date[1]);
                    annee = Number(tab_date[2]);
                    if (annee < 2000)
                        {
                            annee += 2000;
                        }
                    if (typeof(dmini) != 'undefined') {
                        tab_dmini = dmini.split('/');
                        moismn = Number(tab_dmini[0]);
                        jourmn = Number(tab_dmini[1]);
                        anneemn = Number(tab_dmini[2]);
                        if (anneemn < 2000)
                            {
                                anneemn += 2000;
                            }
                    }
                    if (typeof(dmaxi) != 'undefined') {
                        tab_dmaxi = dmaxi.split('/');
                        moismx = Number(tab_dmaxi[0]);
                        jourmx = Number(tab_dmaxi[1]);
                        anneemx = Number(tab_dmaxi[2]);
                        if (anneemx < 2000)
                            {
                                anneemx += 2000;
                            }
                    }
                    break;
                case "jj-mm-aa":
                case "jj-mm-aaaa":
                case "dd-mm-yy":
                case "dd-mm-yyyy":
                    tab_date = date.split('-');
                    jour = Number(tab_date[0]);
                    mois = Number(tab_date[1]);
                    annee = Number(tab_date[2]);
                    if (annee < 2000)
                        {
                            annee += 2000;
                        }
                    if (typeof(dmini) != 'undefined') {
                        tab_dmini = dmini.split('-');
                        jourmn = Number(tab_dmini[0]);
                        moismn = Number(tab_dmini[1]);
                        anneemn = Number(tab_dmini[2]);
                        if (anneemn < 2000)
                            {
                                anneemn += 2000;
                            }
                    }
                    if (typeof(dmaxi) != 'undefined') {
                        tab_dmaxi = dmaxi.split('-');
                        jourmx = Number(tab_dmaxi[0]);
                        moismx = Number(tab_dmaxi[1]);
                        anneemx = Number(tab_dmaxi[2]);
                        if (anneemx < 2000)
                            {
                                anneemx += 2000;
                            }
                    }
                    break;
                case "jj/mm/aa":
                case "jj/mm/aaaa":
                case "dd/mm/yy":
                case "dd/mm/yyyy":
                    tab_date = date.split('/');
                    jour = Number(tab_date[0]);
                    mois = Number(tab_date[1]);
                    annee = Number(tab_date[2]);
                    if (annee < 2000)
                        {
                            annee += 2000;
                        }
                    if (typeof(dmini) != 'undefined') {
                        tab_dmini = dmini.split('/');
                        jourmn = Number(tab_dmini[0]);
                        moismn = Number(tab_dmini[1]);
                        anneemn = Number(tab_dmini[2]);
                        if (anneemn < 2000)
                            {
                                anneemn += 2000;
                            }
                    }
                    if (typeof(dmaxi) != 'undefined') {
                        tab_dmaxi = dmaxi.split('/');
                        jourmx = Number(tab_dmaxi[0]);
                        moismx = Number(tab_dmaxi[1]);
                        anneemx = Number(tab_dmaxi[2]);
                        if (anneemx < 2000)
                            {
                                anneemx += 2000;
                            }
                    }
                    break;
                default :
                    return false;
                    break;
            }

            datetst = new Date(annee, Number(mois - 1), jour);
            datemn = new Date(anneemn, Number(moismn - 1), jourmn);
            datemx = new Date(anneemx, Number(moismx - 1), jourmx);

            if ((typeof(dmini) != 'undefined') && (typeof(dmaxi) != 'undefined')) {
                if (datemx.getTime() >= datemn.getTime()) {
                    if ((datetst.getTime() < datemn.getTime()) || (datetst.getTime() > datemx.getTime()))
                        {
                            return false;
                        }
                }
                else {
                    return false;
                }
            }
            else {
                // Uniquement date maximum
                if ((typeof(dmini) == 'undefined') && (typeof(dmaxi) != 'undefined')) {
                    if (datemx.getTime() < datetst.getTime())
                        {
                            return false;
                        }
                }
                // Uniquement date minimum
                if ((typeof(dmini) != 'undefined') && (typeof(dmaxi) == 'undefined')) {
                    if (datemn.getTime() > datetst.getTime())
                        {
                            return false;
                        }
                }
            }
        }
    }
    return true;
}

// Vérifie si la chaîne est au format heure hh:mm:ss
function IsHeure(str) {
    var tab_duree;
    var expr = new RegExp("^[0-9]{1,2}\:[0-9]{1,2}\:[0-9]{1,2}$");
    if (!expr.test(str))
        {
            return false;
        }

    // On vérifie les valeurs individuelles
    tab_duree = str.split(":");
    return !((Number(tab_duree[0]) > 23) || (Number(tab_duree[1]) > 59) || (Number(tab_duree[2]) > 59));


}

// Convertit une heure en secondes
function ConvertHeureSec(str) {
    var tab_duree;
    var totalsec = 0;
    if (IsHeure(str)) // Si c'est vraiment une heure
    {
        // On calcule la durée totale en secondes
        tab_duree = str.split(":");
        totalsec = (Number(tab_duree[0]) * 3600) + (Number(tab_duree[1]) * 60) + Number(tab_duree[2]);
    }

    return totalsec;
}

// Vérifie si la chaîne est au format heure hh:mm
function IsHeurehhmm(str) {
    var tab_duree;
    var expr = new RegExp("^[0-9]{1,2}\:[0-9]{1,2}$");
    if (!expr.test(str))
        {
            return false;
        }

    // On vérifie les valeurs individuelles
    tab_duree = str.split(":");
    return !((Number(tab_duree[0]) > 23) || (Number(tab_duree[1]) > 59));


}

// Convertit une heure hhmm en secondes
function ConvertHeurehhmmSec(str) {
    var tab_duree;
    var totalsec = 0;
    if (IsHeurehhmm(str)) // Si c'est vraiment une heure hhmm
    {
        // On calcule la durée totale en secondes
        tab_duree = str.split(":");
        totalsec = (Number(tab_duree[0]) * 3600) + (Number(tab_duree[1]) * 60);
    }

    return totalsec;
}

// Vérifie si la chaîne est une durée
function IsDuree(str) {
    var tab_duree;
    var expr = new RegExp("^[0-9]{1,}\:[0-9]{1,2}\:[0-9]{1,2}$");
    if (!expr.test(str))
        {
            return false;
        }

    // On vérifie les valeurs individuelles
    tab_duree = str.split(":");
    return !((Number(tab_duree[1]) > 59) || (Number(tab_duree[2]) > 59));


}

// Vérifie si la chaîne est une durée
function IsDureehhmm(str) {
    var tab_duree;
    var expr = new RegExp("^[0-9]{1,}\:[0-9]{1,2}$");
    if (!expr.test(str))
        {
            return false;
        }

    // On vérifie les valeurs individuelles
    tab_duree = str.split(":");
    return Number(tab_duree[1]) <= 59;


}

// Convertit une durée en secondes
function ConvertDureeSec(str) {
    var tab_duree;
    var totalsec = 0;
    if (IsDuree(str)) // Si c'est vraiment une durée
    {
        // On calcule la durée totale en secondes
        tab_duree = str.split(":");
        totalsec = (Number(tab_duree[0]) * 3600) + (Number(tab_duree[1]) * 60) + Number(tab_duree[2]);
    }

    return totalsec;
}

// Convertit une durée hhmm en secondes
function ConvertDureehhmmSec(str) {
    var tab_duree;
    var totalsec = 0;
    if (IsDureehhmm(str)) // Si c'est vraiment une durée hhmm
    {
        // On calcule la durée totale en secondes
        tab_duree = str.split(":");
        totalsec = (Number(tab_duree[0]) * 3600) + (Number(tab_duree[1]) * 60);
    }

    return totalsec;
}

// Vérifie si un texte est vide
function ChampEstVide(texte) {
    if (!texte) {
        return true;
    }

    return RLtrim(texte) == '';


}

// Donne le nombre d'éléments sélectionnés dans une liste
function NbElementsSel(liste) {
    var nb;
    var nbSelected = 0;
    for (nb = 0; nb < liste[0].options.length; nb++) {
        if (liste[0].options[nb].selected) {
            nbSelected++;
        }
    }

    return nbSelected;
}

// Donne le nombre d'éléments cochés dans une liste
function NbElementsChk(liste) {
    var nb;
    var nbChecked = 0;
    for (nb = 0; nb < liste.length; nb++) {
        if (liste[nb].checked) {
            nbChecked++;
        }
    }

    return nbChecked;
}

// Fonction de contrôle du SIREN en fonction du code pays
function IsSiren(siren, pays) {
    var somme;
    var tmp;
    var idx;
    var sirenok = false;

    if (pays) {
        pays = pays.toLowerCase();

        switch (pays) {
            case 'fr' :
                if ((siren.length != 9) || (isNaN(siren)))
                    {
                        break;
                    }
                somme = 0;
                for (idx = 0; idx < siren.length; idx++) {
                    // Les positions paires : 2ème, 4ème, 6ème et 8ème chiffre
                    if ((idx % 2) == 1) {
                        tmp = siren.charAt(idx) * 2; // On le multiplie par 2
                        if (tmp > 9)
                            {
                                tmp -= 9;
                            }    // Si le résultat est supérieur à 9, on lui soustrait 9
                    }
                    else
                        {
                            tmp = siren.charAt(idx);
                        }

                    somme += parseInt(tmp);
                }

                // Si la somme est un multiple de 10 alors le SIREN est valide
                if ((somme % 10) == 0)
                    {
                        sirenok = true;
                    }
                break;
            default :
                break;
        }
    }
    return sirenok;
}

// Fonction de contrôle du SIRET
function IsSiret(siret, pays) {
    var somme;
    var tmp;
    var idx;
    var siretok = false;

    if (pays) {
        pays = pays.toLowerCase();

        switch (pays) {
            case 'fr' :
            case 'gf' :
            case 'gp' :
            case 'mq' :
            case 're' :
                if ((siret.length != 14) || (isNaN(siret)))
                    {
                        break;
                    }

                somme = 0;

                for (idx = 0; idx < siret.length; idx++) {
                    // Les positions impaires : 1er, 3ème, 5ème, etc...
                    if ((idx % 2) == 0) {
                        tmp = siret.charAt(idx) * 2; // On le multiplie par 2
                        if (tmp > 9)
                            {
                                tmp -= 9;
                            }    // Si le résultat est supérieur à 9, on lui soustrait 9
                    }
                    else
                        {
                            tmp = siret.charAt(idx);
                        }
                    somme += parseInt(tmp);
                }

                if ((somme % 10) == 0)
                    {
                        siretok = true;
                    } // Si la somme est un multiple de 10 alors le SIRET est valide
                break;
            default :
                break;
        }
    }

    return siretok;
}

// Fonction de contrôle du RIB
function IsRIB(rib, pays) {
    var tab_rib;
    var banque;
    var guichet;
    var compte;
    var clef;
    var tab;
    var tab1;
    var cpte;
    var idx;
    var clefc;
    var ribok = false;

    if (pays) {
        pays = pays.toLowerCase();

        switch (pays) {
            case 'fr' :
            case 'gf' :
            case 'gp' :
            case 'mq' :
            case 're' :
                tab_rib = rib.split(" ");

                banque = tab_rib[0];
                guichet = tab_rib[1];
                compte = tab_rib[2];
                clef = parseInt(tab_rib[3]);

                // Conversion du numéro de compte en chiffres
                tab = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
                tab1 = "123456789123456789234567890123456789";

                cpte = '';
                for (idx = 0; idx < compte.length; idx++) {
                    cpte += tab1.charAt(tab.indexOf(compte.charAt(idx)));
                }

                //Calcul clé RIB
                clefc = 97 - (((parseInt(banque) % 97 * 100000 + parseFloat(guichet)) % 97 * 100000000000 + parseInt(cpte)) % 97) * 100 % 97;

                if (clef == clefc)
                    {
                        ribok = true;
                    }
                break;
            default :
                break;
        }
    }

    return ribok;
}

// Fonction de contrôle du code IBAN
function IsIBAN(iban) {
    var str_reste;
    var clef_calc;
    var str_tmp;
    var nb_tmp;
    var code_final;
    var str_clef_calc;
    var ibanok = false;

    var lng = iban.length;

    // On récupère la clef de l'IBAN à tester
    var clefIBAN = iban.substr(2, 2);

    // On calcule la clef IBAN
    var IBANverif = iban.substr(4, (lng - 4)) + iban.substr(0, 2) + '00';

    // Conversion du numéro de compte en chiffres
    // Avec nettoyage des caractères indésirables
    var tab = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

    var IBANnum = '';
    var idx;
    for (idx = 0; idx < IBANverif.length; idx++) {
        if (IBANverif.charAt(idx).match(/[A-Z]/)) {
            IBANnum += tab.indexOf(IBANverif.charAt(idx)) + 10;
        }
        else {
            if (IBANverif.charAt(idx).match(/[0-9]/))
                {
                    IBANnum += IBANverif.charAt(idx);
                }
        }
    }

    // On calcule la clef IBAN
    // Découpage par bloc de 9 chiffres pour calculer le modulo (pb de précision)
    idx = 0;
    str_reste = '';
    while (idx < IBANnum.length) {
        str_tmp = str_reste + IBANnum.substring(idx, idx + 9);
        nb_tmp = parseFloat(str_tmp);
        clef_calc = nb_tmp % 97;
        str_reste = '' + clef_calc;

        idx += 9;
    }

    code_final = 98 - (clef_calc % 97);

    if (code_final < 10) {
        str_clef_calc = '0' + code_final;
    }
    else {
        str_clef_calc = '' + code_final;
    }

    if (clefIBAN == str_clef_calc)
        {
            ibanok = true;
        }

    return ibanok;
}

// Fonction de contrôle du numéro TVA
function IsTVA(tva, pays) {
    var siren;
    var tvaok = false;

    if (pays) {
        pays = pays.toLowerCase();

        switch (pays) {
            case 'fr' :
                siren = tva.substr(4, 9);
                if (IsSiren(siren, pays) == true) {
                    tvaok = true;
                }
                break;
            default :
                tvaok = true;
                break;
        }
    }

    return tvaok;
}

// Fonction de contrôle du numéro INSEE
function IsINSEE(insee, pays) {
    var tab_insee;
    var clef;
    var retirer;
    var tab_pnum;
    var pnum;
    var clefc;
    var inseeok = false;

    if (pays) {
        pays = pays.toLowerCase();

        switch (pays) {
            case 'fr' :
                tab_insee = insee.split(" ");
                clef = parseInt(tab_insee[6]);

                retirer = 0;
                if (tab_insee[3] == "2A") {
                    retirer = 1000000;
                    tab_insee[3] = "20"
                }
                if (tab_insee[3] == "2B") {
                    retirer = 2000000;
                    tab_insee[3] = "20"
                }
                tab_pnum = tab_insee.slice(0, 6);
                pnum = tab_pnum.join("");

                //Calcul clé INSEE
                clefc = 97 - (parseInt(pnum) % 97);

                return clef == clefc;
                break;
            default :
                inseeok = true;
                break;
        }
    }

    return inseeok;
}


// Vérifie si la chaîne est un code EAN-8
function IsEAN8(str) {
    var clefEAN;
    var clef_calc;
    var idx;
    var eanok = false;

    // Nettoyage de la chaine
    var expr = new RegExp("[ ]|\-", "g");
    var str_replace;
    str_replace = str.replace(expr, '', 'g');

    if (str_replace.length == 8) {
        // On récupère la clef du code à tester
        clefEAN = str_replace.substr(7, 1);
        clef_calc = 0;
        for (idx = 1; idx < 8; idx++) {
            if ((idx % 2) != 0) {
                clef_calc += 3 * parseInt(str_replace.substr(idx - 1, 1));
            }
            else {
                clef_calc += parseInt(str_replace.substr(idx - 1, 1));
            }
        }

        clef_calc %= 10;
        clef_calc = 10 - clef_calc;
        if (clef_calc == 10)
            {
                clef_calc = '0';
            }
        else
            {
                clef_calc = '' + clef_calc;
            }

        if (clefEAN == clef_calc)
            {
                eanok = true;
            }
    }

    return eanok;
}

// Vérifie si la chaîne est un code EAN-13
function IsEAN13(str) {
    var clefEAN;
    var clef_calc;
    var idx;
    var eanok = false;

    // Nettoyage de la chaine
    var expr = new RegExp("[ ]|\-", "g");
    var str_replace;
    str_replace = str.replace(expr, '', 'g');

    if (str_replace.length == 13) {
        // On récupère la clef du code à tester
        clefEAN = str_replace.substr(12, 1);

        clef_calc = 0;
        for (idx = 1; idx < 13; idx++) {
            if ((idx % 2) != 0) {
                clef_calc += parseInt(str_replace.substr(idx - 1, 1));
            }
            else {
                clef_calc += 3 * parseInt(str_replace.substr(idx - 1, 1));
            }
        }

        clef_calc %= 10;
        clef_calc = 10 - clef_calc;
        if (clef_calc == 10)
            {
                clef_calc = '0';
            }
        else
            {
                clef_calc = '' + clef_calc;
            }

        if (clefEAN == clef_calc)
            {
                eanok = true;
            }
    }

    return eanok;
}

// Vérifie si la chaîne est un code GTIN-8
function IsGTIN8(str) {
    var clefGTIN8;
    var clef_calc;
    var idx;
    var gtinok = false;

    // Nettoyage de la chaine
    var expr = new RegExp("[ ]|\-", "g");
    var str_replace;
    str_replace = str.replace(expr, '', 'g');

    if (str_replace.length == 8) {
        // On récupère la clef du code à tester
        clefGTIN8 = str_replace.substr(7, 1);

        clef_calc = 0;
        for (idx = 1; idx < 8; idx++) {
            if ((idx % 2) != 0) {
                clef_calc += 3 * parseInt(str_replace.substr(idx - 1, 1));
            }
            else {
                clef_calc += parseInt(str_replace.substr(idx - 1, 1));
            }
        }
        clef_calc %= 10;
        clef_calc = 10 - clef_calc;
        if (clef_calc == 10)
            {
                clef_calc = '0';
            }
        else
            {
                clef_calc = '' + clef_calc;
            }

        if (clefGTIN8 == clef_calc)
            {
                gtinok = true;
            }
    }

    return gtinok;
}

// Vérifie si la chaîne est un code GTIN-12
function IsGTIN12(str) {
    var clefGTIN12;
    var clef_calc;
    var idx;
    var gtinok = false;

    // Nettoyage de la chaine
    var expr = new RegExp("[ ]|\-", "g");
    var str_replace;
    str_replace = str.replace(expr, '', 'g');

    if (str_replace.length == 12) {
        // On récupère la clef du code à tester
        clefGTIN12 = str_replace.substr(11, 1);

        clef_calc = 0;
        for (idx = 1; idx < 12; idx++) {
            if ((idx % 2) != 0) {
                clef_calc += 3 * parseInt(str_replace.substr(idx - 1, 1));
            }
            else {
                clef_calc += parseInt(str_replace.substr(idx - 1, 1));
            }
        }
        clef_calc %= 10;
        clef_calc = 10 - clef_calc;
        if (clef_calc == 10)
            {
                clef_calc = '0';
            }
        else
            {
                clef_calc = '' + clef_calc;
            }

        if (clefGTIN12 == clef_calc)
            {
                gtinok = true;
            }
    }

    return gtinok;
}

// Vérifie si la chaîne est un code GTIN-13
function IsGTIN13(str) {
    var clefGTIN13;
    var clef_calc;
    var idx;
    var gtinok = false;

    // Nettoyage de la chaine
    var expr = new RegExp("[ ]|\-", "g");
    var str_replace;
    str_replace = str.replace(expr, '', 'g');

    if (str_replace.length == 13) {
        // On récupère la clef du code à tester
        clefGTIN13 = str_replace.substr(12, 1);

        clef_calc = 0;
        for (idx = 1; idx < 13; idx++) {
            if ((idx % 2) != 0) {
                clef_calc += parseInt(str_replace.substr(idx - 1, 1));
            }
            else {
                clef_calc += 3 * parseInt(str_replace.substr(idx - 1, 1));
            }
        }
        clef_calc %= 10;
        clef_calc = 10 - clef_calc;
        if (clef_calc == 10)
            {
                clef_calc = '0';
            }
        else
            {
                clef_calc = '' + clef_calc;
            }

        if (clefGTIN13 == clef_calc)
            {
                gtinok = true;
            }
    }

    return gtinok;
}

// Vérifie si la chaîne est un code GTIN-14
function IsGTIN14(str) {
    var clefGTIN14;
    var clef_calc;
    var idx;
    var gtinok = false;

    // Nettoyage de la chaine
    var expr = new RegExp("[ ]|\-", "g");
    var str_replace;
    str_replace = str.replace(expr, '', 'g');

    if (str_replace.length == 14) {
        // On récupère la clef du code à tester
        clefGTIN14 = str_replace.substr(13, 1);

        clef_calc = 0;
        for (idx = 1; idx < 14; idx++) {
            if ((idx % 2) != 0) {
                clef_calc += 3 * parseInt(str_replace.substr(idx - 1, 1));
            }
            else {
                clef_calc += parseInt(str_replace.substr(idx - 1, 1));
            }
        }
        clef_calc %= 10;
        clef_calc = 10 - clef_calc;
        if (clef_calc == 10)
            {
                clef_calc = '0';
            }
        else
            {
                clef_calc = '' + clef_calc;
            }

        if (clefGTIN14 == clef_calc)
            {
                gtinok = true;
            }
    }

    return gtinok;
}

// Vérifie si la chaîne est un code ISBN-10
function IsISBN10(str) {
    var clefISBN10;
    var clef_calc;
    var idx;
    var isbnok = false;

    // Nettoyage de la chaine
    var expr = new RegExp("[ ]|\-", "g");
    var str_replace;
    str_replace = str.replace(expr, '', 'g');

    if (str_replace.length == 10) {
        // On récupère la clef du code à tester
        clefISBN10 = str_replace.substr(9, 1);

        clef_calc = 0;
        for (idx = 0; idx < 9; idx++) {
            clef_calc += (10 - idx) * parseInt(str_replace.substr(idx, 1));
        }
        clef_calc %= 11;
        clef_calc = 11 - clef_calc;
        switch (clef_calc) {
            case 10:
                clef_calc = 'X';
                break;
            case 11:
                clef_calc = '0';
                break;
            default:
        }

        if (clefISBN10 == clef_calc)
            {
                isbnok = true;
            }
    }

    return isbnok;
}

// Vérifie si la chaîne est un code ISBN-13
function IsISBN13(str) {
    var clefISBN13;
    var clef_calc;
    var idx;
    var isbnok = false;

    // Nettoyage de la chaine
    var expr = new RegExp("[ ]|\-", "g");
    var str_replace;
    str_replace = str.replace(expr, '', 'g');

    if (str_replace.length == 13) {
        // On récupère la clef du code à tester
        clefISBN13 = str_replace.substr(12, 1);

        clef_calc = 0;
        for (idx = 1; idx < 13; idx++) {
            if ((idx % 2) != 0) {
                clef_calc += parseInt(str_replace.substr(idx - 1, 1));
            }
            else {
                clef_calc += 3 * parseInt(str_replace.substr(idx - 1, 1));
            }
        }
        clef_calc %= 10;
        clef_calc = 10 - clef_calc;
        if (clef_calc == 10)
            {
                clef_calc = '0';
            }
        else
            {
                clef_calc = '' + clef_calc;
            }

        if (clefISBN13 == clef_calc)
            {
                isbnok = true;
            }
    }

    return isbnok;
}

// Vérifie si la chaîne est un code SSCC
function IsSSCC(str) {
    var clefSSCC;
    var clef_calc;
    var idx;
    var ssccok = false;

    // Nettoyage de la chaine
    var expr = new RegExp("[ ]|\-", "g");
    var str_replace;
    str_replace = str.replace(expr, '', 'g');

    if (str_replace.length == 18) {
        // On récupère la clef du code à tester
        clefSSCC = str_replace.substr(17, 1);

        clef_calc = 0;
        for (idx = 1; idx < 18; idx++) {
            if ((idx % 2) != 0) {
                clef_calc += 3 * parseInt(str_replace.substr(idx - 1, 1));
            }
            else {
                clef_calc += parseInt(str_replace.substr(idx - 1, 1));
            }
        }
        clef_calc %= 10;
        clef_calc = 10 - clef_calc;
        if (clef_calc == 10)
            {
                clef_calc = '0';
            }
        else
            {
                clef_calc = '' + clef_calc;
            }

        if (clefSSCC == clef_calc)
            {
                ssccok = true;
            }
    }

    return ssccok;
}

// Vérifie si la chaîne est un code ISSN
function IsISSN(str) {
    var clefISSN;
    var clef_calc;
    var idx;
    var issnok = false;

    // Nettoyage de la chaine
    var expr = new RegExp("[ ]|\-", "g");
    var str_replace;
    str_replace = str.replace(expr, '', 'g');

    if (str_replace.length == 8) {
        // On récupère la clef du code à tester
        clefISSN = str_replace.substr(7, 1);
        clef_calc = 0;
        for (idx = 0; idx < 7; idx++) {
            clef_calc += (8 - idx) * parseInt(str_replace.substr(idx, 1));
        }
        clef_calc %= 11;
        clef_calc = 11 - clef_calc;
        switch (clef_calc) {
            case 10:
                clef_calc = 'X';
                break;
            case 11:
                clef_calc = '0';
                break;
            default:
        }

        if (clefISSN == clef_calc)
            {
                issnok = true;
            }
    }

    return issnok;
}

// Donne la qualité d'un mot de passe
// 9 maximum
function GivePwQ(valpw) {
    var invalide;
    var nivpw = 0;	// Niveau calculé

    if ((valpw) && (valpw != "")) {
        // Vérification longueur
        if (valpw.length >= 7) {
            nivpw++;
        }

        // Vérification majuscules
        if (valpw.match(/[A-Z]/)) {
            nivpw++;
        }

        // Vérification minuscules
        if (valpw.match(/[a-z]/)) {
            nivpw++;
        }

        // Vérification si caractères numériques
        if (valpw.match(/\d/)) {
            nivpw++;
        }

        // Vérification présence caractère souligné
        if (valpw.indexOf("_") > -1) {
            nivpw++;
        }

        // Il doit y avoir un caractère spécial
        if (valpw.match(/[\-\#\@\%\!\$\*\&\<\>]/)) {
            nivpw++;
        }

        // Il doit y avoir une parenthèse spéciale
        if (valpw.match(/[\{\}\[\]]/)) {
            nivpw++;
        }

        //  Il vaut mieux commencer avec une lettre
        if (valpw.match(/^[a-zA-Z]+/)) {
            nivpw++;
        }

        // Les espaces ne sont pas recommandés
        invalide = " ";
        if (!(valpw.indexOf(invalide) > -1)) {
            nivpw++;
        }
    }

    return nivpw;
}

// Retourne la string regexp 'téléphone fixe' en fonction du code pays
// Si pas de pays, numéro international
function GiveExpr_tel(pays) {
    var expr = '';

    if (pays) {
        pays = pays.toLowerCase();

        switch (pays) {
            case 'ad' :
                expr = "^([+]376[ ])?[0-9]{6,9}$";
                break;
            case 'ae' :
                expr = "^([+]31[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{7,9}$";
                break;
            case 'af' :
                expr = "^([+]93[ ]|0)[0-9]{2}[ \.\-]?[0-9]{6}$";
                break;
            case 'ag' :
                expr = "^([+]1[ ])?268[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'ai' :
                expr = "^([+]1[ ])?264[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'al' :
                expr = "^([+]355[ ]|0)[0-9]{1,3}[ \.\-]?[0-9]{4,6}?$";
                break;
            case 'am' :
                expr = "^([+]374[ ]|0)[0-9]{2,5}[ \.\-]?[0-9]{3,6}$";
                break;
            case 'an' :
                expr = "^([+]599[ ]|0)[0-9]{0,1}[ \.\-]?[0-9]{7}$";
                break;
            case 'ao' :
                expr = "^([+]244[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{5,8}$";
                break;
            case 'ar' :
                expr = "^([+]54[ ]|0)[0-9]{2,4}[ \.\-]?[0-9]{5,8}$";
                break;
            case 'as' :
                expr = "^([+]1[ ])?684[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'at' :
                expr = "^([+]43[ ]|0)[0-9]{1,4}[ \.\-]?[0-9]{3,12}$";
                break;
            case 'au' :
                expr = "^([+]61[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{5,15}$";
                break;
            case 'aw' :
                expr = "^([+]297[ ])?[0-9]{1}[ \.\-]?[0-9]{7}$";
                break;
            case 'ax' :
                expr = "^([+]358[ ])?18[ \.\-]??[0-9]{4}([0-9]{6})?$";
                break;
            case 'az' :
                expr = "^([+]994[ ]|0)[0-9]{2,3}[ \.\-]?[0-9]{5,7}$";
                break;
            case 'ba' :
                expr = "^([+]387[ ]|0)[0-9]{2}[ \.\-]?[0-9]{5,6}$";
                break;
            case 'bb' :
                expr = "^([+]1[ ])?246[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'bd' :
                expr = "^([+]880[ ]|0)[0-9]{1,4}[ \.\-]?[0-9]{3,7}$";
                break;
            case 'be' :
                expr = "^([+]32[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{2,3}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}$";
                break;
            case 'bf' :
                expr = "^([+]226[ ])?[0-9]{8}$";
                break;
            case 'bg' :
                expr = "^([+]359[ ]|0)[0-9]{1,5}[ \.\-]?[0-9]{3,7}$";
                break;
            case 'bh' :
                expr = "^([+]973[ ])?[0-9]{6,8}$";
                break;
            case 'bi' :
                expr = "^([+]257[ ])?[0-9]{7}$";
                break;
            case 'bj' :
                expr = "^([+]229[ ])?[0-9]{8}$";
                break;
            case 'bm' :
                expr = "^([+]1[ ])?441[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'bn' :
                expr = "^([+]673[ ])?[0-9]{6,7}$";
                break;
            case 'bo' :
                expr = "^([+]49[ ]|0)[0-9]{1}[ \.\-]?[0-9]{7}$";
                break;
            case 'br' :
                expr = "^([+]55[ ]|0)[0-9]{2}[ \.\-]?[0-9]{8}$";
                break;
            case 'bs' :
                expr = "^([+]1[ ])?242[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'bt' :
                expr = "^([+]975[ ]|0)?[0-9]{1}[ \.\-]?[0-9]{6}$";
                break;
            case 'bw' :
                expr = "^([+]267[ ])?[0-9]{6,7}$";
                break;
            case 'by' :
                expr = "^([+]375[ ]|8)[0-9]{2,4}[ \.\-]?[0-9]{5,7}$";
                break;
            case 'bz' :
                expr = "^([+]501[ ])?[0-9]{7}$";
                break;
            case 'ca' :
                expr = "^([+]1[ ])?[0-9]{3}[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'cd' :
                expr = "^([+]243[ ]|0)[0-9]{1}[ \.\-]?[0-9]{7}$";
                break;
            case 'cf' :
                expr = "^([+]236[ ])?[0-9]{6}$";
                break;
            case 'cg' :
                expr = "^([+]242[ ])?[0-9]{7}$";
                break;
            case 'ch' :
                expr = "^([+]41[ ]|0)[0-9]{2,3}[ \.\-]?[0-9]{6,7}$";
                break;
            case 'ci' :
                expr = "^([+]225[ ])?[0-9]{8}$";
                break;
            case 'ck' :
                expr = "^([+]682[ ])?[0-9]{5}$";
                break;
            case 'cl' :
                expr = "^([+]56[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{6,7}$";
                break;
            case 'cm' :
                expr = "^([+]237[ ])?[0-9]{3}[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{3}$";
                break;
            case 'cn' :
                expr = "^([+]86[ ]|0)[0-9]{2,4}[ \.\-]?[0-9]{4,8}$";
                break;
            case 'co' :
                expr = "^([+]57[ ]|09)[0-9]{1,5}[ \.\-]?[0-9]{5,7}$";
                break;
            case 'cr' :
                expr = "^([+]506[ ])?[0-9]{7}$";
                break;
            case 'cs' :
                expr = "^([+]381[ ]|0)[0-9]{2,3}[ \.\-]?[0-9]{5,7}$";
                break;
            case 'cu' :
                expr = "^([+]53[ ]|0)[0-9]{1,4}[ \.\-]?[0-9]{4,7}$";
                break;
            case 'cv' :
                expr = "^([+]238[ ])?[0-9]{7}$";
                break;
            case 'cz' :
                expr = "^([+]420[ ])?[0-9]{3}[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{3}$";
                break;
            case 'cy' :
                expr = "^([+]357[ ])?[0-9]{1,2}[ \.\-]?[0-9]{4,6}$";
                break;
            case 'de' :
                expr = "^([+]49[ ]|0)[0-9]{2,5}[ \.\-]?[0-9]{3,9}$";
                break;
            case 'dj' :
                expr = "^([+]253[ ])?[0-9]{6}$";
                break;
            case 'dk' :
                expr = "^([+]45[ ])?[0-9]{2}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}$";
                break;
            case 'do' :
                expr = "^([+]1[ ])?767[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'dz' :
                expr = "^([+]213[ ]|0)[0-9]{2}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}$";
                break;
            case 'ec' :
                expr = "^([+]49[ ]|0)[0-9]{1}[ \.\-]?[0-9]{6,7}$";
                break;
            case 'ee' :
                expr = "^([+]372[ ])?[0-9]{7,8}$";
                break;
            case 'eg' :
                expr = "^([+]20[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{6,7}$";
                break;
            case 'er' :
                expr = "^([+]291[ ]|0)[0-9]{1}[ \.\-]?[0-9]{6}$";
                break;
            case 'es' :
                expr = "^([+]34[ ])?[0-9]{9}$";
                break;
            case 'et' :
                expr = "^([+]251[ ]|0)[0-9]{2}[ \.\-]?[0-9]{7}$";
                break;
            case 'fi' :
                expr = "^([+]358[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{4,9}$";
                break;
            case 'fj' :
                expr = "^([+]679[ ])?[0-9]{7}$";
                break;
            case 'fk' :
                expr = "^([+]500[ ])?[0-9]{5}$";
                break;
            case 'fm' :
                expr = "^([+]691[ ]|1)[0-9]{7}$";
                break;
            case 'fo' :
                expr = "^([+]298[ ])?[0-9]{6}$";
                break;
            case 'fr' :
                expr = "^([+]33[ ]|0)[1-9]{1}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}$";
                break;
            case 'ga' :
                expr = "^([+]241[ ])?[0-9]{6}$";
                break;
            case 'gb' :
                expr = "^([+]44[ ]|0)[0-9]{2,6}[ \.\-]?[0-9]{3,8}$";
                break;
            case 'gd' :
                expr = "^([+]1[ ])?473[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'ge' :
                expr = "^([+]995[ ]|8)[0-9]{2,3}[ \.\-]?[0-9]{5,6}$";
                break;
            case 'gf' :
                expr = "^([+]594|0594)[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{3}$";
                break;
            case 'gh' :
                expr = "^([+]233[ ]|0)[0-9]{2,3}[ \.\-]?[0-9]{3,6}$";
                break;
            case 'gi' :
                expr = "^([+]350[ ])?[0-9]{4,8}$";
                break;
            case 'gl' :
                expr = "^([+]299[ ])?[0-9]{6}$";
                break;
            case 'gm' :
                expr = "^([+]220[ ])?[0-9]{7}$";
                break;
            case 'gn' :
                expr = "^([+]224[ ])?[0-9]{6}$";
                break;
            case 'gp' :
                expr = "^([+]590|0590)[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}$";
                break;
            case 'gq' :
                expr = "^([+]240[ ])?[0-9]{0,1}[ \.\-]?[0-9]{6}$";
                break;
            case 'gr' :
                expr = "^([+]30[ ]|0)[0-9]{1,3}[ \.\-]?[0-9]{5,7}$";
                break;
            case 'gt' :
                expr = "^([+]502[ ])?[0-9]{7,8}$";
                break;
            case 'gu' :
                expr = "^([+]1[ ])?671[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'gw' :
                expr = "^([+]245[ ])?[0-9]{6}$";
                break;
            case 'gy' :
                expr = "^([+]591[ ])?[0-9]{1}[ \.\-]?[0-9]{5}$";
                break;
            case 'hk' :
                expr = "^([+]852[ ])?[0-9]{8}$";
                break;
            case 'hn' :
                expr = "^([+]504[ ])?[0-9]{7}$";
                break;
            case 'hr' :
                expr = "^([+]385[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{5,7}$";
                break;
            case 'ht' :
                expr = "^([+]509[ ])?[0-9]{7}$";
                break;
            case 'hu' :
                expr = "^([+]36[ ]|06)?[0-9]{1,2}[ \.\-]?[0-9]{6,7}$";
                break;
            case 'id' :
                expr = "^([+]62[ ]|0)[0-9]{1,4}[ \.\-]?[0-9]{5,11}$";
                break;
            case 'ie' :
                expr = "^([+]353[ ]|0)[0-9]{1,3}[ \.\-]?[0-9]{5,7}$";
                break;
            case 'il' :
                expr = "^([+]972[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{6,7}$";
                break;
            case 'in' :
                expr = "^([+]91[ ]|0)[0-9]{2,7}[ \.\-]?[0-9]{4,8}$";
                break;
            case 'iq' :
                expr = "^([+]964[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{4,9}$";
                break;
            case 'ir' :
                expr = "^([+]97[ ]|0)[0-9]{3}[ \.\-]?[0-9]{7}$";
                break;
            case 'is' :
                expr = "^([+]354[ ])?[0-9]{7,9}$";
                break;
            case 'it' :
                expr = "^([+]39[ ])?[0-9]{1,3}[ \.\-]?[0-9]{5,8}$";
                break;
            case 'jm' :
                expr = "^([+]1[ ])?876[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'jo' :
                expr = "^([+]962[ ]|0)[0-9]{1}[ \.\-]?[0-9]{7,8}$";
                break;
            case 'jp' :
                expr = "^([+]81[ ]|0)[0-9]{1,5}[ \.\-]?[0-9]{4,8}$";
                break;
            case 'ke' :
                expr = "^([+]254[ ]|0)[0-9]{1,3}[ \.\-]?[0-9]{5,6}$";
                break;
            case 'kg' :
                expr = "^([+]996[ ]|0)[0-9]{3,4}[ \.\-]?[0-9]{5,6}$";
                break;
            case 'kh' :
                expr = "^([+]855[ ]|0)[0-9]{2}[ \.\-]?[0-9]{6}$";
                break;
            case 'ki' :
                expr = "^([+]686[ ])?[0-9]{5}$";
                break;
            case 'km' :
                expr = "^([+]262[ ]|[+]269[ ])?[0-9]{6}$";
                break;
            case 'kn' :
                expr = "^([+]1[ ])?869[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'kp' :
                expr = "^([+]82[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{6,7}$";
                break;
            case 'kr' :
                expr = "^([+]850[ ]|0)?[0-9]{1,2}[ \.\-]?[0-9]{7}$";
                break;
            case 'ky' :
                expr = "^([+]1[ ])?345[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'kw' :
                expr = "^([+]965[ ])?[0-9]{7}$";
                break;
            case 'kz' :
                expr = "^([+]7[ ]|8)[0-9]{3}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{5,6}$";
                break;
            case 'la' :
                expr = "^([+]856[ ]|0)[0-9]{2}[ \.\-]?[0-9]{6}$";
                break;
            case 'lb' :
                expr = "^([+]961[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{6}$";
                break;
            case 'lc' :
                expr = "^([+]1[ ])?758[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'li' :
                expr = "^([+]423[ ])?[0-9]{7}$";
                break;
            case 'lk' :
                expr = "^([+]94[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{4,6}$";
                break;
            case 'lr' :
                expr = "^([+]231[ ])?[0-9]{6}$";
                break;
            case 'ls' :
                expr = "^([+]266[ ])?[0-9]{8}$";
                break;
            case 'lt' :
                expr = "^([+]370[ ]|0|8)[0-9]{1,2}[ \.\-]?[0-9]{5,6}$";
                break;
            case 'lu' :
                expr = "^([+]352[ ])?[0-9]{5,11}$";
                break;
            case 'lv' :
                expr = "^([+]371[ ]|8)?[0-9]{0,2}[ \.\-]?[0-9]{5,7}$";
                break;
            case 'ly' :
                expr = "^([+]218[ ]|0)[0-9]{2,3}[ \.\-]?[0-9]{5,7}$";
                break;
            case 'ma' :
                expr = "^([+]212[ ]|0)[0-9]{1}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}$";
                break;
            case 'mc' :
                expr = "^([+]377[ ])?[0-9]{8,9}$";
                break;
            case 'md' :
                expr = "^([+]373[ ]|0)[0-9]{2,3}[ \.\-]?[0-9]{5,6}$";
                break;
            case 'me' :
                expr = "^([+]382[ ]|0)[0-9]{2,3}[ \.\-]?[0-9]{5,7}$";
                break;
            case 'mg' :
                expr = "^([+]261[ ])?([0-9]{2})?[0-9]{7}$";
                break;
            case 'mh' :
                expr = "^([+]692[ ])?[1]{0,1}[ \.\-]?[0-9]{7}$";
                break;
            case 'mk' :
                expr = "^([+]389[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{5,7}$";
                break;
            case 'ml' :
                expr = "^([+]223[ ])?[0-9]{7}$";
                break;
            case 'mm' :
                expr = "^([+]95[ ]|0)?[0-9]{1,2}[ \.\-]?[0-9]{5,6}$";
                break;
            case 'mn' :
                expr = "^([+]976[ ]|01|02)[0-9]{1,4}[ \.\-]?[0-9]{4,6}$";
                break;
            case 'mo' :
                expr = "^([+]853[ ])?[0-9]{6,7}$";
                break;
            case 'mp' :
                expr = "^([+]1[ ])?670[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'mq' :
                expr = "^([+]596|0596)[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}$";
                break;
            case 'mr' :
                expr = "^([+]222[ ])?[0-9]{7}$";
                break;
            case 'ms' :
                expr = "^([+]1[ ])?664[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'mt' :
                expr = "^([+]356[ ])?[0-9]{2}[ \.\-][0-9]{3}[ \.\-][0-9]{3}$";
                break;
            case 'mu' :
                expr = "^([+]230[ ])?[0-9]{7}$";
                break;
            case 'mv' :
                expr = "^([+]960[ ])?[0-9]{7}$";
                break;
            case 'mw' :
                expr = "^([+]265[ ])?[0-9]{8}$";
                break;
            case 'mx' :
                expr = "^([+]52[ ]|01|02)[0-9]{1,3}[ \.\-]?[0-9]{5,7}$";
                break;
            case 'my' :
                expr = "^([+]60[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{6,8}$";
                break;
            case 'mz' :
                expr = "^([+]258[ ])?[0-9]{1,2}[ \.\-]?[0-9]{5,6}$";
                break;
            case 'na' :
                expr = "^([+]264[ ]|0)[0-9]{2,4}[ \.\-]?[0-9]{2,6}$";
                break;
            case 'nc' :
                expr = "^([+]687[ ])?[0-9]{2}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}$";
                break;
            case 'ne' :
                expr = "^([+]227[ ])?[0-9]{6}$";
                break;
            case 'ng' :
                expr = "^([+]233[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{5,7}$";
                break;
            case 'ni' :
                expr = "^([+]505[ ])?[0-9]{7}$";
                break;
            case 'nl' :
                expr = "^([+]31[ ]|0)[0-9]{2,3}[ \.\-]?[0-9]{6,7}$";
                break;
            case 'np' :
                expr = "^([+]977[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{6,7}$";
                break;
            case 'nr' :
                expr = "^([+]674[ ])?[0-9]{7}$";
                break;
            case 'nu' :
                expr = "^([+]683[ ])?[0-9]{4}$";
                break;
            case 'pa' :
                expr = "^([+]507[ ])?[0-9]{7}$";
                break;
            case 'pf' :
                expr = "^([+]689[ ])?[0-9]{2}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}$";
                break;
            case 'pr' :
                expr = "^([+]1[ ])?[787|939][ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'nf' :
            case 'pn' :
                expr = "^([+]672[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{3,5}$";
                break;
            case 'no' :
                expr = "^([+]47[ ])?[0-9]{8}$";
                break;
            case 'nz' :
                expr = "^([+]64[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{6,8}$";
                break;
            case 'om' :
                expr = "^([+]968[ ])?[0-9]{6,8}$";
                break;
            case 'pe' :
                expr = "^([+]51[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{6,8}$";
                break;
            case 'pg' :
                expr = "^([+]675[ ])?[0-9]{7}$";
                break;
            case 'ph' :
                expr = "^([+]63[ ]|0)[0-9]{1,4}[ \.\-]?[0-9]{5,7}$";
                break;
            case 'pk' :
                expr = "^([+]92[ ]|0)[0-9]{2,5}[ \.\-]?[0-9]{4,7}$";
                break;
            case 'pl' :
                expr = "^([+]48[ ]|0)[0-9]{2}[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}$";
                break;
            case 'pm' :
                expr = "^([+]508[ ])?[0-9]{6}$";
                break;
            case 'ps' :
                expr = "^([+]970[ ]|0)[0-9]{1}[ \.\-]?[0-9]{7}$";
                break;
            case 'pt' :
                expr = "^([+]351[ ])?[0-9]{1,2}[ \.\-]?[0-9]{5,7}$";
                break;
            case 'pw' :
                expr = "^([+]680[ ])?[0-9]{7}$";
                break;
            case 'py' :
                expr = "^([+]595[ ]|0)[0-9]{2,4}[ \.\-]?[0-9]{3,7}$";
                break;
            case 'qa' :
                expr = "^([+]974[ ])?[0-9]{6}$";
                break;
            case 'ro' :
                expr = "^([+]40[ ]|0)[0-9]{1,3}[ \.\-]?[0-9]{5,7}$";
                break;
            case 'ru' :
                expr = "^([+]7[ ]|8)[0-9]{3,5}[ \.\-]?[0-9]{5,7}$";
                break;
            case 'rw' :
                expr = "^([+]250[ ])?[0-9]{5,8}$";
                break;
            case 'sa' :
                expr = "^([+]966[ ]|0)[0-9]{1}[ \.\-]?[0-9]{7}$";
                break;
            case 'sc' :
                expr = "^([+]248[ ])?[0-9]{6}$";
                break;
            case 'sd' :
                expr = "^([+]249[ ]|0)[0-9]{2,3}[ \.\-]?[0-9]{5,6}$";
                break;
            case 'sk' :
                expr = "^([+]421[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{7,8}$";
                break;
            case 're' :
                expr = "^([+]262[ ]262|0262)[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{3}$";
                break;
            case 'sb' :
                expr = "^([+]677[ ])?[0-9]{5}$";
                break;
            case 'se' :
                expr = "^([+]46[ ]|0)[0-9]{1,3}[ \.\-]?[0-9]{5,8}$";
                break;
            case 'sg' :
                expr = "^([+]65[ ])?[0-9]{7,8}$";
                break;
            case 'sh' :
                expr = "^([+]290[ ])?[0-9]{4}$";
                break;
            case 'si' :
                expr = "^([+]386[ ]|0)[0-9]{1}[ \.\-]?[0-9]{7}$";
                break;
            case 'sl' :
                expr = "^([+]232[ ]|0)[0-9]{2}[ \.\-]?[0-9]{6}$";
                break;
            case 'sm' :
                expr = "^([+]378[ ])?[0-9]{10,12}$";
                break;
            case 'sn' :
                expr = "^([+]221[ ])?[0-9]{7}$";
                break;
            case 'so' :
                expr = "^([+]252[ ])?[0-9]{7}$";
                break;
            case 'sr' :
                expr = "^([+]597[ ])?[0-9]{6}$";
                break;
            case 'st' :
                expr = "^([+]239[ ])?[0-9]{6}$";
                break;
            case 'sv' :
                expr = "^([+]503[ ])?[0-9]{7}$";
                break;
            case 'sy' :
                expr = "^([+]963[ ]|0)[0-9]{2}[ \.\-]?[0-9]{6,7}$";
                break;
            case 'sz' :
                expr = "^([+]268[ ]|0)[0-9]{7}$";
                break;
            case 'tc' :
                expr = "^([+]1[ ])?649[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'td' :
                expr = "^([+]235[ ])?[0-9]{6}$";
                break;
            case 'th' :
                expr = "^([+]66[ ]|0)[0-9]{1,3}[ \.\-]?[0-9]{6,7}$";
                break;
            case 'tg' :
                expr = "^([+]228[ ])?[0-9]{7}$";
                break;
            case 'tj' :
                expr = "^([+]998[ ]|8)[0-9]{2,4}[ \.\-]?[0-9]{5,7}$";
                break;
            case 'tk' :
                expr = "^([+]690[ ])?[0-9]{1}[ \.\-]?[0-9]{3}$";
                break;
            case 'tl' :
                expr = "^([+]670[ ])?[0-9]{7}$";
                break;
            case 'tm' :
                expr = "^([+]993[ ]|8)[0-9]{2,3}[ \.\-]?[0-9]{5,6}$";
                break;
            case 'tn' :
                expr = "^([+]216[ ])?[0-9]{2}[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{3}$";
                break;
            case 'to' :
                expr = "^([+]676[ ])?[0-9]{7}$";
                break;
            case 'tr' :
                expr = "^([+]90[ ]|0)[0-9]{3}[ \.\-]?[0-9]{7}$";
                break;
            case 'tt' :
                expr = "^([+]1[ ])?868[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'tv' :
                expr = "^([+]688[ ])?[0-9]{5}$";
                break;
            case 'tw' :
                expr = "^([+]886[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{6,8}$";
                break;
            case 'tz' :
                expr = "^([+]255[ ]|0)[0-9]{2}[ \.\-]?[0-9]{7}$";
                break;
            case 'ua' :
                expr = "^([+]380[ ]|8)[0-9]{2,4}[ \.\-]?[0-9]{5,7}$";
                break;
            case 'ug' :
                expr = "^([+]256[ ]|0)[0-9]{2,3}[ \.\-]?[0-9]{4,7}$";
                break;
            case 'us' :
                expr = "^([+]1[ ])?[0-9]{3}[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                // expr = "^([+]1[ ])?[0-9]{3}[ \.\-]?(([0-9]{3}[ \.\-]?[0-9]{4})|[a-zA-Z]{7})$";
                break;
            case 'uy' :
                expr = "^([+]598[ ]|0)[0-9]{1,4}[ \.\-]?[0-9]{4,6}$";
                break;
            case 'uz' :
                expr = "^([+]998[ ]|8)[0-9]{2}[ \.\-]?[0-9]{7}$";
                break;
            case 'vc' :
                expr = "^([+]1[ ])?784[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 've' :
                expr = "^([+]58[ ]|0)[0-9]{3}[ \.\-]?[0-9]{7}$";
                break;
            case 'vg' :
                expr = "^([+]1[ ])?284[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'vi' :
                expr = "^([+]1[ ])?340[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'vn' :
                expr = "^([+]84[ ]|0)[0-9]{1,3}[ \.\-]?[0-9]{5,7}$";
                break;
            case 'vu' :
                expr = "^([+]678[ ])?[0-9]{5}$";
                break;
            case 'wf' :
                expr = "^([+]681[ ])?[0-9]{6}$";
                break;
            case 'ws' :
                expr = "^([+]685[ ])?[0-9]{6,7}$";
                break;
            case 'ye' :
                expr = "^([+]967[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{5,7}$";
                break;
            case 'yt' :
                expr = "^([+]262[ ]269|0269)[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{3}$";
                break;
            case 'za' :
                expr = "^([+]27[ ]|0)[0-9]{2,5}[ \.\-]?[0-9]{3,7}$";
                break;
            case 'zm' :
                expr = "^([+]260[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{5,6}$";
                break;
            case 'zw' :
                expr = "^([+]263[ ]|0)[0-9]{1,4}[ \.\-]?[0-9]{3,8}$";
                break;
            default :
                expr = "^([+][0-9]{2,3}[ ])?[0-9]{6,11}$";
                break;
        }
    }
    else {
        expr = "^([+][0-9]{2,3}[ ])?[0-9]{6,11}$";
    }
    return expr;
}

// Retourne la string regexp 'téléphone portable' en fonction du code pays
// Si pas de pays, numéro international
function GiveExpr_telp(pays) {
    var expr = '';

    if (pays) {
        pays = pays.toLowerCase();

        switch (pays) {
            case 'ad' :
                expr = "^([+]376[ ])?[0-9]{6,9}$";
                break;
            case 'ae' :
                expr = "^([+]31[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{7,9}$";
                break;
            case 'af' :
                expr = "^([+]93[ ]|0)[0-9]{2}[ \.\-]?[0-9]{6}$";
                break;
            case 'ag' :
                expr = "^([+]1[ ])?268[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'ai' :
                expr = "^([+]1[ ])?264[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'al' :
                expr = "^([+]355[ ]|0)[0-9]{1,3}[ \.\-]?[0-9]{4,6}?$";
                break;
            case 'am' :
                expr = "^([+]374[ ]|0)[0-9]{2,5}[ \.\-]?[0-9]{3,6}$";
                break;
            case 'an' :
                expr = "^([+]599[ ]|0)[0-9]{0,1}[ \.\-]?[0-9]{7}$";
                break;
            case 'ao' :
                expr = "^([+]244[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{5,8}$";
                break;
            case 'ar' :
                expr = "^([+]54[ ]|0)[0-9]{2,4}[ \.\-]?[0-9]{5,8}$";
                break;
            case 'as' :
                expr = "^([+]1[ ])?684[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'at' :
                expr = "^([+]43[ ]|0)[0-9]{1,4}[ \.\-]?[0-9]{3,12}$";
                break;
            case 'au' :
                expr = "^([+]61[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{5,15}$";
                break;
            case 'aw' :
                expr = "^([+]297[ ])?[0-9]{1}[ \.\-]?[0-9]{7}$";
                break;
            case 'ax' :
                expr = "^([+]358[ ])?18[ \.\-]??[0-9]{4}([0-9]{6})?$";
                break;
            case 'az' :
                expr = "^([+]994[ ]|0)[0-9]{2,3}[ \.\-]?[0-9]{5,7}$";
                break;
            case 'ba' :
                expr = "^([+]387[ ]|0)[0-9]{2}[ \.\-]?[0-9]{5,6}$";
                break;
            case 'bb' :
                expr = "^([+]1[ ])?246[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'bd' :
                expr = "^([+]880[ ]|0)[0-9]{1,4}[ \.\-]?[0-9]{3,7}$";
                break;
            case 'be' :
                expr = "^([+]32[ ]|0)[0-9]{1,3}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}$";
                break;
            case 'bf' :
                expr = "^([+]226[ ])?[0-9]{8}$";
                break;
            case 'bg' :
                expr = "^([+]359[ ]|0)[0-9]{1,5}[ \.\-]?[0-9]{3,7}$";
                break;
            case 'bh' :
                expr = "^([+]973[ ])?[0-9]{6,8}$";
                break;
            case 'bi' :
                expr = "^([+]257[ ])?[0-9]{7}$";
                break;
            case 'bj' :
                expr = "^([+]229[ ])?[0-9]{8}$";
                break;
            case 'bm' :
                expr = "^([+]1[ ])?441[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'bn' :
                expr = "^([+]673[ ])?[0-9]{6,7}$";
                break;
            case 'bo' :
                expr = "^([+]49[ ]|0)[0-9]{1}[ \.\-]?[0-9]{7}$";
                break;
            case 'br' :
                expr = "^([+]55[ ]|0)[0-9]{2}[ \.\-]?[0-9]{8}$";
                break;
            case 'bs' :
                expr = "^([+]1[ ])?242[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'bt' :
                expr = "^([+]975[ ]|0)?[0-9]{1}[ \.\-]?[0-9]{6}$";
                break;
            case 'bw' :
                expr = "^([+]267[ ])?[0-9]{6,7}$";
                break;
            case 'by' :
                expr = "^([+]375[ ]|8)[0-9]{2,4}[ \.\-]?[0-9]{5,7}$";
                break;
            case 'bz' :
                expr = "^([+]501[ ])?[0-9]{7}$";
                break;
            case 'ca' :
                expr = "^([+]1[ ])?[0-9]{3}[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'cd' :
                expr = "^([+]243[ ]|0)[0-9]{1}[ \.\-]?[0-9]{7}$";
                break;
            case 'cf' :
                expr = "^([+]236[ ])?[0-9]{6}$";
                break;
            case 'cg' :
                expr = "^([+]242[ ])?[0-9]{7}$";
                break;
            case 'ch' :
                expr = "^([+]41[ ]|0)[0-9]{2,3}[ \.\-]?[0-9]{6,7}$";
                break;
            case 'ci' :
                expr = "^([+]225[ ])?[0-9]{8}$";
                break;
            case 'ck' :
                expr = "^([+]682[ ])?[0-9]{5}$";
                break;
            case 'cl' :
                expr = "^([+]56[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{6,7}$";
                break;
            case 'cm' :
                expr = "^([+]237[ ])?[0-9]{3}[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{3}$";
                break;
            case 'cn' :
                expr = "^([+]86[ ]|0)[0-9]{2,4}[ \.\-]?[0-9]{4,8}$";
                break;
            case 'co' :
                expr = "^([+]57[ ]|09)[0-9]{1,5}[ \.\-]?[0-9]{5,7}$";
                break;
            case 'cr' :
                expr = "^([+]506[ ])?[0-9]{7}$";
                break;
            case 'cs' :
                expr = "^([+]381[ ]|0)[0-9]{2,3}[ \.\-]?[0-9]{5,7}$";
                break;
            case 'cu' :
                expr = "^([+]53[ ]|0)[0-9]{1,4}[ \.\-]?[0-9]{4,7}$";
                break;
            case 'cv' :
                expr = "^([+]238[ ])?[0-9]{7}$";
                break;
            case 'cz' :
                expr = "^([+]420[ ])?[0-9]{3}[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{3}$";
                break;
            case 'cy' :
                expr = "^([+]357[ ])?[0-9]{1,2}[ \.\-]?[0-9]{4,6}$";
                break;
            case 'de' :
                expr = "^([+]49[ ]|0)[0-9]{2,5}[ \.\-]?[0-9]{3,9}$";
                break;
            case 'dj' :
                expr = "^([+]253[ ])?[0-9]{6}$";
                break;
            case 'dk' :
                expr = "^([+]45[ ])?[0-9]{2}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}$";
                break;
            case 'do' :
                expr = "^([+]1[ ])?767[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'dz' :
                expr = "^([+]213[ ]|0)[0-9]{2}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}$";
                break;
            case 'ec' :
                expr = "^([+]49[ ]|0)[0-9]{1}[ \.\-]?[0-9]{6,7}$";
                break;
            case 'ee' :
                expr = "^([+]372[ ])?[0-9]{7,8}$";
                break;
            case 'eg' :
                expr = "^([+]20[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{6,7}$";
                break;
            case 'er' :
                expr = "^([+]291[ ]|0)[0-9]{1}[ \.\-]?[0-9]{6}$";
                break;
            case 'es' :
                expr = "^([+]34[ ])?[0-9]{9}$";
                break;
            case 'et' :
                expr = "^([+]251[ ]|0)[0-9]{2}[ \.\-]?[0-9]{7}$";
                break;
            case 'fi' :
                expr = "^([+]358[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{4,9}$";
                break;
            case 'fj' :
                expr = "^([+]679[ ])?[0-9]{7}$";
                break;
            case 'fk' :
                expr = "^([+]500[ ])?[0-9]{5}$";
                break;
            case 'fm' :
                expr = "^([+]691[ ]|1)[0-9]{7}$";
                break;
            case 'fo' :
                expr = "^([+]298[ ])?[0-9]{6}$";
                break;
            case 'fr' :
                expr = "^([+]33[ ]|0)(6|7)[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}$";
                break;
            case 'ga' :
                expr = "^([+]241[ ])?[0-9]{6}$";
                break;
            case 'gb' :
                expr = "^([+]44[ ]|0)[0-9]{2,6}[ \.\-]?[0-9]{3,8}$";
                break;
            case 'gd' :
                expr = "^([+]1[ ])?473[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'ge' :
                expr = "^([+]995[ ]|8)[0-9]{2,3}[ \.\-]?[0-9]{5,6}$";
                break;
            case 'gf' :
                expr = "^([+]694|694|0694)[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{3}$";
                break;
            case 'gh' :
                expr = "^([+]233[ ]|0)[0-9]{2,3}[ \.\-]?[0-9]{3,6}$";
                break;
            case 'gi' :
                expr = "^([+]350[ ])?[0-9]{4,8}$";
                break;
            case 'gl' :
                expr = "^([+]299[ ])?[0-9]{6}$";
                break;
            case 'gm' :
                expr = "^([+]220[ ])?[0-9]{7}$";
                break;
            case 'gn' :
                expr = "^([+]224[ ])?[0-9]{6}$";
                break;
            case 'gp' :
                expr = "^([+]690|0690)[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}$";
                break;
            case 'gq' :
                expr = "^([+]240[ ])?[0-9]{0,1}[ \.\-]?[0-9]{6}$";
                break;
            case 'gr' :
                expr = "^([+]30[ ]|0)[0-9]{1,3}[ \.\-]?[0-9]{5,7}$";
                break;
            case 'gt' :
                expr = "^([+]502[ ])?[0-9]{7,8}$";
                break;
            case 'gu' :
                expr = "^([+]1[ ])?671[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'gw' :
                expr = "^([+]245[ ])?[0-9]{6}$";
                break;
            case 'gy' :
                expr = "^([+]591[ ])?[0-9]{1}[ \.\-]?[0-9]{5}$";
                break;
            case 'hk' :
                expr = "^([+]852[ ])?[0-9]{8}$";
                break;
            case 'hn' :
                expr = "^([+]504[ ])?[0-9]{7}$";
                break;
            case 'hr' :
                expr = "^([+]385[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{5,7}$";
                break;
            case 'ht' :
                expr = "^([+]509[ ])?[0-9]{7}$";
                break;
            case 'hu' :
                expr = "^([+]36[ ]|06)?[0-9]{1,2}[ \.\-]?[0-9]{6,7}$";
                break;
            case 'id' :
                expr = "^([+]62[ ]|0)[0-9]{1,4}[ \.\-]?[0-9]{5,11}$";
                break;
            case 'ie' :
                expr = "^([+]353[ ]|0)[0-9]{1,3}[ \.\-]?[0-9]{5,7}$";
                break;
            case 'il' :
                expr = "^([+]972[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{6,7}$";
                break;
            case 'in' :
                expr = "^([+]91[ ]|0)[0-9]{2,7}[ \.\-]?[0-9]{4,8}$";
                break;
            case 'iq' :
                expr = "^([+]964[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{4,9}$";
                break;
            case 'ir' :
                expr = "^([+]97[ ]|0)[0-9]{3}[ \.\-]?[0-9]{7}$";
                break;

            case 'is' :
                expr = "^([+]354[ ])?[0-9]{7,9}$";
                break;
            case 'it' :
                expr = "^([+]39[ ])?[0-9]{1,3}[ \.\-]?[0-9]{5,8}$";
                break;
            case 'jm' :
                expr = "^([+]1[ ])?876[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'jo' :
                expr = "^([+]962[ ]|0)[0-9]{1}[ \.\-]?[0-9]{7,8}$";
                break;
            case 'jp' :
                expr = "^([+]81[ ]|0)[0-9]{1,5}[ \.\-]?[0-9]{4,8}$";
                break;
            case 'ke' :
                expr = "^([+]254[ ]|0)[0-9]{1,3}[ \.\-]?[0-9]{5,6}$";
                break;
            case 'kg' :
                expr = "^([+]996[ ]|0)[0-9]{3,4}[ \.\-]?[0-9]{5,6}$";
                break;
            case 'kh' :
                expr = "^([+]855[ ]|0)[0-9]{2}[ \.\-]?[0-9]{6}$";
                break;
            case 'ki' :
                expr = "^([+]686[ ])?[0-9]{5}$";
                break;
            case 'km' :
                expr = "^([+]262[ ]|[+]269[ ])?[0-9]{6}$";
                break;
            case 'kn' :
                expr = "^([+]1[ ])?869[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'kp' :
                expr = "^([+]82[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{6,7}$";
                break;
            case 'kr' :
                expr = "^([+]850[ ]|0)?[0-9]{1,2}[ \.\-]?[0-9]{7}$";
                break;
            case 'ky' :
                expr = "^([+]1[ ])?345[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'kw' :
                expr = "^([+]965[ ])?[0-9]{7}$";
                break;
            case 'kz' :
                expr = "^([+]7[ ]|8)[0-9]{3}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{5,6}$";
                break;
            case 'la' :
                expr = "^([+]856[ ]|0)[0-9]{2}[ \.\-]?[0-9]{6}$";
                break;
            case 'lb' :
                expr = "^([+]961[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{6}$";
                break;
            case 'lc' :
                expr = "^([+]1[ ])?758[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'li' :
                expr = "^([+]423[ ])?[0-9]{7}$";
                break;
            case 'lk' :
                expr = "^([+]94[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{4,6}$";
                break;
            case 'lr' :
                expr = "^([+]231[ ])?[0-9]{6}$";
                break;
            case 'ls' :
                expr = "^([+]266[ ])?[0-9]{8}$";
                break;
            case 'lt' :
                expr = "^([+]370[ ]|0|8)[0-9]{1,2}[ \.\-]?[0-9]{5,6}$";
                break;
            case 'lu' :
                expr = "^([+]352[ ])?[0-9]{5,11}$";
                break;
            case 'lv' :
                expr = "^([+]371[ ]|8)?[0-9]{0,2}[ \.\-]?[0-9]{5,7}$";
                break;
            case 'ly' :
                expr = "^([+]218[ ]|0)[0-9]{2,3}[ \.\-]?[0-9]{5,7}$";
                break;
            case 'ma' :
                expr = "^([+]212[ ]|0)[0-9]{1}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}$";
                break;
            case 'mc' :
                expr = "^([+]377[ ])?[0-9]{8,9}$";
                break;
            case 'md' :
                expr = "^([+]373[ ]|0)[0-9]{2,3}[ \.\-]?[0-9]{5,6}$";
                break;
            case 'me' :
                expr = "^([+]382[ ]|0)[0-9]{2,3}[ \.\-]?[0-9]{5,7}$";
                break;
            case 'mg' :
                expr = "^([+]261[ ])?([0-9]{2})?[0-9]{7}$";
                break;
            case 'mh' :
                expr = "^([+]692[ ])?[1]{0,1}[ \.\-]?[0-9]{7}$";
                break;
            case 'mk' :
                expr = "^([+]389[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{5,7}$";
                break;
            case 'ml' :
                expr = "^([+]223[ ])?[0-9]{7}$";
                break;
            case 'mm' :
                expr = "^([+]95[ ]|0)?[0-9]{1,2}[ \.\-]?[0-9]{5,6}$";
                break;
            case 'mn' :
                expr = "^([+]976[ ]|01|02)[0-9]{1,4}[ \.\-]?[0-9]{4,6}$";
                break;
            case 'mo' :
                expr = "^([+]853[ ])?[0-9]{6,7}$";
                break;
            case 'mp' :
                expr = "^([+]1[ ])?670[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'mq' :
                expr = "^([+]696|0696)[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}$";
                break;
            case 'mr' :
                expr = "^([+]222[ ])?[0-9]{7}$";
                break;
            case 'ms' :
                expr = "^([+]1[ ])?664[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'mt' :
                expr = "^([+]356[ ])?[0-9]{2}[ \.\-][0-9]{3}[ \.\-][0-9]{3}$";
                break;
            case 'mu' :
                expr = "^([+]230[ ])?[0-9]{7}$";
                break;
            case 'mv' :
                expr = "^([+]960[ ])?[0-9]{7}$";
                break;
            case 'mw' :
                expr = "^([+]265[ ])?[0-9]{8}$";
                break;
            case 'mx' :
                expr = "^([+]52[ ]|01|02)[0-9]{1,3}[ \.\-]?[0-9]{5,7}$";
                break;
            case 'my' :
                expr = "^([+]60[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{6,8}$";
                break;
            case 'mz' :
                expr = "^([+]258[ ])?[0-9]{1,2}[ \.\-]?[0-9]{5,6}$";
                break;
            case 'na' :
                expr = "^([+]264[ ]|0)[0-9]{2,4}[ \.\-]?[0-9]{2,6}$";
                break;
            case 'nc' :
                expr = "^([+]687[ ])?[0-9]{2}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}$";
                break;
            case 'ne' :
                expr = "^([+]227[ ])?[0-9]{6}$";
                break;
            case 'ng' :
                expr = "^([+]233[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{5,7}$";
                break;
            case 'ni' :
                expr = "^([+]505[ ])?[0-9]{7}$";
                break;
            case 'nl' :
                expr = "^([+]31[ ]|0)[0-9]{2,3}[ \.\-]?[0-9]{6,7}$";
                break;
            case 'np' :
                expr = "^([+]977[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{6,7}$";
                break;
            case 'nr' :
                expr = "^([+]674[ ])?[0-9]{7}$";
                break;
            case 'nu' :
                expr = "^([+]683[ ])?[0-9]{4}$";
                break;
            case 'pa' :
                expr = "^([+]507[ ])?[0-9]{7}$";
                break;
            case 'pf' :
                expr = "^([+]689[ ])?[0-9]{2}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}$";
                break;
            case 'pr' :
                expr = "^([+]1[ ])?[787|939][ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'nf' :
            case 'pn' :
                expr = "^([+]672[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{3,5}$";
                break;
            case 'no' :
                expr = "^([+]47[ ])?[0-9]{8}$";
                break;
            case 'nz' :
                expr = "^([+]64[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{6,8}$";
                break;
            case 'om' :
                expr = "^([+]968[ ])?[0-9]{6,8}$";
                break;
            case 'pe' :
                expr = "^([+]51[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{6,8}$";
                break;
            case 'pg' :
                expr = "^([+]675[ ])?[0-9]{7}$";
                break;
            case 'ph' :
                expr = "^([+]63[ ]|0)[0-9]{1,4}[ \.\-]?[0-9]{5,7}$";
                break;
            case 'pk' :
                expr = "^([+]92[ ]|0)[0-9]{2,5}[ \.\-]?[0-9]{4,7}$";
                break;
            case 'pl' :
                expr = "^([+]48[ ]|0)[0-9]{2}[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}$";
                break;
            case 'pm' :
                expr = "^([+]508[ ])?[0-9]{6}$";
                break;
            case 'ps' :
                expr = "^([+]970[ ]|0)[0-9]{1}[ \.\-]?[0-9]{7}$";
                break;
            case 'pt' :
                expr = "^([+]351[ ])?[0-9]{1,2}[ \.\-]?[0-9]{5,7}$";
                break;
            case 'pw' :
                expr = "^([+]680[ ])?[0-9]{7}$";
                break;
            case 'py' :
                expr = "^([+]595[ ]|0)[0-9]{2,4}[ \.\-]?[0-9]{3,7}$";
                break;
            case 'qa' :
                expr = "^([+]974[ ])?[0-9]{6}$";
                break;
            case 'ro' :
                expr = "^([+]40[ ]|0)[0-9]{1,3}[ \.\-]?[0-9]{5,7}$";
                break;
            case 'ru' :
                expr = "^([+]7[ ]|8)[0-9]{3,5}[ \.\-]?[0-9]{5,7}$";
                break;
            case 'rw' :
                expr = "^([+]250[ ])?[0-9]{5,8}$";
                break;
            case 'sa' :
                expr = "^([+]966[ ]|0)[0-9]{1}[ \.\-]?[0-9]{7}$";
                break;
            case 'sc' :
                expr = "^([+]248[ ])?[0-9]{6}$";
                break;
            case 'sd' :
                expr = "^([+]249[ ]|0)[0-9]{2,3}[ \.\-]?[0-9]{5,6}$";
                break;
            case 'sk' :
                expr = "^([+]421[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{7,8}$";
                break;
            case 're' :
                expr = "^([+]262[ ]692|[+]262[ ]693|0692|0693)[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{3}$";
                break;
            case 'sb' :
                expr = "^([+]677[ ])?[0-9]{5}$";
                break;
            case 'se' :
                expr = "^([+]46[ ]|0)[0-9]{1,3}[ \.\-]?[0-9]{5,8}$";
                break;
            case 'sg' :
                expr = "^([+]65[ ])?[0-9]{7,8}$";
                break;
            case 'sh' :
                expr = "^([+]290[ ])?[0-9]{4}$";
                break;
            case 'si' :
                expr = "^([+]386[ ]|0)[0-9]{1}[ \.\-]?[0-9]{7}$";
                break;
            case 'sl' :
                expr = "^([+]232[ ]|0)[0-9]{2}[ \.\-]?[0-9]{6}$";
                break;
            case 'sm' :
                expr = "^([+]378[ ])?[0-9]{10,12}$";
                break;
            case 'sn' :
                expr = "^([+]221[ ])?[0-9]{7}$";
                break;
            case 'so' :
                expr = "^([+]252[ ])?[0-9]{7}$";
                break;
            case 'sr' :
                expr = "^([+]597[ ])?[0-9]{6}$";
                break;
            case 'st' :
                expr = "^([+]239[ ])?[0-9]{6}$";
                break;
            case 'sv' :
                expr = "^([+]503[ ])?[0-9]{7}$";
                break;
            case 'sy' :
                expr = "^([+]963[ ]|0)[0-9]{2}[ \.\-]?[0-9]{6,7}$";
                break;
            case 'sz' :
                expr = "^([+]268[ ]|0)[0-9]{7}$";
                break;
            case 'tc' :
                expr = "^([+]1[ ])?649[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'td' :
                expr = "^([+]235[ ])?[0-9]{6}$";
                break;
            case 'th' :
                expr = "^([+]66[ ]|0)[0-9]{1,3}[ \.\-]?[0-9]{6,7}$";
                break;
            case 'tg' :
                expr = "^([+]228[ ])?[0-9]{7}$";
                break;
            case 'tj' :
                expr = "^([+]998[ ]|8)[0-9]{2,4}[ \.\-]?[0-9]{5,7}$";
                break;
            case 'tk' :
                expr = "^([+]690[ ])?[0-9]{1}[ \.\-]?[0-9]{3}$";
                break;
            case 'tl' :
                expr = "^([+]670[ ])?[0-9]{7}$";
                break;
            case 'tm' :
                expr = "^([+]993[ ]|8)[0-9]{2,3}[ \.\-]?[0-9]{5,6}$";
                break;
            case 'tn' :
                expr = "^([+]216[ ])?[0-9]{2}[ \.\-]?[0-9]{6}$";
                break;
            case 'to' :
                expr = "^([+]676[ ])?[0-9]{7}$";
                break;
            case 'tr' :
                expr = "^([+]90[ ]|0)[0-9]{3}[ \.\-]?[0-9]{7}$";
                break;
            case 'tt' :
                expr = "^([+]1[ ])?868[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'tv' :
                expr = "^([+]688[ ])?[0-9]{5}$";
                break;
            case 'tw' :
                expr = "^([+]886[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{6,8}$";
                break;
            case 'tz' :
                expr = "^([+]255[ ]|0)[0-9]{2}[ \.\-]?[0-9]{7}$";
                break;
            case 'ua' :
                expr = "^([+]380[ ]|8)[0-9]{2,4}[ \.\-]?[0-9]{5,7}$";
                break;
            case 'ug' :
                expr = "^([+]256[ ]|0)[0-9]{2,3}[ \.\-]?[0-9]{4,7}$";
                break;
            case 'us' :
                expr = "^([+]1[ ])?[0-9]{3}[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'uy' :
                expr = "^([+]598[ ]|0)[0-9]{1,4}[ \.\-]?[0-9]{4,6}$";
                break;
            case 'uz' :
                expr = "^([+]998[ ]|8)[0-9]{2}[ \.\-]?[0-9]{7}$";
                break;
            case 'vc' :
                expr = "^([+]1[ ])?784[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 've' :
                expr = "^([+]58[ ]|0)[0-9]{3}[ \.\-]?[0-9]{7}$";
                break;
            case 'vg' :
                expr = "^([+]1[ ])?284[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'vi' :
                expr = "^([+]1[ ])?340[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{4}$";
                break;
            case 'vn' :
                expr = "^([+]84[ ]|0)[0-9]{1,3}[ \.\-]?[0-9]{5,7}$";
                break;
            case 'vu' :
                expr = "^([+]678[ ])?[0-9]{5}$";
                break;
            case 'wf' :
                expr = "^([+]681[ ])?[0-9]{6}$";
                break;
            case 'ws' :
                expr = "^([+]685[ ])?[0-9]{6,7}$";
                break;
            case 'ye' :
                expr = "^([+]967[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{5,7}$";
                break;
            case 'yt' :
                expr = "^([+]262[ ]639|0639)[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{3}$";
                break;
            case 'za' :
                expr = "^([+]27[ ]|0)[0-9]{2,5}[ \.\-]?[0-9]{3,7}$";
                break;
            case 'zm' :
                expr = "^([+]260[ ]|0)[0-9]{1,2}[ \.\-]?[0-9]{5,6}$";
                break;
            case 'zw' :
                expr = "^([+]263[ ]|0)[0-9]{1,4}[ \.\-]?[0-9]{3,8}$";
                break;
            default :
                expr = "^([+][0-9]{2,3}[ ])?[0-9]{6,11}$";
                break;
        }
    }
    else {
        expr = "^([+][0-9]{2,3}[ ])?[0-9]{6,11}$";
    }
    return expr;
}

// Retourne la string regexp 'sécurité sociale' en fonction du code pays
// Si pas de pays, rien
function GiveExpr_secu(pays) {
    var expr = '';

    if (pays) {
        pays = pays.toLowerCase();

        switch (pays) {
            case 'fr' :
                expr = "^[1-2]{1}[ ][0-9]{2}[ ][0-9]{2}[ ][0-9]{1}[A-B0-9]{1}[ ][0-9]{3}[ ][0-9]{3}[ ][0-9]{2}$";
                break;
            case 'us' :
                expr = "^[0-9]{3}[ \-][0-9]{2}[ \-][0-9]{2}[ \-][0-9]{4}$";
                break;
            default :
                break;
        }
    }

    return expr;
}

// Retourne la string regexp 'code postal' en fonction du code pays
// Si pas de pays, rien
function GiveExpr_cp(pays) {
    var expr = '';

    if (pays) {
        pays = pays.toLowerCase();
        switch (pays) {
            case 'ca' :
                expr = "^[a-zA-Z]{1}[0-9]{1}[a-zA-Z]{1}[ \-][0-9]{1}[a-zA-Z]{1}[0-9]{1}$";
                break;
            case 'au' :
                expr = "^[2-7]{1}[0-9]{3}$";
                break;
            case 'be' :
            case 'cy' :
            case 'hu' :
                expr = "^[0-9]{4}$";
                break;
            case 'br' :
                expr = "^[0-9]{5}[\-][0-9]{3}$";
                break;
            case 'cn' :
            case 'ro' :
            case 'ru' :
            case 'sg' :
            case 'in' :
                expr = "^[0-9]{6}$";
                break;
            case 'jp' :
                expr = "^[0-9]{7}$";
                break;
            case 'cz' :
            case 'sk' :
                expr = "^[0-9]{3}[ ][0-9]{2}$";
                break;
            case 'dk' :
                expr = "^(DK-)?[0-9]{4}$";
                break;
            case 'md' :
                expr = "^MD-[0-9]{4}$";
                break;
            case 'fo' :
                expr = "^[0-9]{3}$";
                break;
            case 'gl' :
            case 'no' :
            case 'nz' :
            case 'ph' :
            case 'za' :
                expr = "^[0-9]{4}$";
                break;
            case 'ch' :
            case 'cs' :
            case 'de' :
            case 'dz' :
            case 'es' :
            case 'fi' :
            case 'fr' :
            case 'il' :
            case 'it' :
            case 'lk' :
            case 'ma' :
            case 'my' :
            case 'tr' :
                expr = "^[0-9]{5}$";
                break;
            case 'nl' :
                expr = "^[0-9]{4}[ ][a-zA-Z]{2}([ ][0-9]{2})?$";
                break;
            case 'pl' :
            case 'kr' :
                expr = "^[0-9]{3}\-[0-9]{3}$";
                break;
            case 'gb' :
                expr = "^[a-zA-Z]{1}[0-9a-zA-Z]{1,3}[ ][0-9]{1}[a-zA-Z]{2}$";
                // ^(GIR ?0AA|(?:[A-PR-UWYZ](?:\d|\d{2}|[A-HK-Y]\d|[A-HK-Y]\d\d|\d[A-HJKSTUW]|[A-HK-Y]\d[ABEHMNPRV-Y])) ?\d[ABD-HJLNP-UW-Z]{2})$
                break;
            /*
             case 'nl' :
             expr = "^[1-9][0-9]{3}[ ]?[a-zA-Z]{2}$";
             break;
             */
            case 'se' :
                expr = "^(s-|S-){0,1}[0-9]{3}[ ][0-9]{2}$";
                break;
            case 'tw' :
                expr = "^[0-9]{3}([0-9]{2})?$";
                break;
            case 'us' :
                expr = "^[0-9]{5}(\-[0-9]{4})?$";
                break;
            default :
                break;
        }
    }
    return expr;
}

// Retourne la string regexp 'siret' en fonction du code pays
// Si pas de pays, rien
function GiveExpr_siret(pays) {
    var expr = '';

    if (pays) {
        pays = pays.toLowerCase();

        switch (pays) {
            case 'fr' :
            case 'gf' :
            case 'gp' :
            case 'mq' :
            case 're' :
                expr = "^[0-9]{3}[ ]?[0-9]{3}[ ]?[0-9]{3}[ ]?[0-9]{5}$";
                break;
            default :
                break;
        }
    }

    return expr;
}

// Retourne la string regexp 'siren' en fonction du code pays
// Si pas de pays, rien
function GiveExpr_siren(pays) {
    var expr = '';

    if (pays) {
        pays = pays.toLowerCase();

        switch (pays) {
            case 'fr' :
            case 'gf' :
            case 'gp' :
            case 'mq' :
            case 're' :
                expr = "^[0-9]{3}[ ]?[0-9]{3}[ ]?[0-9]{3}$";
                break;
            default :
                break;
        }
    }

    return expr;
}

// Retourne la string regexp 'rib' en fonction du code pays
// Si pas de pays, rien
function GiveExpr_rib(pays) {
    var expr = '';

    if (pays) {
        pays = pays.toLowerCase();

        switch (pays) {
            case 'fr' :
                expr = "^[0-9]{5}[ ][0-9]{5}[ ][a-z0-9]{11}[ ][0-9]{2}$";
                break;
            default :
                break;
        }
    }

    return expr;
}

// Retourne la string regexp 'iban' en fonction du code pays
// Si pas de pays, rien
function GiveExpr_iban(pays) {
    var expr = '';

    if (pays) {
        pays = pays.toLowerCase();

        switch (pays) {
            case 'no' :
                expr = "^" + pays.toUpperCase() + "[0-9]{2}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{3}|" + pays.toUpperCase() + "[0-9]{13}$";
                break;
            case 'be' :
                expr = "^" + pays.toUpperCase() + "[0-9]{2}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{4}|" + pays.toUpperCase() + "[0-9]{14}$";
                break;
            case 'dk' :
            case 'fi' :
            case 'fo' :
                expr = "^" + pays.toUpperCase() + "[0-9]{2}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{2}|" + pays.toUpperCase() + "[0-9]{16}$";
                break;
            case 'nl' :
                expr = "^" + pays.toUpperCase() + "[0-9]{2}[ ][0-9,A-Z]{4}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{2}|" + pays.toUpperCase() + "[0-9]{2}[0-9,A-Z]{4}[0-9]{10}$";
                break;
            case 'mk' :
            case 'si' :
                expr = "^" + pays.toUpperCase() + "[0-9]{2}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{3}|" + pays.toUpperCase() + "[0-9]{17}$";
                break;
            case 'at' :
            case 'ba' :
            case 'ee' :
            case 'lt' :
            case 'lu' :
                expr = "^" + pays.toUpperCase() + "[0-9]{2}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{4}|" + pays.toUpperCase() + "[0-9]{18}$";
                break;
            case 'ch' :
            case 'cs' :
            case 'de' :
            case 'hr' :
            case 'li' :
            case 'lv' :
                expr = "^" + pays.toUpperCase() + "[0-9]{2}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{1}|" + pays.toUpperCase() + "[0-9]{19}$";
                break;
            case 'bg' :
            case 'me' :
                expr = "^" + pays.toUpperCase() + "[0-9]{2}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{2}|" + pays.toUpperCase() + "[0-9]{20}$";
                break;
            case 'gb' :
                expr = "^" + pays.toUpperCase() + "[0-9]{2}[ ][0-9,A-Z]{4}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{2}|" + pays.toUpperCase() + "[0-9]{2}[0-9,A-Z]{4}[0-9]{14}$";
                break;
            case 'gi' :
            case 'il' :
            case 'rs' :
                expr = "^" + pays.toUpperCase() + "[0-9]{2}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{3}|" + pays.toUpperCase() + "[0-9]{21}$";
                break;
            case 'ie' :
                expr = "^" + pays.toUpperCase() + "[0-9]{2}[ ][A-Z]{4}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{3}|" + pays.toUpperCase() + "[0-9]{2}[A-Z]{4}[0-9]{15}$";
                break;
            case 'ad' :
            case 'es' :
            case 'cz' :
            case 'se' :
            case 'sk' :
            case 'tn' :
                expr = "^" + pays.toUpperCase() + "[0-9]{2}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{4}|" + pays.toUpperCase() + "[0-9]{22}$";
                break;
            case 'ro' :
                expr = "^" + pays.toUpperCase() + "[0-9]{2}[ ][0-9,A-Z]{4}[ ][0-9,A-Z]{4}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{4}|" + pays.toUpperCase() + "[0-9]{2}[0-9,A-Z]{8}[0-9]{12}$";
                break;
            case 'pt' :
                expr = "^" + pays.toUpperCase() + "[0-9]{2}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{1}|" + pays.toUpperCase() + "[0-9]{23}$";
                break;
            case 'is' :
            case 'tr' :
                expr = "^" + pays.toUpperCase() + "[0-9]{2}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{2}|" + pays.toUpperCase() + "[0-9]{24}$";
                break;
            case 'fr' :
            case 'gf' :
            case 'gp' :
            case 'gr' :
            case 'it' :
            case 'mq' :
            case 'nc' :
            case 'pm' :
            case 're' :
            case 'tf' :
            case 'wf' :
            case 'yt' :
                expr = "^" + pays.toUpperCase() + "[0-9]{2}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{3}|" + pays.toUpperCase() + "[0-9]{25}$";
                break;
            case 'sm' :
                expr = "^" + pays.toUpperCase() + "[0-9]{2}[ ][0-9,A-Z]{4}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{3}|" + pays.toUpperCase() + "[0-9]{2}[0-9,A-Z]{4}[0-9]{19}$";
                break;
            case 'mc' :
                expr = "^" + pays.toUpperCase() + "[0-9]{2}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9,A-Z,a-z]{3}|" + pays.toUpperCase() + "[0-9]{22}[0-9,A-Z,a-z]{3}$";
                break;
            case 'hu' :
            case 'cy' :
            case 'pl' :
                expr = "^" + pays.toUpperCase() + "[0-9]{2}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{4}|" + pays.toUpperCase() + "[0-9]{26}$";
                break;
            case 'mu' :
                expr = "^" + pays.toUpperCase() + "[0-9]{2}[ ][A-Z]{4}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{4}[ ][A-Z,0-9]{4}[ ][0-9,A-Z]{2}|" + pays.toUpperCase() + "[0-9]{2}[A-Z]{4}[0-9]{16}[0-9,A-Z]{6}$";
                break;
            case 'mt' :
                expr = "^" + pays.toUpperCase() + "[0-9]{2}[ ][A-Z]{4}[ ][0-9]{4}[ ][0-9]{4}[ ][0-9]{4}[ ][A-Z,0-9]{4}[ ][A-Z,0-9]{4}[ ][0-9,A-Z]{3}|" + pays.toUpperCase() + "[0-9]{2}[A-Z]{4}[0-9]{12}[0-9,A-Z]{11}$";
                break;
            default :
                expr = "^[A-Z]{2}[0-9]{2}[0-9]{30}$";
                break;
        }
    }

    return expr;
}

// Retourne la string regexp 'naf' en fonction du code pays
// Si pas de pays, rien
function GiveExpr_naf(pays) {
    var expr = '';

    if (pays) {
        pays = pays.toLowerCase();

        switch (pays) {
            case 'fr' :
            case 'gf' :
            case 'gp' :
            case 'mq' :
            case 're' :
                expr = "^[0-9]{3,4}[a-z,A-Z]{1}$";
                break;
            default :
                break;
        }
    }

    return expr;
}

// Retourne la string regexp 'tva' en fonction du code pays
// Si pas de pays, rien
function GiveExpr_tva(pays) {
    var expr = '';

    if (pays) {
        pays = pays.toLowerCase();

        switch (pays) {
            case 'at' :
                expr = "^AT[u,U]{1}[0-9]{8}$";
                break;
            case 'be' :
                expr = "^BE[0-9]{10}$";
                break;
            case 'de' :
            case 'pt' :
                expr = "^" + pays.toUpperCase() + "[0-9]{9}$";
                break;
            case 'cy' :
            case 'ee' :
            case 'es' :
                expr = "^" + pays.toUpperCase() + "[0-9,A-Z]{9}$";
                break;
            case 'cz' :
                expr = "^CZ[0-9,A-Z]{8,10}$";
                break;
            case 'bg' :
                expr = "^BG[0-9]{9,10}$";
                break;
            case 'dk' :
            case 'fi' :
            case 'lu' :
            case 'si' :
                expr = "^" + pays.toUpperCase() + "[0-9]{8}$";
                break;
            case 'fr' :
                expr = "^FR[a-z,A-Z,0-9]{2}[0-9]{9}$";
                break;
            case 'gb' :
                expr = "^GB([0-9]{9}|[0-9]{12}|[a-z,A-Z,0-9]{2}[0-9]{3})$";
                break;
            case 'gr' :
                expr = "^(EL|GR)[0-9]{9}$";
                break;
            case 'hu' :
            case 'mt' :
                expr = "^" + pays.toUpperCase() + "[0-9,A-Z]{8}$";
                break;
            case 'ie' :
                expr = "^IE[a-z,A-Z,0-9]{8}$";
                break;
            case 'it' :
                expr = "^IT[0-9]{11}$";
                break;
            case 'lv' :
                expr = "^LV[A-Z,0-9]{11}$";
                break;
            case 'lt' :
                expr = "^LV([A-Z,0-9]{9}|[A-Z,0-9]{12})$";
                break;
            case 'nl' :
                expr = "^NL[0-9]{9}[A-Z]{1}[0-9]{2}$";
                break;
            case 'pl' :
                expr = "^PL[A-Z,0-9]{10}$";
                break;
            case 'sk' :
                expr = "^CZ[0-9,A-Z]{9,10}$";
                break;
            case 'se' :
                expr = "^SE[0-9]{12}$";
                break;
            default :
                break;
        }
    }

    return expr;
}

// Retourne la string regexp 'nf' en fonction du code pays
// Si pas de pays, rien
function GiveExpr_nf(pays) {
    var expr = '';

    if (pays) {
        pays = pays.toLowerCase();

        switch (pays) {
            case 'fr' :
                expr = "^[0-9]{2}[ ][0-9]{2}[ ][0-9]{3}[ ][0-9]{3}[ ][0-9]{3}[ ][A-Z]{1}$";
                break;
            default :
                break;
        }
    }

    return expr;
}

// Retourne la string regexp 'insee' en fonction du code pays
// Si pas de pays, rien
function GiveExpr_insee(pays) {
    var expr = '';

    if (pays) {
        pays = pays.toLowerCase();

        switch (pays) {
            case 'fr' :
                expr = "^[0-9]{2}[ ][0-9]{2}[ ][0-9]{3}[ ][0-9]{3}[ ][0-9]{3}[ ][A-Z]{1}$";
                break;
            default :
                break;
        }
    }

    return expr;
}

// Retourne la string regexp 'immatriculation' en fonction du code pays
// Si pas de pays, rien
function GiveExpr_imt(pays) {
    var expr = '';

    if (pays) {
        pays = pays.toLowerCase();

        switch (pays) {
            case 'ad' :
                expr = "^([A-Z]{1}[ ][0-9]{4}|[0-9]{5})$";
                break;
            case 'al' :
                expr = "^[A-Z]{2}[ ][0-9]{4}[ ][A-Z]{1}$";
                break;
            case 'au' :
                expr = "^([A-Z]{1}[ ][0-9]{4}|[0-9]{5})$";
                break;
            case 'de' :
                expr = "^([A-Z]{1,3}[ ][A-Z]{1,3}[ ][0-9]{1,4}|[A-Z]{1}[ ][0-9]{1,4}[ ][A-Z]{1}|[A-Z]{1,3}[ ][0-9]{1,4})$";
                break;
            case 'fr' :
                expr = "^[0-9]{1,4}[ ][A-Z]{1,3}[ ][0-9]{2}$";
                break;
            case 'in' :
                expr = "^([A-Z|a-z]{2}\s{1}\d{2}\s{1}[A-Z|a-z]{1,2}\s{1}\d{1,4})?([A-Z|a-z]{3}\s{1}\d{1,4})?$";
                break;
            default :
                break;
        }
    }

    return expr;
}

// Valide un champ texte sur le format donné
function valide_champ(pays, valeur, format, masque, vmn, vmx, pwq) {
    var swformat;
    var tab_ip;
    var n;
    var tstip;
    var val1;
    var val2;
    var ok;
    var errno = -1;
    var expr = '';
    var strexpr = '';
    var tab_format = [];
    var tab_siren = '';
    var siren = '';
    var tab_siret = '';
    var siret = '';


    valeur = RLtrim(valeur);

    // On ne teste que si le champ contient quelque chose
    if (ChampEstVide(valeur) == false) {
        swformat = true;

        // Vérification si format de type 'tel_codepays'
        if (format.indexOf("tel_") > -1) {
            swformat = false;
            tab_format = format.split("_");
            if (tab_format.length != 2) {
                errno = 12;
            }
            else {
                strexpr = GiveExpr_tel(tab_format[1]);
                if (strexpr != '') {
                    expr = new RegExp(strexpr, "gi");
                    if (!expr.test(valeur)) {
                        errno = 1;
                    }
                }
                else {
                    errno = 12;
                }
            }
        }

        // Vérification si format de type 'telp_codepays'
        if (format.indexOf("telp_") > -1) {
            swformat = false;
            tab_format = format.split("_");
            if (tab_format.length != 2) {
                errno = 12;
            }
            else {
                strexpr = GiveExpr_telp(tab_format[1]);
                if (strexpr != '') {
                    expr = new RegExp(strexpr, "gi");
                    if (!expr.test(valeur)) {
                        errno = 1;
                    }
                }
                else {
                    errno = 12;
                }
            }
        }

        // Vérification si format de type 'secu_codepays'
        if (format.indexOf("secu_") > -1) {
            swformat = false;
            tab_format = format.split("_");
            if (tab_format.length != 2) {
                errno = 12;
            }
            else {
                strexpr = GiveExpr_secu(tab_format[1]);
                if (strexpr != '') {
                    expr = new RegExp(strexpr, "gi");
                    if (!expr.test(valeur)) {
                        errno = 1;
                    }
                    else {
                        if (IsINSEE(valeur, tab_format[1]) == false) {
                            errno = 1;
                        }
                    }
                }
                else {
                    errno = 12;
                }
            }
        }

        // Vérification si format de type 'cp_codepays'
        if (format.indexOf("cp_") > -1) {
            swformat = false;
            tab_format = format.split("_");
            if (tab_format.length != 2) {
                errno = 12;
            }
            else {
                strexpr = GiveExpr_cp(tab_format[1]);
                if (strexpr != '') {
                    expr = new RegExp(strexpr, "gi");
                    if (!expr.test(valeur)) {
                        errno = 1;
                    }
                }
                else {
                    errno = 12;
                }
            }
        }

        // Vérification si format de type 'naf_codepays'
        if (format.indexOf("naf_") > -1) {
            swformat = false;
            tab_format = format.split("_");
            if (tab_format.length != 2) {
                errno = 12;
            }
            else {
                strexpr = GiveExpr_naf(tab_format[1]);
                if (strexpr != '') {
                    expr = new RegExp(strexpr, "gi");
                    if (!expr.test(valeur)) {
                        errno = 1;
                    }
                }
                else {
                    errno = 12;
                }
            }
        }

        // Vérification si format de type 'nf_codepays'
        if (format.indexOf("nf_") > -1) {
            swformat = false;
            tab_format = format.split("_");
            if (tab_format.length != 2) {
                errno = 12;
            }
            else {
                strexpr = GiveExpr_nf(tab_format[1]);
                if (strexpr != '') {
                    expr = new RegExp(strexpr, "gi");
                    if (!expr.test(valeur)) {
                        errno = 1;
                    }
                }
                else {
                    errno = 12;
                }
            }
        }

        // Vérification si format de type 'tva_codepays'
        if (format.indexOf("tva_") > -1) {
            swformat = false;
            tab_format = format.split("_");
            if (tab_format.length != 2) {
                errno = 12;
            }
            else {
                strexpr = GiveExpr_tva(tab_format[1]);
                if (strexpr != '') {
                    expr = new RegExp(strexpr, "gi");
                    if (!expr.test(valeur)) {
                        errno = 1;
                    }
                    else {
                        if (IsTVA(valeur, tab_format[1]) == false) {
                            errno = 1;
                        }
                    }
                }
                else {
                    errno = 12;
                }
            }
        }

        // Vérification si format de type 'siren_codepays'
        if (format.indexOf("siren_") > -1) {
            swformat = false;
            tab_format = format.split("_");
            if (tab_format.length != 2) {
                errno = 12;
            }
            else {
                strexpr = GiveExpr_siren(tab_format[1]);
                if (strexpr != '') {
                    expr = new RegExp(strexpr, "gi");
                    if (!expr.test(valeur)) {
                        errno = 1;
                    }
                    else {
                        // On "nettoie" la chaîne puis on vérifie
                        tab_siren = valeur.split(" ");
                        siren = RLtrim(tab_siren.join(""));
                        if (IsSiren(siren, tab_format[1]) == false) {
                            errno = 1;
                        }
                    }
                }
                else {
                    errno = 12;
                }
            }
        }

        // Vérification si format de type 'siret_codepays'
        if (format.indexOf("siret_") > -1) {
            swformat = false;
            tab_format = format.split("_");
            if (tab_format.length != 2) {
                errno = 12;
            }
            else {
                strexpr = GiveExpr_siret(tab_format[1]);
                if (strexpr != '') {
                    expr = new RegExp(strexpr, "gi");
                    if (!expr.test(valeur)) {
                        errno = 1;
                    }
                    else {
                        // On "nettoie" la chaîne puis on vérifie
                        tab_siret = valeur.split(" ");
                        siret = RLtrim(tab_siret.join(""));
                        if (IsSiret(siret, tab_format[1]) == false) {
                            errno = 1;
                        }
                    }
                }
                else {
                    errno = 12;
                }
            }
        }

        // Vérification si format de type 'rib_codepays'
        if (format.indexOf("rib_") > -1) {
            swformat = false;
            tab_format = format.split("_");
            if (tab_format.length != 2) {
                errno = 12;
            }
            else {
                strexpr = GiveExpr_rib(tab_format[1]);
                if (strexpr != '') {
                    expr = new RegExp(strexpr, "gi");
                    if (!expr.test(valeur)) {
                        errno = 1;
                    }
                    else {
                        if (IsRIB(valeur, tab_format[1]) == false) {
                            errno = 1;
                        }
                    }
                }
                else {
                    errno = 12;
                }
            }
        }

        // Vérification si format de type 'iban_codepays'
        if (format.indexOf("iban_") > -1) {
            swformat = false;
            tab_format = format.split("_");
            if (tab_format.length != 2) {
                errno = 12;
            }
            else {
                strexpr = GiveExpr_iban(tab_format[1]);
                if (strexpr != '') {
                    expr = new RegExp(strexpr, "gi");
                    if (!expr.test(valeur)) {
                        errno = 1;
                    }
                    else {
                        if (IsIBAN(valeur) == false) {
                            errno = 1;
                        }
                    }
                }
                else {
                    errno = 12;
                }
            }
        }

        // Vérification si format de type 'imt_codepays'
        if (format.indexOf("imt_") > -1) {
            swformat = false;
            tab_format = format.split("_");
            if (tab_format.length != 2) {
                errno = 12;
            }
            else {
                strexpr = GiveExpr_imt(tab_format[1]);
                if (strexpr != '') {
                    expr = new RegExp(strexpr, "gi");
                    if (!expr.test(valeur)) {
                        errno = 1;
                    }
                }
                else {
                    errno = 12;
                }
            }
        }

        if (swformat == true) {
            switch (format) {
                // Date
                case 'date':
                    if (IsDate(valeur, masque) == false) {
                        errno = 1;
                    }
                    else {
                        if (DateInMinMax(valeur, vmn, vmx, masque) == false) {
                            errno = 4;
                        }
                    }
                    break;

                // Email
                case 'mail':
                    expr = new RegExp("^[a-z0-9_\-]+(\.[a-z0-9_\-]+)*@[a-z0-9\-]*[a-z0-9](\.[a-z0-9\-]*[a-z0-9])*[\.][a-z]{2,4}$", "gi");
                    if (!expr.test(valeur)) {
                        errno = 1;
                    }
                    break;

                // Téléphone en fonction du pays
                case 'tel':
                    strexpr = GiveExpr_tel(pays);
                    if (strexpr != '') {
                        expr = new RegExp(strexpr, "gi");
                        if (!expr.test(valeur)) {
                            errno = 1;
                        }
                    }
                    else {
                        errno = 13;
                    }
                    break;

                // Téléphone portable en fonction du pays
                case 'telp':
                    strexpr = GiveExpr_telp(pays);
                    if (strexpr != '') {
                        expr = new RegExp(strexpr, "gi");
                        if (!expr.test(valeur)) {
                            errno = 1;
                        }
                    }
                    else {
                        errno = 13;
                    }
                    break;

                // Numéro de sécurité sociale en fonction du pays
                case 'secu':
                    strexpr = GiveExpr_secu(pays);
                    if (strexpr != '') {
                        expr = new RegExp(strexpr, "gi");
                        if (!expr.test(valeur)) {
                            errno = 1;
                        }
                    }
                    else {
                        errno = 13;
                    }
                    break;

                // code postal en fonction du pays
                case 'cp':
                    strexpr = GiveExpr_cp(pays);
                    if (strexpr != '') {
                        expr = new RegExp(strexpr, "gi");
                        if (!expr.test(valeur)) {
                            errno = 1;
                        }
                    }
                    else {
                        errno = 13;
                    }
                    break;

                // naf en fonction du pays
                case 'naf':
                    strexpr = GiveExpr_naf(pays);
                    if (strexpr != '') {
                        expr = new RegExp(strexpr, "gi");
                        if (!expr.test(valeur)) {
                            errno = 1;
                        }
                    }
                    else {
                        errno = 13;
                    }
                    break;

                // numéro fiscal en fonction du pays
                case 'nf':
                    strexpr = GiveExpr_nf(pays);
                    if (strexpr != '') {
                        expr = new RegExp(strexpr, "gi");
                        if (!expr.test(valeur)) {
                            errno = 1;
                        }
                    }
                    else {
                        errno = 13;
                    }
                    break;

                // SIREN en fonction du code pays
                case 'siren':
                    strexpr = GiveExpr_siren(pays);
                    if (strexpr != '') {
                        expr = new RegExp(strexpr, "gi");
                        if (!expr.test(valeur)) {
                            errno = 1;
                        }
                        else {
                            // On "nettoie" la chaîne puis on vérifie
                            tab_siren = valeur.split(" ");
                            siren = RLtrim(tab_siren.join(""));
                            if (IsSiren(siren, pays) == false) {
                                errno = 1;
                            }
                        }
                    }
                    else {
                        errno = 13;
                    }
                    break;

                // SIRET en fonction du code pays
                case 'siret':
                    strexpr = GiveExpr_siret(pays);
                    if (strexpr != '') {
                        expr = new RegExp(strexpr, "gi");
                        if (!expr.test(valeur)) {
                            errno = 1;
                        }
                        else {
                            // On "nettoie" la chaîne puis on vérifie
                            tab_siret = valeur.split(" ");
                            siret = RLtrim(tab_siret.join(""));
                            if (IsSiret(siret, pays) == false) {
                                errno = 1;
                            }
                        }
                    }
                    else {
                        errno = 13;
                    }
                    break;

                // RIB en fonction du code pays
                case 'rib':
                    strexpr = GiveExpr_rib(pays);
                    if (strexpr != '') {
                        expr = new RegExp(strexpr, "gi");
                        if (!expr.test(valeur)) {
                            errno = 1;
                        }
                        else {
                            if (IsRIB(valeur, pays) == false) {
                                errno = 1;
                            }
                        }
                    }
                    else {
                        errno = 13;
                    }
                    break;

                // IBAN en fonction du code pays
                case 'iban':
                    strexpr = GiveExpr_iban(pays);
                    if (strexpr != '') {
                        expr = new RegExp(strexpr, "gi");
                        if (!expr.test(valeur)) {
                            errno = 1;
                        }
                        else {
                            if (IsIBAN(valeur) == false) {
                                errno = 1;
                            }
                        }
                    }
                    else {
                        errno = 13;
                    }
                    break;

                // EAN-8
                case 'ean8':
                    if (IsEAN8(valeur) == false) {
                        errno = 1;
                    }
                    break;

                // EAN-13
                case 'ean13':
                    if (IsEAN13(valeur) == false) {
                        errno = 1;
                    }
                    break;

                // GTIN-8
                case 'gtin8':
                    if (IsGTIN8(valeur) == false) {
                        errno = 1;
                    }
                    break;

                // GTIN-12
                case 'gtin12':
                    if (IsGTIN12(valeur) == false) {
                        errno = 1;
                    }
                    break;

                // GTIN-13
                case 'gtin13':
                    if (IsGTIN13(valeur) == false) {
                        errno = 1;
                    }
                    break;

                // GTIN-14
                case 'gtin14':
                    if (IsGTIN14(valeur) == false) {
                        errno = 1;
                    }
                    break;

                // ISBN-10
                case 'isbn10':
                    if (IsISBN10(valeur) == false) {
                        errno = 1;
                    }
                    break;

                // ISBN-13
                case 'isbn13':
                    if (IsISBN13(valeur) == false) {
                        errno = 1;
                    }
                    break;

                // ISSN
                case 'issn':
                    if (IsISSN(valeur) == false) {
                        errno = 1;
                    }
                    break;

                // SSCC
                case 'sscc':
                    if (IsSSCC(valeur) == false) {
                        errno = 1;
                    }
                    break;

                // TVA en fonction du code pays
                case 'tva':
                    strexpr = GiveExpr_tva(pays);
                    if (strexpr != '') {
                        expr = new RegExp(strexpr, "gi");
                        if (!expr.test(valeur)) {
                            errno = 1;
                        }
                        else {
                            if (IsTVA(valeur, pays) == false) {
                                errno = 1;
                            }
                        }
                    }
                    else {
                        errno = 13;
                    }
                    break;

                // Immatriculation en fonction du code pays
                case 'imt':
                    strexpr = GiveExpr_imt(pays);
                    if (strexpr != '') {
                        expr = new RegExp(strexpr, "gi");
                        if (!expr.test(valeur)) {
                            errno = 1;
                        }
                    }
                    else {
                        errno = 13;
                    }
                    break;

                // Adresse IP V4
                case 'ip':
                    expr = new RegExp("^[0-9]{1,3}[\.][0-9]{1,3}[\.][0-9]{1,3}[\.][0-9]{1,3}$", "gi");
                    if (!expr.test(valeur)) {
                        errno = 1;
                    }
                    else // On vérifie la validité de l'adresse IP saisie
                    {
                        tab_ip = valeur.split('.');
                        n = 0;
                        tstip = true;
                        while ((n < 4) && (tstip == true)) {
                            if (parseInt(tab_ip[n]) > 255) {
                                tstip = false;
                            }
                            n++;
                        }
                        if (tstip == false) {
                            errno = 1;
                        }
                    }
                    break;

                // Adresse IP V6
                case 'ip6':
                    expr = new RegExp("^(^(([0-9A-F]{1,4}(((:[0-9A-F]{1,4}){5}::[0-9A-F]{1,4})|((:[0-9A-F]{1,4}){4}::[0-9A-F]{1,4}(:[0-9A-F]{1,4}){0,1})|((:[0-9A-F]{1,4}){3}::[0-9A-F]{1,4}(:[0-9A-F]{1,4}){0,2})|((:[0-9A-F]{1,4}){2}::[0-9A-F]{1,4}(:[0-9A-F]{1,4}){0,3})|(:[0-9A-F]{1,4}::[0-9A-F]{1,4}(:[0-9A-F]{1,4}){0,4})|(::[0-9A-F]{1,4}(:[0-9A-F]{1,4}){0,5})|(:[0-9A-F]{1,4}){7}))$|^(::[0-9A-F]{1,4}(:[0-9A-F]{1,4}){0,6})$)|^::$)|^((([0-9A-F]{1,4}(((:[0-9A-F]{1,4}){3}::([0-9A-F]{1,4}){1})|((:[0-9A-F]{1,4}){2}::[0-9A-F]{1,4}(:[0-9A-F]{1,4}){0,1})|((:[0-9A-F]{1,4}){1}::[0-9A-F]{1,4}(:[0-9A-F]{1,4}){0,2})|(::[0-9A-F]{1,4}(:[0-9A-F]{1,4}){0,3})|((:[0-9A-F]{1,4}){0,5})))|([:]{2}[0-9A-F]{1,4}(:[0-9A-F]{1,4}){0,4})):|::)((25[0-5]|2[0-4][0-9]|[0-1]?[0-9]{0,2})\.){3}(25[0-5]|2[0-4][0-9]|[0-1]?[0-9]{0,2})$$", "gi");
                    if (!expr.test(valeur)) {
                        errno = 1;
                    }
                    break;

                // Adresse MAC
                case 'mac':
                    expr = new RegExp("^([0-9a-fA-F][0-9a-fA-F]:){5}([0-9a-fA-F][0-9a-fA-F])$|^([0-9a-fA-F][0-9a-fA-F]-){5}([0-9a-fA-F][0-9a-fA-F])$", "gi");
                    if (!expr.test(valeur)) {
                        errno = 1;
                    }
                    break;

                // Hexadécimal
                case 'hexa':
                    if (IsHexa(valeur) == false) {
                        errno = 1;
                    }
                    else {
                        if (ValInMinMax(parseInt(valeur), vmn, vmx) == false) {
                            errno = 4;
                        }
                    }
                    break;

                // Hexadécimal couleur
                case 'hexacol':
                    if (IsHexaCol(valeur) == false) {
                        errno = 1;
                    }
                    else {
                        if (ValInMinMax(parseInt(valeur), vmn, vmx) == false) {
                            errno = 4;
                        }
                    }
                    break;

                // Non signé
                case 'unsigned':
                    if (IsUnsigned(valeur) == false) {
                        errno = 1;
                    }
                    else {
                        if (ValInMinMax(parseInt(valeur), vmn, vmx) == false) {
                            errno = 4;
                        }
                    }
                    break;

                // Nombre entier
                case 'entier':
                    if (IsInteger(valeur) == false) {
                        errno = 1;
                    }
                    else {
                        if (ValInMinMax(parseInt(valeur), vmn, vmx) == false) {
                            errno = 4;
                        }
                    }
                    break;

                // Nombre réel
                case 'reel':
                    if (IsReal(valeur) == false) {
                        errno = 1;
                    }
                    else {
                        if (ValInMinMax(parseFloat(valeur), vmn, vmx) == false) {
                            errno = 4;
                        }
                    }
                    break;

                // Nombre réel non signé
                case 'reel_ns':
                    if (IsRealUnsigned(valeur) == false) {
                        errno = 1;
                    }
                    else {
                        if (ValInMinMax(parseFloat(valeur), vmn, vmx) == false) {
                            errno = 4;
                        }
                    }
                    break;

                // Tout texte
                case 'txt':
                    break;

                // Alphabétique seulement
                case 'alpha':
                    expr = new RegExp("^[a-z]*$", "gi");
                    if (!expr.test(valeur)) {
                        errno = 1;
                    }
                    break;

                // Alphabétique seulement (minuscules)
                case 'alphamin':
                    expr = new RegExp("^[a-z]*$", "g");
                    if (!expr.test(valeur)) {
                        errno = 1;
                    }
                    break;

                // Alphabétique seulement (majuscules)
                case 'alphamaj':
                    expr = new RegExp("^[A-Z]*$", "g");
                    if (!expr.test(valeur)) {
                        errno = 1;
                    }
                    break;

                // Alphanumérique
                case 'alphanum':
                    expr = new RegExp("^[a-z0-9]*$", "gi");
                    if (!expr.test(valeur)) {
                        errno = 1;
                    }
                    break;

                // Alphanumérique (minuscules seulement)
                case 'alphanummin':
                    expr = new RegExp("^[a-z0-9]*$", "g");
                    if (!expr.test(valeur)) {
                        errno = 1;
                    }
                    break;

                // Alphanumérique (majuscules seulement)
                case 'alphanummaj':
                    expr = new RegExp("^[A-Z0-9]*$", "g");
                    if (!expr.test(valeur)) {
                        errno = 1;
                    }
                    break;

                // Préfixe
                case 'extens':
                    if ((valeur.length >= 3) && (valeur.length <= 4)) {
                        val1 = valeur.charAt(0);
                        if (val1 == '.') {
                            val2 = valeur.substr(1, valeur.length - 1);
                            expr = new RegExp("^[a-z0-9]*$", "g");
                            if (!expr.test(val2)) {
                                errno = 1;
                            }
                        }
                        else {
                            errno = 1;
                        }
                    }
                    else {
                        errno = 1;
                    }
                    break;

                // Chemin
                case 'chemin':
                    expr = new RegExp("^[a-z0-9_/]*$", "gi");
                    if (!expr.test(valeur)) {
                        errno = 1;
                    }
                    break;

                // Heure
                case 'heure':
                    ok = IsHeure(valeur);
                    if (ok == false) {
                        errno = 1;
                    }
                    else {
                        if (ValInMinMax(ConvertHeureSec(valeur), vmn, vmx) == false) {
                            errno = 4;
                        }
                    }
                    break;

                // Heure hh:mm
                case 'heurehhmm':
                    if (IsHeurehhmm(valeur) == false) {
                        errno = 1;
                    }
                    else {
                        if (ValInMinMax(ConvertHeurehhmmSec(valeur), vmn, vmx) == false) {
                            errno = 4;
                        }
                    }
                    break;

                // Durée
                case 'duree':
                    if (IsDuree(valeur) == false) {
                        errno = 1;
                    }
                    else {
                        if (ValInMinMax(ConvertDureeSec(valeur), vmn, vmx) == false) {
                            errno = 4;
                        }
                    }
                    break;

                // Durée hh:mm
                case 'dureehhmm':
                    if (IsDureehhmm(valeur) == false) {
                        errno = 1;
                    }
                    else {
                        if (ValInMinMax(ConvertDureehhmmSec(valeur), vmn, vmx) == false) {
                            errno = 4;
                        }
                    }
                    break;

                // url (avec préfixe http / https / ftp / ftps / sftp / telnet / gopher)
                case 'url_pref':
                    expr = new RegExp("^(http(s?)|ftp(s?)|sftp|telnet|gopher)\://([a-z0-9_\-]+[\:][a-z0-9_\-]+@)?([0-9]{1,3}[\.][0-9]{1,3}[\.][0-9]{1,3}[\.][0-9]{1,3}|[a-z0-9_\-]+([\.][a-z0-9_\-]+){1,}[\.][a-z]{2,})?([\/][a-zA-Z0-9\-\.\?\,\'\/\\\+=&%\$#_]*)?$", "gi");
                    if (!expr.test(valeur)) {
                        errno = 1;
                    }
                    break;

                // url (sans préfixe)
                case 'url_npref':
                    expr = new RegExp("^([a-z0-9_\-]+[\:][a-z0-9_\-]+@)?([0-9]{1,3}[\.][0-9]{1,3}[\.][0-9]{1,3}[\.][0-9]{1,3}|[a-z0-9_\-]+([\.][a-z0-9_\-]+){1,}[\.][a-z]{2,})([\:][0-9]{2,})?([\/][a-zA-Z0-9\-\.\?\,\'\/\\\+=&%\$#_]*)?$", "gi");
                    if (!expr.test(valeur)) {
                        errno = 1;
                    }
                    break;

                // mot de passe
                case 'pw':
                    if (GivePwQ(valeur) < parseInt(pwq)) {
                        errno = 11;
                    }
                    break;

                default:
                    break;
            }
        }
    }

    return errno;
}

// Routine de contrôle du formulaire
function VForm(formulaire, a_champs, pays, lng) {
    var txttabpasdef;
    var nchp;
    var txtpw1;
    var txt1enum;
    var tab_messerr;
    var tab_mpop;
    var hlp_pw;
    var errno;
    var no_enum;
    var sel_champ;
    var prem_checked;
    var n;
    var ok;
    var tstok;
    var no_champ;
    var long_saisie;
    var tab_prm;
    var tab_prmchamp;
    var tab_typeprm;
    var no_prm;
    var str_prm;
    var idx;
    var nom_champ;
    var champ;
    var nom_champcomp;
    var champcomp;
    var type_champcomp;
    var val_champcomp;
    var type_champ;
    var val_champ;
    var carenumok;
    var avecenum;
    var carenum;
    var tab_enum;
    var max_length;
    var nbChecked;
    var nb;
    var prem_select;
    var nbSelected;
    var nb;
    var nivpw;
    var txt_pop = ''; // Texte du popup d'erreur

    if (pays == '') {
        pays = 'fr';
    }
    else {
        pays = pays.toLowerCase();
    }

    /***********************************/
    /**  Partie à traduire si besoin  **/
    /** To be translated if necessary **/
    /***********************************/
    // Français
    txttabpasdef = "Tableau de paramétrage non défini";
    nchp = "Champ";
    txtpw1 = 'Votre mot de passe possède un indice de qualité de';
    txt1enum = "sur une des énumérations";
    tab_messerr = ["Champ obligatoire",
        "Saisie non valide",
        "Saisie inférieure à la longueur minimum demandée",
        "Saisie supérieure à la longueur maximum demandée",
        "Valeur en dehors de la fourchette demandée",
        "Mauvaise quantité d'options sélectionnées",
        "Mauvaise option sélectionnée",
        "Le champ à comparer n'est pas du même type",
        "Les 2 saisies ne sont pas identiques",
        "Structures des 2 champs à comparer différentes",
        "Problème sur les paramètres du mot de passe",
        "Problème sur votre saisie du mot de passe",
        "Type de champ inconnu",
        "Pays non géré"];
    tab_mpop = ["Problème sur le caractère d'énumération",
        "Un des champs n'existe pas ou n'est pas un champ de saisie",
        "Mauvaise définition des champs dans le tableau ou le formulaire"];
    hlp_pw = "Rappel important sur les mots de passe :\n";
    hlp_pw += "-- Ils doivent au moins faire 7 caractères.";
    hlp_pw += "\n-- Il doit y avoir au moins une majuscule.";
    hlp_pw += "\n-- Il doit y avoir au moins une minuscule.";
    hlp_pw += "\n-- Il doit y avoir au moins un chiffre.";
    hlp_pw += "\n-- Il doit y avoir au moins le caractère souligné ('_').";
    hlp_pw += "\n-- Il doit y avoir au moins un caractère spécial ('-,#,@,%,!,$,*,&,<,>').";
    hlp_pw += "\n-- Il doit y avoir au moins une parenthèse spéciale ('[,],{,}').";
    hlp_pw += "\n-- Il vaut mieux commencer par une lettre.";
    hlp_pw += "\n-- Il n'est pas recommandé d'entrer des espaces.";

    switch (lng.toLowerCase()) {
        case 'en' :
            txttabpasdef = "Parameters array not defined";
            nchp = "Field";
            txtpw1 = 'Your password has a quality of';
            txt1enum = "on one of the enumarations";
            tab_messerr = ["Required field",
                "Field is not valid",
                "Field length is less than required",
                "Field length is more than required",
                "Field is not inside required values",
                "Bad number of selected options",
                "Bad selected option",
                "The field to compare si not the same type",
                "The 2 input are not the same",
                "The 2 fields to be compared have different structure",
                "Problem on your password field parameters",
                "Problem on your password entry",
                "Unknown field type",
                "Country not managed"];
            tab_mpop = ["Problem on an enumerating char",
                "One of the fiels doesn't exist or is not an input field",
                "Bad definition of the fiels in the array or in the form"];
            hlp_pw = "Important remind about passwords :\n";
            hlp_pw += "-- They must be at least 7 chars length.";
            hlp_pw += "\n-- They must include at least an uppercase letter.";
            hlp_pw += "\n-- They must include at least a lowercase letter.";
            hlp_pw += "\n-- They must include at least one number.";
            hlp_pw += "\n-- They must include at least the underscore ('_') character.";
            hlp_pw += "\n-- They must include at least one special character ('-,#,@,%,!,$,*,&,<,>').";
            hlp_pw += "\n-- They must include at least a special bracket ('[,],{,}').";
            hlp_pw += "\n-- They must start with at least one letter.";
            hlp_pw += "\n-- It is not recommended to input a space.";
            break;
        default : // Français
            break;
    }
    /**********************************/

    if (a_champs) {
        errno = -1;
        no_enum = 0;
        prem_checked = -1;
        n = 0;
        ok = true;
        tstok = true;

        for (no_champ = 0; no_champ < a_champs.length; no_champ++) {
            long_saisie = 0;
            // Les champs étant séparés par des ";", on éclate la chaîne
            tab_prm = RLtrim(a_champs[no_champ]).split(";");
            tab_prmchamp = [];
            tab_typeprm = [];
            // On contrôle tous les paramètres un par un
            for (no_prm = 0; no_prm < tab_prm.length; no_prm++) {
                // Les paramètres étant de la forme "nom_prm : valeur", on éclate la chaîne
                tab_typeprm = RLtrim(tab_prm[no_prm]).split(":");

                if ((tab_typeprm.length) >= 2) {
                    // On reconstruit le paramètre (par exemple s'il est de la format hh:mm:ss, vform l'aura éclaté en tableau)
                    str_prm = '';
                    for (idx = 1; idx < tab_typeprm.length; idx++) {
                        str_prm += RLtrim(tab_typeprm[idx]) + ':';
                    }

                    // On élimine le dernier ':'
                    str_prm = str_prm.substr(0, str_prm.length - 1);

                    // On crée le paramètre final
                    tab_prmchamp[RLtrim(tab_typeprm[0].toLowerCase())] = str_prm;
                }
            }

            ok = true;

            // Contrôle du nom
            if (tab_prmchamp['nom']) {
                nom_champ = RLtrim(tab_prmchamp['nom']);

                // Champ requis ?
                if (!tab_prmchamp["req"]) {
                    tab_prmchamp["req"] = false;
                }
                else {
                    tab_prmchamp["req"] = (tab_prmchamp["req"] == "Y") || (tab_prmchamp["req"] == "y") || (tab_prmchamp["req"] == "O") || (tab_prmchamp["req"] == "o");
                }

                champ = document.getElementsByName(nom_champ);
                if (champ && champ.length > 0) {
                    // Contrôle du champ de comparaison (s'il existe...sinon, on ne compare rien)
                    if (tab_prmchamp["comp"]) {
                        nom_champcomp = RLtrim(tab_prmchamp["comp"]);
                        champcomp = document.getElementsByName(nom_champcomp);

                        if (!champcomp || champcomp.length <= 0) {
                            delete(tab_prmchamp["comp"]);
                        }
                        else {
                            type_champcomp = champcomp[0].type;
                            val_champcomp = champcomp[0].value;
                        }
                    }

                    type_champ = champ[0].type;
                    val_champ = champ[0].value;

                    // On contrôle que les paramètres "minimum" existent, sinon valeur par défaut

                    // Texte descriptif du champ
                    // Si pas existant, on le crée avec le nom du champ
                    if (!tab_prmchamp["txt"]) {
                        tab_prmchamp["txt"] = nchp + ' ' + champ[0].name;
                    }

                    // Contrôle du caractère d'énumération (si existe)
                    carenumok = true;
                    avecenum = false;

                    if (tab_prmchamp["carenum"]) {
                        carenum = RLtrim(tab_prmchamp["carenum"]);

                        if (carenum.length != 1) {
                            delete(tab_prmchamp["carenum"]);
                            carenumok = false;
                        }
                        else {
                            switch (type_champ.toLowerCase()) {
                                // Dans ces 4 cas, il est inutile de définir une énumération
                                case 'select-one':
                                case 'select-multiple':
                                case 'radio':
                                case 'checkbox':
                                    carenum = '';
                                    avecenum = false;
                                    delete(tab_prmchamp["carenum"]);
                                    break;
                                default:
                                    tab_enum = RLtrim(val_champ).split(carenum);
                                    avecenum = true;
                                    break;
                            }
                        }

                    }

                    if (carenumok == true) {
                        errno = -1;
                        no_enum = 0;

                        // Test si champ obligatoire
                        // S'il est vide, ce n'est même pas la peine de tester le reste
                        if (tab_prmchamp["req"] == true) // le champ est obligatoire
                        {
                            switch (type_champ.toLowerCase()) {
                                case 'text':
                                case 'textarea':
                                case 'password':
                                case 'file':
                                    if (avecenum == true) {
                                        while ((no_enum < tab_enum.length) && (errno == -1)) {
                                            if (ChampEstVide(tab_enum[no_enum])) {
                                                errno = 0;
                                            }
                                            no_enum++;
                                        }
                                    }
                                    else {
                                        if (ChampEstVide(val_champ)) {
                                            errno = 0;
                                        }
                                    }
                                    break;
                                case 'select-one':
                                    sel_champ = champ[0].selectedIndex;
                                    if (parseInt(sel_champ) < 0) {
                                        errno = 0;
                                    }
                                    break;
                                case 'select-multiple':
                                    if (NbElementsSel(champ) == 0) {
                                        errno = 0;
                                    }
                                    break;
                                case 'radio':
                                case 'checkbox':
                                    if (NbElementsChk(champ) == 0) {
                                        errno = 0;
                                    }
                                    break;
                                default:
                                    break;
                            }
                        }

                        if (errno >= 0) {
                            ok = false;
                        }

                        // Le test" champ requis" est passé, on vérifie si c'est un mot de passe
                        if (ok == true) {
                            // Format
                            if (!tab_prmchamp["format"]) {
                                tab_prmchamp["format"] = '';
                            }

                            // Contrôle si mot de passe
                            if (tab_prmchamp["format"] == "pw") {
                                if (tab_prmchamp["pwq"]) {
                                    if ((parseInt(tab_prmchamp["pwq"]) < 0) || (parseInt(tab_prmchamp["pwq"]) > 8)) {
                                        errno = 10;
                                    }
                                }
                                else {
                                    errno = 10;
                                }
                            }
                        }

                        if (errno >= 0) {
                            ok = false;
                        }

                        // Le test "mot de passe" est passé, on vérifie maintenant "longueur mini" et "longueur maxi"
                        if (ok == true) {
                            // Longueur Minimum (pour liste : nb minimum de sélectionnés)
                            if (tab_prmchamp["lmn"]) {
                                // Défini : on vérifie si c'est bien un entier non signé
                                if (IsUnsigned(tab_prmchamp["lmn"]))  // Oui, on converti en entier
                                {
                                    tab_prmchamp["lmn"] = parseInt(tab_prmchamp["lmn"]);
                                }
                                else // Non, on affecte une longueur mini (puisque d'un minimum a été demandé, mais qu'il est faux)
                                {
                                    tab_prmchamp["lmn"] = 0;
                                }

                                // On contrôle la longueur mini de la saisie
                                switch (type_champ.toLowerCase()) {
                                    case 'text':
                                    case 'textarea':
                                    case 'password':
                                    case 'file':
                                        if (avecenum == true) {
                                            no_enum = 0;
                                            while ((no_enum < tab_enum.length) && (errno == -1)) {
                                                if (ChampEstVide(tab_enum[no_enum])) {
                                                    long_saisie = 0;
                                                }
                                                else {
                                                    long_saisie = parseInt(tab_enum[no_enum].length);
                                                }
                                                if (long_saisie < tab_prmchamp["lmn"]) {
                                                    errno = 2;
                                                }
                                                no_enum++;
                                            }
                                        }
                                        else {
                                            if (ChampEstVide(val_champ)) {
                                                long_saisie = 0;
                                            }
                                            else {
                                                long_saisie = parseInt(val_champ.length);
                                            }
                                            if (long_saisie < tab_prmchamp["lmn"]) {
                                                errno = 2;
                                            }
                                        }
                                        break;
                                    case 'select-multiple':
                                        if (NbElementsSel(champ) < tab_prmchamp["lmn"]) {
                                            errno = 2;
                                        }
                                        break;
                                    case 'checkbox':
                                        if (NbElementsChk(champ) < tab_prmchamp["lmn"]) {
                                            errno = 2;
                                        }
                                        break;
                                    default:
                                        break;
                                }
                            }

                            if (errno >= 0) {
                                ok = false;
                            }

                            // Le test" champ requis" est passé, on vérifie maintenant "longueur mini" et "longueur maxi"
                            if (ok == true) {
                                // Longueur Maximum (pour liste : nb minimum de sélectionnés)
                                if (tab_prmchamp["lmx"]) {
                                    // Défini : on vérifie si c'est bien un entier non signé
                                    if (IsUnsigned(tab_prmchamp["lmx"])) // Oui, on converti en entier
                                    {
                                        tab_prmchamp["lmx"] = parseInt(tab_prmchamp["lmx"]);
                                    }
                                    else // Non, on affecte une longueur maxi (puisque d'un maximum a été demandé, mais qu'il est faux)
                                    {
                                        switch (type_champ.toLowerCase()) {
                                            case 'text':
                                            case 'textarea':
                                            case 'password':
                                            case 'file':
                                                max_length = Number(champ.maxlength);
                                                if (max_length) {
                                                    tab_prmchamp["lmx"] = max_length;
                                                }
                                                else {
                                                    tab_prmchamp["lmx"] = 0;
                                                }
                                                break;
                                            case 'select-one':
                                            case 'select-multiple':
                                                // Le maxi est le nombre maximum d'éléments de la liste
                                                tab_prmchamp["lmx"] = champ[0].options.length;
                                                break;
                                            case 'radio':
                                            case 'checkbox':
                                                // Le maxi est le nombre maximum d'éléments à cocher
                                                tab_prmchamp["lmx"] = champ.length;
                                                break;
                                            default:
                                                break;
                                        }
                                    }

                                    // On contrôle la longueur maxi de la saisie
                                    switch (type_champ.toLowerCase()) {
                                        case 'text':
                                        case 'textarea':
                                        case 'password':
                                        case 'file':
                                            if (avecenum == true) {
                                                no_enum = 0;
                                                while ((no_enum < tab_enum.length) && (errno == -1)) {
                                                    if (ChampEstVide(tab_enum[no_enum])) {
                                                        long_saisie = 0;
                                                    }
                                                    else {
                                                        long_saisie = parseInt(tab_enum[no_enum].length);
                                                    }
                                                    if (long_saisie > tab_prmchamp["lmx"]) {
                                                        errno = 3;
                                                    }
                                                    no_enum++;
                                                }
                                            }
                                            else {
                                                if (ChampEstVide(val_champ)) {
                                                    long_saisie = 0;
                                                }
                                                else {
                                                    long_saisie = parseInt(val_champ.length);
                                                }
                                                if (long_saisie > tab_prmchamp["lmx"]) {
                                                    errno = 3;
                                                }
                                            }
                                            break;
                                        case 'select-multiple':
                                            if (NbElementsSel(champ) > tab_prmchamp["lmx"]) {
                                                errno = 3;
                                            }
                                            break;
                                        case 'checkbox':
                                            if (NbElementsChk(champ) > tab_prmchamp["lmx"]) {
                                                errno = 3;
                                            }
                                            break;
                                        default:
                                            break;
                                    }
                                }
                            }

                            if (errno >= 0) {
                                ok = false;
                            }

                            // Si les paramètres "longueur de champ" sont passés, on vérifie maintenant le paramètre
                            // "valeur mini" et on le modifie si besoin
                            if (ok == true) {
                                // Valeur Minimum (vérifiée et modifiée que si paramétrée)
                                if (tab_prmchamp["vmn"]) {
                                    switch (tab_prmchamp["format"]) {
                                        case 'date':
                                            // Défini : on vérifie si c'est bien une date valable au format demandé
                                            if (IsDate(tab_prmchamp["vmn"], tab_prmchamp["masque"])) // Oui
                                            {
                                                break;
                                            }
                                            else // Non
                                            {
                                                delete(tab_prmchamp["vmn"]);
                                            }
                                            break;
                                        case 'hexa':
                                            // Défini : on vérifie si c'est bien un hexadécimal
                                            if (IsHexa(tab_prmchamp["vmn"])) // Oui
                                            {
                                                tab_prmchamp["vmn"] = parseInt(tab_prmchamp["vmn"]);
                                            }
                                            else // Non
                                            {
                                                delete(tab_prmchamp["vmn"]);
                                            }
                                            break;
                                        case 'unsigned':
                                            // Défini : on vérifie si c'est bien un non signé
                                            if (IsUnsigned(tab_prmchamp["vmn"])) // Oui
                                            {
                                                tab_prmchamp["vmn"] = parseInt(tab_prmchamp["vmn"]);
                                            }
                                            else // Non
                                            {
                                                delete(tab_prmchamp["vmn"]);
                                            }
                                            break;
                                        case 'entier':
                                            // Défini : on vérifie si c'est bien un entier
                                            if (IsInteger(tab_prmchamp["vmn"])) // Oui
                                            {
                                                tab_prmchamp["vmn"] = parseInt(tab_prmchamp["vmn"]);
                                            }
                                            else // Non
                                            {
                                                delete(tab_prmchamp["vmn"]);
                                            }
                                            break;
                                        case 'reel':
                                            // Défini : on vérifie si c'est bien un réel
                                            if (IsReal(tab_prmchamp["vmn"])) // Oui
                                            {
                                                tab_prmchamp["vmn"] = parseFloat(tab_prmchamp["vmn"]);
                                            }
                                            else // Non
                                            {
                                                delete(tab_prmchamp["vmn"]);
                                            }
                                            break;
                                        case 'reel_ns':
                                            // Défini : on vérifie si c'est bien un réel non signé
                                            if (IsRealUnsigned(tab_prmchamp["vmn"])) // Oui
                                            {
                                                tab_prmchamp["vmn"] = parseFloat(tab_prmchamp["vmn"]);
                                            }
                                            else // Non
                                            {
                                                delete(tab_prmchamp["vmn"]);
                                            }
                                            break;
                                        case 'heure':
                                            // Défini : on vérifie si c'est bien une heure
                                            if (IsHeure(tab_prmchamp["vmn"])) // Oui
                                            {
                                                tab_prmchamp["vmn"] = ConvertHeureSec(tab_prmchamp["vmn"]);
                                            }
                                            else // Non
                                            {
                                                delete(tab_prmchamp["vmn"]);
                                            }
                                            break;
                                        case 'heurehhmm':
                                            // Défini : on vérifie si c'est bien une heure
                                            if (IsHeurehhmm(tab_prmchamp["vmn"])) // Oui
                                            {
                                                tab_prmchamp["vmn"] = ConvertHeurehhmmSec(tab_prmchamp["vmn"]);
                                            }
                                            else // Non
                                            {
                                                delete(tab_prmchamp["vmn"]);
                                            }
                                            break;
                                        case 'duree':
                                            // Défini : on vérifie si c'est bien une heure
                                            if (IsDuree(tab_prmchamp["vmn"])) // Oui
                                            {
                                                tab_prmchamp["vmn"] = ConvertDureeSec(tab_prmchamp["vmn"]);
                                            }
                                            else // Non
                                            {
                                                delete(tab_prmchamp["vmn"]);
                                            }
                                            break;
                                        case 'dureehhmm':
                                            // Défini : on vérifie si c'est bien une heure
                                            if (IsDureehhmm(tab_prmchamp["vmn"])) // Oui
                                            {
                                                tab_prmchamp["vmn"] = ConvertDureehhmmSec(tab_prmchamp["vmn"]);
                                            }
                                            else // Non
                                            {
                                                delete(tab_prmchamp["vmn"]);
                                            }
                                            break;
                                        case 'liste':
                                        case 'listem':
                                        case'radio':
                                        case 'checkbox':
                                            // Défini : on vérifie si c'est bien un entier
                                            if (IsUnsigned(tab_prmchamp["vmn"])) // Oui
                                            {
                                                tab_prmchamp["vmn"] = parseInt(tab_prmchamp["vmn"]);
                                            }
                                            else // Non
                                            {
                                                tab_prmchamp["vmn"] = 0; // Mini = 1er élément de la liste
                                            }
                                            break;
                                        default:
                                            delete(tab_prmchamp["vmn"]);
                                            break;
                                    }
                                }
                            }

                            if (errno >= 0) {
                                ok = false;
                            }

                            // On vérifie maintenant le paramètre "valeur maxi" et on le modifie si besoin
                            if (ok == true) {
                                // Valeur Maximum (vérifiée et modifiée que si paramétrée)
                                if (tab_prmchamp["vmx"]) {
                                    switch (tab_prmchamp["format"]) {
                                        case 'date':
                                            // Défini : on vérifie si c'est bien une date valable au format demandé
                                            if (IsDate(tab_prmchamp["vmx"], tab_prmchamp["masque"])) // Oui
                                            {
                                                break;
                                            }
                                            else // Non
                                            {
                                                delete(tab_prmchamp["vmx"]);
                                            }
                                            break;
                                        case 'hexa':
                                            // Défini : on vérifie si c'est bien un hexadécimal
                                            if (IsHexa(tab_prmchamp["vmx"])) // Oui
                                            {
                                                tab_prmchamp["vmx"] = parseInt(tab_prmchamp["vmx"]);
                                            }
                                            else // Non
                                            {
                                                delete(tab_prmchamp["vmn"]);
                                            }
                                            break;
                                        case 'unsigned':
                                            // Défini : on vérifie si c'est bien un non signé
                                            if (IsUnsigned(tab_prmchamp["vmx"])) // Oui
                                            {
                                                tab_prmchamp["vmx"] = parseInt(tab_prmchamp["vmx"]);
                                            }
                                            else // Non
                                            {
                                                delete(tab_prmchamp["vmx"]);
                                            }
                                            break;
                                        case 'entier':
                                            // Défini : on vérifie si c'est bien un entier
                                            if (IsInteger(tab_prmchamp["vmx"])) // Oui
                                            {
                                                tab_prmchamp["vmx"] = parseInt(tab_prmchamp["vmx"]);
                                            }
                                            else // Non
                                            {
                                                delete(tab_prmchamp["vmx"]);
                                            }
                                            break;
                                        case 'reel':
                                            // Défini : on vérifie si c'est bien un réel
                                            if (IsReal(tab_prmchamp["vmx"])) // Oui
                                            {
                                                tab_prmchamp["vmx"] = parseFloat(tab_prmchamp["vmx"]);
                                            }
                                            else // Non
                                            {
                                                delete(tab_prmchamp["vmx"]);
                                            }
                                            break;
                                        case 'reel_ns':
                                            // Défini : on vérifie si c'est bien un réel non signé
                                            if (IsRealUnsigned(tab_prmchamp["vmx"])) // Oui
                                            {
                                                tab_prmchamp["vmx"] = parseFloat(tab_prmchamp["vmx"]);
                                            }
                                            else // Non
                                            {
                                                delete(tab_prmchamp["vmx"]);
                                            }
                                            break;
                                        case 'heure':
                                            // Défini : on vérifie si c'est bien une heure
                                            if (IsHeure(tab_prmchamp["vmx"])) // Oui
                                            {
                                                tab_prmchamp["vmx"] = ConvertHeureSec(tab_prmchamp["vmx"]);
                                            }
                                            else // Non
                                            {
                                                delete(tab_prmchamp["vmx"]);
                                            }
                                            break;
                                        case 'heurehhmm':
                                            // Défini : on vérifie si c'est bien une heure
                                            if (IsHeurehhmm(tab_prmchamp["vmx"])) // Oui
                                            {
                                                tab_prmchamp["vmx"] = ConvertHeurehhmmSec(tab_prmchamp["vmx"]);
                                            }
                                            else // Non
                                            {
                                                delete(tab_prmchamp["vmx"]);
                                            }
                                            break;
                                        case 'duree':
                                            // Défini : on vérifie si c'est bien une heure
                                            if (IsDuree(tab_prmchamp["vmx"])) // Oui
                                            {
                                                tab_prmchamp["vmx"] = ConvertDureeSec(tab_prmchamp["vmx"]);
                                            }
                                            else // Non
                                            {
                                                delete(tab_prmchamp["vmx"]);
                                            }
                                            break;
                                        case 'dureehhmm':
                                            // Défini : on vérifie si c'est bien une heure
                                            if (IsDureehhmm(tab_prmchamp["vmx"])) // Oui
                                            {
                                                tab_prmchamp["vmx"] = ConvertDureehhmmSec(tab_prmchamp["vmx"]);
                                            }
                                            else // Non
                                            {
                                                delete(tab_prmchamp["vmx"]);
                                            }
                                            break;
                                        case 'liste':
                                        case 'listem':
                                        case 'radio':
                                        case 'checkbox':
                                            // Défini : on vérifie si c'est bien un entier
                                            if (IsUnsigned(tab_prmchamp["vmx"])) // Oui
                                            {
                                                tab_prmchamp["vmx"] = parseInt(tab_prmchamp["vmx"]);
                                                if (tab_prmchamp["vmx"] > champ.length - 1) {
                                                    tab_prmchamp["vmx"] = champ.length - 1; // Maxi = dernier élément de la liste
                                                }
                                            }
                                            else // Non
                                            {
                                                tab_prmchamp["vmx"] = champ.length - 1; // Maxi = dernier élément de la liste
                                            }
                                            break;
                                        default:
                                            delete(tab_prmchamp["vmx"]);
                                            break;
                                    }
                                }
                            }

                            if (errno >= 0) {
                                ok = false;
                            }

                            // Les paramètres de champs sont ok,
                            // On analyse les différents paramètres du type déclaré en fonction du type de champ
                            // uniquement si le champ est rempli
                            if (ok == true) {
                                switch (type_champ.toLowerCase()) {
                                    case 'radio':
                                        prem_checked = -1;
                                        n = 0;
                                        while ((n < champ.length) && (prem_checked < 0)) {
                                            if (champ[n].checked) {
                                                if (prem_checked == -1) {
                                                    prem_checked = n;
                                                }
                                            }
                                            n++;
                                        }
                                        // On ne teste que si au moins un bouton est coché
                                        if (prem_checked != -1) {
                                            // On vérifie si la valeur de case cochée est bien dans la fourchette mini/maxi
                                            if (ValInMinMax(prem_checked, tab_prmchamp["vmn"], tab_prmchamp["vmx"]) == false) {
                                                errno = 6;
                                            }
                                        }
                                        break;

                                    case 'checkbox':
                                        // Nombre de cases cochées
                                        prem_checked = -1;
                                        nbChecked = 0;
                                        for (nb = 0; nb < champ.length; nb++) {
                                            if (champ[nb].checked) {
                                                if (prem_checked == -1) {
                                                    prem_checked = nb;
                                                }
                                                nbChecked++;
                                            }
                                        }
                                        // On ne teste que si au moins une case est cochée
                                        if (nbChecked > 0) {
                                            // On vérifie si la valeur de la ligne sélectionnée est bien dans la fourchette
                                            if (ValInMinMax(prem_checked, tab_prmchamp["vmn"], tab_prmchamp["vmx"]) == false) {
                                                errno = 6;
                                            }
                                            else // On vérifie si le nombre de lignes sélectionnées est bien dans la fourchette
                                            {
                                                if (ValInMinMax(nbChecked, tab_prmchamp["lmn"], tab_prmchamp["lmx"]) == false) {
                                                    errno = 5;
                                                }
                                            }
                                        }
                                        break;

                                    case 'select-one':
                                        sel_champ = champ[0].selectedIndex;
                                        if (ValInMinMax(parseInt(sel_champ), tab_prmchamp["vmn"], tab_prmchamp["vmx"]) == false) {
                                            errno = 6;
                                        }
                                        break;

                                    case 'select-multiple':
                                        // Nombre de sélectionnés
                                        prem_select = -1;
                                        nbSelected = 0;
                                        for (nb = 0; nb < champ[0].options.length; nb++) {
                                            if (champ[0].options[nb].selected) {
                                                if (prem_select == -1) {
                                                    prem_select = nb;
                                                }
                                                nbSelected++;
                                            }
                                        }
                                        // On vérifie si la valeur de la ligne sélectionnée est bien dans la fourchette
                                        if (ValInMinMax(prem_select, tab_prmchamp["vmn"], tab_prmchamp["vmx"]) == false) {
                                            errno = 6;
                                        }

                                        // On vérifie si le nombre de lignes sélectionnées est bien dans la fourchette
                                        if (ValInMinMax(nbSelected, tab_prmchamp["lmn"], tab_prmchamp["lmx"]) == false) {
                                            errno = 5;
                                        }
                                        break;

                                    case 'text':
                                    case 'textarea':
                                    case 'password':
                                    case 'file':
                                        if (avecenum == true) {
                                            no_enum = 0;
                                            while ((no_enum < tab_enum.length) && (errno == -1)) {
                                                errno = valide_champ(pays, tab_enum[no_enum], tab_prmchamp["format"], tab_prmchamp["masque"], tab_prmchamp["vmn"], tab_prmchamp["vmx"], tab_prmchamp["pwq"]);
                                                no_enum++;
                                            }
                                        }
                                        else {
                                            errno = valide_champ(pays, val_champ, tab_prmchamp["format"], tab_prmchamp["masque"], tab_prmchamp["vmn"], tab_prmchamp["vmx"], tab_prmchamp["pwq"]);
                                        }
                                        break;

                                    default:
                                        break;
                                }
                            }

                            if (errno >= 0) {
                                ok = false;
                            }

                            // On vérifie maintenant s'il y a un champ de comparaison
                            if (ok == true) {
                                if (tab_prmchamp["comp"]) {
                                    if ((type_champ.toLowerCase()) != (type_champcomp.toLowerCase())) {
                                        errno = 7;
                                    }
                                    else {
                                        switch (type_champ.toLowerCase()) {
                                            case 'radio':
                                            case 'checkbox':
                                                // On vérifie la longueur des champs
                                                if (champ.length == champcomp.length) {
                                                    tstok = true;
                                                    n = 0;
                                                    while ((n < champ.length) && (tstok)) {
                                                        // On vérifie la valeur des champs
                                                        if (champ[n].value == champcomp[n].value) {
                                                            // On vérifie s'il ont un état "coché'/'non coché" identique
                                                            if (champ[n].checked != champcomp[n].checked) {
                                                                errno = 8;
                                                                tstok = false;
                                                            }
                                                        }
                                                        else {
                                                            errno = 9;
                                                            tstok = false;
                                                        }
                                                        n++;
                                                    }
                                                }
                                                else {
                                                    errno = 9;
                                                }
                                                break;
                                            case 'text':
                                            case 'textarea':
                                            case 'password':
                                            case 'file':
                                                if (val_champ != val_champcomp) {
                                                    errno = 8;
                                                }
                                                break;
                                            case 'select-one':
                                                // On vérifie la longueur des champs
                                                if (champ[0].options.length == champcomp[0].options.length) {
                                                    if (champ[0].selectedIndex != champcomp[0].selectedIndex) {
                                                        errno = 8;
                                                    }
                                                }
                                                else {
                                                    errno = 9;
                                                }
                                                break;
                                            case 'select-multiple':
                                                // On vérifie la longueur des champs
                                                if (champ[0].options.length == champcomp[0].options.length) {
                                                    tstok = true;
                                                    n = 0;
                                                    while ((n < champ[0].options.length) && (tstok)) {
                                                        // On vérifie la valeur des champs
                                                        if (champ[0].options[n].value == champcomp[0].options[n].value) {
                                                            // On vérifie s'il ont un état "coché'/'non coché" identique
                                                            if (champ[0].options[n].selected != champcomp[0].options[n].selected) {
                                                                errno = 8;
                                                                tstok = false;
                                                            }
                                                        }
                                                        else {
                                                            errno = 9;
                                                            tstok = false;
                                                        }
                                                        n++;
                                                    }
                                                }
                                                else {
                                                    errno = 9;
                                                }
                                                break;
                                            default:
                                                break;
                                        }
                                    }
                                }
                            }
                        }
                        // Construction du message d'erreur
                        if (errno >= 0) {
                            // Si style défini pour l'erreur on l'affiche
                            if (tab_prmchamp["stbad"]) {
                                champ[0].className = tab_prmchamp["stbad"];
                                if (tab_prmchamp["comp"]) {
                                    champcomp[0].className = tab_prmchamp["stbad"];
                                }
                            }
                            txt_pop += ConvertAccents(tab_prmchamp["txt"]) + ' --> ' + ConvertAccents(tab_messerr[errno]);
                            if (avecenum == true) {
                                txt_pop += ConvertAccents(' ' + txt1enum);
                            }
                            if (errno == 11) {
                                nivpw = GivePwQ(val_champ);
                                txt_pop += '\n\n' + txtpw1 + ' ' + nivpw;
                                switch (nivpw) {
                                    case 0 :
                                    case 1 :
                                    case 2 :
                                        txt_pop += ' (mauvais) :\n';
                                        break;
                                    case 3 :
                                    case 4 :
                                    case 5 :
                                        txt_pop += ' (moyen) :\n';
                                        break;
                                    case 6 :
                                    case 7 :
                                        txt_pop += ' (correct) :\n';
                                        break;
                                    case 8 :
                                    case 9 :
                                        txt_pop += ' (bon) :\n';
                                        break;
                                    default :
                                        break;
                                }
                                txt_pop += '\n\n' + hlp_pw + '\n';
                            }
                            txt_pop += '\n';
                        }
                        else {
                            // Si style défini pour champ ok on l'affiche
                            champ[0].className = tab_prmchamp["stok"];
                            if (tab_prmchamp["comp"]) {
                                champcomp[0].className = tab_prmchamp["stok"];
                            }
                        }
                    }
                    else {
                        txt_pop = tab_mpop[0];
                        alert(ConvertAccents(txt_pop));
                        return false;
                    }

                }
                else {
                    if (tab_prmchamp['req'] == true) {
                        txt_pop = tab_mpop[1];
                        alert(ConvertAccents(txt_pop) + ' :\n' + nom_champ);
                        return false;
                    }
                }
            }
            else {
                txt_pop = tab_mpop[2];
                alert(ConvertAccents(txt_pop));
                return false;
            }
        }
    }
    else {
        txt_pop = ConvertAccents(txttabpasdef);
    }

    // Si texte pop défini, on l'affiche
    if (txt_pop.length > 0) {
        alert(txt_pop);
        return false;
    }
    else {
        return true;
    }
}
