Covertisseur vers Divers Base (2-8-16-10-....)

#include
#include
#include
#include
#define GROUPAGE_PAR_LIGNE 60

int read_buff( char **output_tab);
void get_num(int *num );
char get_hex( int *num );
int b_ret( int *b, int *ret);
char get_C(void);

int main()
{
    int i = 0, f = 0, l,m = 0, j = 0;
    int NbrC = 0, virgDetc = 0, dicE = 0, key = 1;
    int iBase = 0, fBase = 0;
    int TAILLE_TAB = 0;

    char *symbol = "0123456789abcdefABCDEF"; ///caractere valable pour la conversion
    char *result = NULL;

    int  *etabNInt = NULL, eNbrTerm = 0, etabLmt = 0;
    int  *dtabNInt = NULL, dtabLmt = 0;
//variable de conversion vers la base 10
    int compteur = 0, b = 0, k = 0, sortie = 0;

    int *tabO = NULL, tabOLmt = 0,varTabO = 0;
    int pDConversion = 0;//pDConversion=nbrTerm-vartabO-1;

    int *tabadd1= NULL, add1=0;
    int *tabadd2 = NULL, add2 = 0;
    int *tabSm = NULL, sm = 0, ret = 0;
    int *tabResult = NULL;
    int *tabDiv = NULL;

    int termiBase1 = 0, termiBase2 = 0;
    int lgmx = 0, lgmsx = 0;//optimisateurs

//variable de la conversion de la partie decimale vers la base 10
    int rest = 0, divd = 0, div = 0, quot = 0;
    int pDivConver = 0, interp = 0;
    int *tabQuot = NULL;
    int tabRLmt = 0;

// variable de la conversion de la partie entiere vers la base cible

    int *tabDivd = NULL, dDivd = 0;
    int vQuot = 0,quotLmt = 0;

    int *tabSion = NULL;

    int *tabRest = NULL, vRest = 0;

    int termfbase1 = 0, termfbase2 = 0;
    int dif = 0, sQuot = 0;
    int detector = 0;
    // variable de la conversion de la partie decimale

    int a = 0;

//zone de securite
    do
    {
//        system("clear");



        printf( "\nBase initiale: " );
        get_num( &iBase );

        fBase = 2;//evitement de declaration d'erreur sur fBase en cas sur iBase
        if( iBase == 2 || iBase == 8 || iBase == 10 || iBase == 16 )
        {

            printf( "Base cible: " );
            get_num(&fBase);
            if( fBase == 2 || fBase == 8 || fBase == 10 || fBase == 16 )
            {


                etabNInt = calloc(5, sizeof(int));
                dtabNInt = calloc(5, sizeof(int));
                printf( "\nNombre a convertir: " );

                i = 0;//initialisation de la boucle
                NbrC = 1;
                char c;
                while( (c = getchar() ) !='\n' && key == 1 && virgDetc < 2)
                {
                    if( c != ' ')
                    {
                        etabNInt = realloc(etabNInt,5*NbrC*sizeof(int));
                        dtabNInt = realloc(dtabNInt, 5*NbrC*sizeof(int));
                        if ( ( result = strchr( symbol, c ) ) )
                        {
                            dicE = 1;

                            if ( virgDetc == 1 )
                            {

                                dtabNInt[f] = result - symbol;
                                if( dtabNInt[f] >= iBase )
                                {
                                    key = 0;
                                }
                                dtabLmt++;
                                f++;

                            }
                            else
                            {
                                etabNInt[i] = result - symbol;
                                if( etabNInt[i] >= iBase )
                                {
                                    key = 0;
                                }
                                i++;
                                eNbrTerm++;

                            }

                            NbrC++;

                        }

                        if ( c == '.' )
                        {
                            virgDetc++;
                            dicE = 1;
                        }

                        if( virgDetc == 2 || dicE == 0 )
                        {
                            key = 0;
                        }

                        dicE = 0;//reinitialiser l'indicateur

                    }

                }


//etablissement des limites de deplacement dans les cellules de la partie entiere
                if( eNbrTerm > 0 )
                {
                    etabLmt = eNbrTerm - 1;
                }
//---------------conversion de tableau 'char' en tableau 'int'[0]

            }
            else
            {
                key = 0;//clef de la base finale
            }

        }
        else
        {
            key = 0;//clef de la base finale
        }


        if( key == 1 )//si key==1
        {

            TAILLE_TAB = 5 * (NbrC);

            tabadd1 = calloc(TAILLE_TAB, sizeof(int));
            tabadd2 = calloc(TAILLE_TAB, sizeof(int));
            tabDiv = calloc(TAILLE_TAB, sizeof(int));
            tabDivd = calloc(TAILLE_TAB, sizeof(int));
            tabO = calloc(TAILLE_TAB, sizeof(int));
            tabQuot = calloc(TAILLE_TAB, sizeof(int));
            tabRest = calloc(TAILLE_TAB, sizeof(int));
            tabResult = calloc(TAILLE_TAB, sizeof(int));
            tabSion = calloc(TAILLE_TAB, sizeof(int));
            tabSm = calloc(TAILLE_TAB, sizeof(int));


///conversion de la partie entiere en base 10



//Machine de conversion vers la base 10 de etabNInt
            ///----------------------//-----------conversion en base 10 [1]
            varTabO = 0;

            tabRLmt = TAILLE_TAB - 1;

            if( iBase >= 10 )
            {
                termiBase1 = iBase - 10;
                termiBase2 = 10;
            }
            else
            {
                termiBase1 = 0;
                termiBase2 = iBase;
            }


//chargement initial de la valeur de la cellule de tabO 1
            b = etabNInt[varTabO];
            if(b < 10)
            {
                lgmx = TAILLE_TAB - 1;//opt premiere valeur non null rencontrer dans le tableau
                tabSm[lgmx] = b;
            }
            else
            {
                b -= 10;
                lgmx = TAILLE_TAB - 2;// opt premier valeur non null rencontrer dans le tableau

                tabSm[lgmx] = 1;
                tabSm[lgmx+1] = b;
            }

            pDConversion = eNbrTerm - 1 - varTabO;//pDConversion=nbrTerm-1-varTabO;//calcul de la puissance de conversion initial

            if( pDConversion == 0 )//s'il n'ya que un seul terme declare
            {
                termiBase1 = 1;
                termiBase2 = 0;
            }


            do
            {
                ///xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

//Multiplication de tabadd1 par termiBase1
//Multiplication de tabadd2 par termiBase2
//addition de tabadd1 et de tabadd2
                i = TAILLE_TAB - 1;
                ret = 0;
                l = 0;
                rest = 0;
                do
                {
                    sm = tabSm[i] * termiBase1 + ret;
                    ret = 0;
                    b_ret( &sm, &ret);

                    b = tabSm[i] * termiBase2 + l;
                    l = 0;
                    tabSm[i] = b_ret( &b, &l);

                    sm += b + rest;
                    rest = 0;
                    if( sm > 9 )
                    {
                        sm -= 10;
                        rest = 1;
                    }
                    tabSm[i] = sm;

                    if( i < lgmx && b == 0 && ret == 0 && rest == 0)
                    {
                        lgmx = i; //opt
                        i = -1; //sortie forcee
                    }

                    i--;

                }
                while( i > -1 );// printf("\n");


                if(pDConversion > 0)
                {
                    pDConversion--;
                }

//reinitialisation des valeurs et passage a une nouvelle cellule si la pDConversion est nulle
                if( pDConversion == 0 )
                {
                    //addition de tabSm et de tabResult
                    i = TAILLE_TAB - 1;
                    ret = 0;
                    do
                    {

                        tabResult[i] += tabSm[i] + ret;
                        ret = 0;
                        if( tabResult[i] > 9 )
                        {
                            tabResult[i] -= 10;
                            ret = 1;
                        }

                        if( tabRLmt >= i && ret == 0)
                        {
                            tabRLmt = i;
                        }


                        if( i < lgmx && ret == 0 )
                        {
                            i = -1;//sortie force
                        }
                        else
                        {
                            i--;
                        }

                    }
                    while( i > -1 );

//reinitialisation des tableaux d'operation
                    i = TAILLE_TAB - 1;
                    do
                    {
                        tabSm[i] = 0;
                        if( i < lgmx-1 )
                        {
                            i = -1;//sortie force
                        }
                        else
                        {
                            i--;
                        }

                    }
                    while( i > -1 );


                    varTabO++;

                    //chargement de la valeur de la cellule de tabO 1
                    b = etabNInt[varTabO];
                    if(b < 10)
                    {
                        lgmx = TAILLE_TAB - 1;//opt premiere valeur non null rencontrer dans le tableau
                        tabSm[lgmx] = b;
                    }
                    else
                    {
                        b -= 10;
                        lgmx = TAILLE_TAB - 2;// opt premier valeur non null rencontrer dans le tableau
                        tabSm[lgmx] = 1;
                        tabSm[lgmx+1] = b;
                    }

                    pDConversion = eNbrTerm - 1 - varTabO;//pDConversion=nbrTerm-1-varTabO;//determination de la puissance de conversion de reinitialisation

//on ajoute la derniere valeur se trouvant dnas le tableau a la fin des calculs
                    if( pDConversion == 0 || pDConversion == -1 )
                    {

//derniere operation d'addition  avant etablissement de la valeur convertit en base 10

                        i = TAILLE_TAB - 1;
                        ret = 0;
                        do
                        {

                            tabResult[i] += tabSm[i] + ret;
                            ret = 0;

                            if( tabResult[i] > 9 )
                            {
                                tabResult[i]-= 10;
                                ret = 1;
                            }

                            if( tabRLmt > i && ret == 0 )
                            {
                                tabRLmt = i;
                            }

                            if(i < lgmx && ret == 0)
                            {
                                i = -1;//sortie force
                            }
                            else
                            {
                                i--;
                            }

                        }
                        while( i > -1 );


//transfert de la nouvelle valeur en base 10 dans tabO

                        i = tabRLmt;
                        k = 0;
                        sortie = 0;
                        etabLmt = 0;//tabOLmt=0;
                        do
                        {

                            if( tabResult[i] > 0 )
                            {
                                sortie = 1;
                            }
                            if(sortie > 0)
                            {
                                etabNInt[k] = tabResult[i];//tabO[k]=add1;
                                k++;
                                etabLmt++;//nbrTerm++;
                            }

                            tabResult[i] = 0;//reinitialisation pour sortie de boucle

                            i++;
                        }
                        while( i < TAILLE_TAB );

                    }

                }

            }
            while ( pDConversion > 0 ); ///xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
//----------------------------------calcul vers la base 10 [0]
//------------------------------------------------------------stockage de tabSm dans tabadd1 et dans tabadd2 [0]
            etabLmt--; // recorection

///----------------------//-----------conversion en base 10 [0]


///fin de conversion vers la base 10 de la partie entiere


///conversion de la partie decimale vers la base 10


            i = 0;
            do
            {
                tabO[i] = dtabNInt[i];//transfert des valeurs de dtabNInt dans tabO
                //printf("%d",tabO[i]);
                dtabNInt[i] = 0;//elemination des valeurs prises
                i++;
            }
            while( i < dtabLmt );
            //nettoyage de dtabNInt
            free(dtabNInt);
            dtabNInt = calloc(TAILLE_TAB, sizeof(int));
            //printf("\n\n");
            tabOLmt = dtabLmt;

            div = iBase;


            ///debut
            //boucle de conversion de la partie decimale
            dtabLmt = 0;//tabRLmt=0;
            k = 0;
            do
            {
                lgmx = 2;
                tabDiv[0] = tabO[k];
                tabO[k] = 0;//elemination de la valeur prise

                pDivConver = k + 1;
                //calcul de la valeur en base 10 de la cellule tabO

                do
                {
                    rest = 0;
                    i = 0;
                    interp = 0;
                    do
                    {

                        divd = rest * 10 + tabDiv[i];//calcul de la dividende
                        rest = divd % div;//calcul du reste
                        divd = divd - rest;//calcul de la dividende sans le reste
                        quot = divd / div;//calcul du quotient
                        tabDiv[i] = quot;//enregistrement du quotient dans le tableau des de division

                        if( pDivConver == 1 )
                        {
                            if( quot > 0 && interp == 0 )
                            {
                                dicE = i;
                                interp = 1;
                            }
                        }

                        if( i > lgmx && quot == 0)
                        {
                            lgmx = i;
                            i = TAILLE_TAB;//sortie forcee
                        }

                        i++;//changement de cellule
                    }
                    while( i < TAILLE_TAB ); //printf("\n");
                    //printf("\n");

                    pDivConver--;
                }
                while( pDivConver > 0 );

//addition de tabDiv et de dtabNInt
                i = lgmx;//- 4 ;//lgmx - 5;
                ret = 0;
                //interp = 0;
                do
                {

                    dtabNInt[i] += tabDiv[i] + ret;

                    tabDiv[i] = 0; //reinitialisation de tabDiv

                    ret = 0;
                    if( dtabNInt[i] > 9 )
                    {
                        dtabNInt[i] -= 10;
                        ret = 1;
                    }

                    if( dtabNInt[i] > 0 && dtabLmt <= i )
                    {
                        dtabLmt = i + 1;//determination de la limite de dtabLmt
                    }
                    if( i <= dicE && ret == 0 )// opt
                    {
                        dicE = i;
                        i =  -1; //sortie forcee
                    }
                    else
                    {
                        i--;

                    }


                }
                while( i > -1 );


                k++;
            }
            while( k <= tabOLmt );

            ///fin



///conversion de la partie entiere en la base cible


//chargement de tabDivd pour la conversion vers la base cible de la partie entiere


            k = TAILLE_TAB - 1 - etabLmt;
            i = 0;
            lgmx = k - 1;//not touch enter
            while(i <= etabLmt)
            {
                tabDivd[k] = etabNInt[i];
                etabNInt[i] = 0;//elemination des valeur chargee
                i++;
                k++;
            }
            //nettoyage de etabNInt
            free(etabNInt);
            etabNInt = calloc(TAILLE_TAB, sizeof(int));

            printf("\n___________\n");
//chargement des terme de multiplicateur
            if( fBase > 9 )
            {
                termfbase1 = fBase - 10;
                termfbase2 = 1;
            }
            else
            {
                termfbase1 = fBase;
                termfbase2 = 0;
            }

            tabDiv[TAILLE_TAB-1] = termfbase1;
            tabDiv[TAILLE_TAB-2] = termfbase2;

////
//Boucle principale de conversion vers fBase

            vRest = TAILLE_TAB - 1;
            do
            {

                //determination du debut de la dividende
                dDivd = lgmx;//not touch
                if( lgmx < TAILLE_TAB - 2 )
                {
                    lgmx++;
                }


                if( tabDivd[lgmx] == 0 && tabDivd[dDivd] == 0 )
                {
                    i = lgmx;

                    while( tabDivd[i] == 0 && i  < TAILLE_TAB - 1 )
                    {
                        i++;
                    }


                    dDivd = i;
                    lgmx = i;
                }
                else if( tabDivd[dDivd] )
                {
                    dDivd--;
                    lgmx--;
                }


                //debut processus de division
                vQuot = 0;
                interp = 0;
                ////-----------------------------------------------------------

//zone de division des termes;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                lgmsx = TAILLE_TAB - 2;
                //l = 0;
                l = TAILLE_TAB - dDivd+1;
                do
                {

                    sQuot = 0;
                    do
                    {

                        if( interp == 1 )
                        {

                            ret = 0;
                            i = TAILLE_TAB - 1;

                            do
                            {
                                add1 = tabSion[i-l];
                                add2 = tabDiv[i];

                                dif = add1 - add2 - ret;
                                ret = 0;

                                if(dif < 0)
                                {
                                    dif += 10;
                                    ret = 1;
                                }
                                tabSion[i-l] = dif;
                                if( dif > 0 && lgmsx == 0 )
                                {
                                    lgmsx = i;
                                }


                                if(i < (TAILLE_TAB-1) && ret == 0 )//optimisateur de la soustraction
                                {
                                    i = 0;
                                }

                                i--;
                            }
                            while( i > -1 ); //-1 indique la limite a laquelle la soustraction do s'arreter

                            sQuot++;

                        } //soustraction ci avant

                        //test de superiorite de la demi dividende
                        i = lgmsx;//i=0;
                        interp = 0;

                        do
                        {
                            add1 = tabSion[i-l];
                            add2 = tabDiv[i];


                            if( add1 >= add2 )
                            {

                                if( fBase >= 10 )
                                {
                                    if( add1 > add2 && add1 != 0 )
                                    {
                                        interp = 1;
                                    }

                                    if( add1 == add2 && i == TAILLE_TAB - 1 )
                                    {
                                        interp = 1;
                                    }
                                }
                                else if( fBase <= 9 )
                                {
                                    if( add1 != 0 )
                                    {
                                        interp = 1;
                                    }

                                }

                            }
                            else if( add2 > add1 )
                            {

                                i = TAILLE_TAB;//sortie forcee
                            }

                            i++;
                        }
                        while( i < TAILLE_TAB && interp == 0 );

                    }
                    while( interp == 1 ); //faire la soustraction tant que la demi dividende est superieur au diviseur

                    //enregistrement du quotient dans tabQuot
                    tabQuot[vQuot] = sQuot;

                    vQuot++;
                    quotLmt++;//augmentation du rang des termes du quotient

                    if( dDivd < TAILLE_TAB )//s'il ya un autre terme dans la dividende
                    {
                        lgmsx--;///ZONE A REVOIR PLUTART++
                        //abaissement d'un autre terme
                        l = TAILLE_TAB - dDivd+1;
                        tabSion[dDivd-2] = tabDivd[dDivd];
                    }
                    dDivd++;//redressement du debut dividende

                    //test de superiorite de la demi dividende pour reprise de boucle
                    i = lgmsx;
                    interp = 0;
                    do
                    {
                        add1 = tabSion[i-l];
                        add2 = tabDiv[i];


                        if( add1 >= add2 )///add1>add2
                        {

                            if(fBase>=10)
                            {
                                if( add1 > add2 && add1 != 0 )
                                {
                                    interp = 1;
                                }

                                if( add1 == add2 && i == TAILLE_TAB - 1 )
                                {
                                    interp = 1;
                                }
                            }
                            else if( fBase <= 9 )
                            {
                                if( add1 != 0 )
                                {
                                    interp = 1;
                                }

                            }

                        }
                        else if( add2 > add1 )
                        {
                            i = TAILLE_TAB;//sortie forcee

                        }


                        i++;
                    }
                    while( i < TAILLE_TAB && interp == 0 );

                }
                while( dDivd < TAILLE_TAB + 1 || interp == 1 ); //fin de division succ//inferieur a 1001 because il reste un element de tabSion non pris en compte

//zone de recherche du reste de la division

//chargement des tables de multiplication

//multiplication par termfBase1 de tabadd1=tabQuot
                i = TAILLE_TAB - 1;
                ret = 0;
                rest = 0;
                f = vRest;
                detector = 0;
                l = 0;
                j = quotLmt-1;//dernier valeur de quot dans tabQuot
                m = 0;
                do
                {

                    b = tabQuot[j] * termfbase1 + ret;
                    b_ret( &b, &ret);

                    if( fBase > 9 )
                    {
                        if( j == quotLmt-1)
                        {
                            sm = b + rest;
                        }
                        else
                        {
                            sm = b + add2 + rest;
                        }
                        add2 = tabQuot[j];
                    }
                    else
                    {
                        sm = b + rest;
                    }
                    j--;

                    rest = 0;
                    if( sm > 9 )
                    {
                        sm -= 10;
                        rest = 1;
                    }

                    //calcul du reste par soustraction de tabSm a tabDivd

                    dif = tabDivd[i] - sm - l;
                    l = 0;

                    if( dif < 0 )
                    {
                        dif += 10;
                        l = 1;
                    }

                    if( fBase > 9 )
                    {

                        if( detector == 1 )
                        {
                            add1 = tabRest[vRest];
                            dif = dif * 10 + add1;

                        }
                        tabRest[vRest] = dif;
                        detector = 1;
                    }

                    if( fBase < 10 )
                    {

                        tabRest[f] = dif;
                        if( f > 0 )
                        {
                            f --;
                        }
                    }

                    i--;
                    m++;
                }
                while( m < 2 );
                vRest--;

//rafraichissement de tabDivd
                k = TAILLE_TAB - quotLmt;
                b = 0;

                interp = 0;
                do
                {
                    tabDivd[k+b] = tabQuot[b];

                    if( tabQuot[b] > 0 && interp == 0)
                    {
                        interp = 1;//test d'existence de valeur dans la dividende avec //reinitialisation de tabQuot
                    }
                    tabQuot[b] = 0;

                    b++;
                }
                while( b < quotLmt );
                quotLmt = 0;

            }
            while( interp == 1 );
            //recorrection de vRest
            vRest += 1;
            //fin de conversion vers la base cible

//chargement des nouvelles valeurs
            compteur = 0;
            for( i = vRest; i < TAILLE_TAB; i++ )
            {
                etabNInt[i] = tabRest[i];
                tabRest[i] = 0;//elemination des valeurs chargee
                compteur++;
            }


            etabLmt = vRest;

///conversion de la partie decimale en la base cible

//reinitialisation de variables de calcul
//transfert des valeurs de dtabNInt dans tabO pour conversion vers la base cible
            k = 1;//on augmente la marge de la partie entiere de 1 pour les valeurs plus grand que 9 apres multiplication
            i = 0;

            do
            {
                tabO[k] = dtabNInt[i];

                dtabNInt[i] = 0;//elemination des valeurs chargees
                if( tabO[k] > 0 )
                {
                    tabOLmt = k;
                }

                i++;
                k++;
            }
            while( k <= dtabLmt ); //printf("\n\n");

            dtabLmt = 0;

            a = 0;
            do
            {

                //multiplication par termfBase1 de tabadd1=tabO
                i = tabOLmt;

                lgmx = 0;//opti en rapport avec la limite de la precision de la partie decimale convertit
                interp = 0;
                rest = 0;
                ret = 0;
                do
                {

                    b = tabO[i] * termfbase1 + ret;
                    b_ret( &b, &ret);

                    if( fBase > 9 && i > 0)
                    {
                        if(i == tabOLmt)
                        {
                            sm = b + rest;
                        }
                        else
                        {
                            sm = b + add2 + rest;
                        }
                        add2 = tabO[i];
                    }
                    else
                    {
                        sm = b + rest;
                    }

                    rest = 0;
                    if( sm > 9 )
                    {
                        sm -= 10;
                        rest = 1;
                    }
//enregistrement de la partie entiere du produit dans dtabNint
//enregistrement de la partie entiere du produit dans dtabNint

                    tabO[i] = sm;

                    if( i < 2)
                    {
                        //liberation de la partie entiere de tabO
                        tabO[i] = 0;

                        if( i == 1 )
                        {
                            dtabNInt[dtabLmt] = sm;
                        }
                        else// if i == 0
                        {
                            dtabNInt[dtabLmt] += sm*10;
                            dtabLmt++;
                        }

                    }

                    if( sm > 0 && interp == 0 )
                    {
                        interp = 1;
                        tabOLmt = i;
                        lgmx = 1;
                    }

                    i--;
                }
                while( i > -1 );



                a++;
            }
            while( a < TAILLE_TAB && lgmx == 1 ); // 10 //indication sur la limite du nombre de multiplication

            a = 0;
            if( interp == 1 )
            {
                a = 1;//indicateur de non fin de la conversion de la partie decimale pour cause de depassement de capacite
            }

///affichage des resultats de la conversion

//affichage resultat conversion de la partie entiere

            printf( " " );

            for(i = etabLmt; i < TAILLE_TAB; i++ )
            {

//zone de calcul de l'affichage partie entiere
                printf("%c", get_hex(&etabNInt[i]));
            }

            printf("\n|.|\n ");//point de separation de la partie entiere et de la partie de decimale

//affichage resultat conversion de la partie decimale
            for( i = 0; i < dtabLmt; i++ )
            {
                //zone de cacul de l'affichage des symboles partie decimale
                printf("%c", get_hex(&dtabNInt[i]));

            }

            if( a == 1 )//indicateur de non fin de conversion de la partie decimale
            {
                printf( "|....+" );
            }
//liberation des tableaux de calcul
            free( tabadd1 );
            free( tabadd2 );
            free(tabDiv);
            free( tabDivd );
            free( tabO );
            free( tabQuot );
            free( tabRest );
            free( tabResult ) ;
            free(tabSion);
            free( tabSm );
            free( etabNInt );
            free( dtabNInt );


        }//si key==1


        if( key == 0 )//enumeration des problemes
        {
            printf( "!!!!!!!!!!!!WARNING!!!!!!!!!\n" );
            printf( "Diagnostic du probleme\n_____________________________________________________________________\n" );

            //diagnostic des bases d'entree et de sortie
            if( iBase != 2 && iBase !=8 && iBase !=10 && iBase != 16 )
            {
                printf( "       Conversion impossible!\n:Erreur sur Base initiale\n" );

                if( fBase != 2 && fBase != 8 && fBase != 10 && fBase != 16 && iBase != fBase )
                {
                    printf( ":Erreur Base cible" );
                }


            }


            if( iBase == 2 || iBase == 8 || iBase== 10 || iBase == 16 )
            {
                if( fBase != 2 && fBase != 8 && fBase != 10 && fBase != 16 )
                {
                    printf( "   Conversion impossible!\n:Erreur Base cible" );
                }

            }


            //diagnostic des valeurs entrees
            if( iBase == 2 || iBase == 8 || iBase == 10 || iBase == 16 )
            {
                if( fBase == 2 || fBase == 8 || fBase == 10 || fBase == 16 )
                {

                    printf( "Conversion impossible!\n:Erreur sur Nombre a convertir\nVerifiez s'il vous plait\n" );

                }//2

            }//1


        }//si key=0


        printf( "\n\n" );
        printf( "Entrer 1 si vous voulez continuer\n" );
        get_num(&key);

        if( key == 1 )
        {

            //zone de reinitialisation des variables et des tab

            f = 0;
            eNbrTerm = 0;
            etabLmt = 0;
            dtabLmt = 0;
            virgDetc = 0;
//variable de conversion vers la base 10
            b = 0;
            k = 0;
            sortie = 0;
            varTabO = 0;
            tabOLmt = 0;


//variable de la conversion de la partie decimale vers la base 10

            divd = 0;
            div = 0;
            quot = 0;
            pDivConver = 0;
            interp = 0;
            tabRLmt = 0;

// variable de la conversion de la partie entiere vers la base cible


            detector = 0;
            dDivd = 0;
            vQuot = 0;
            quotLmt = 0;

            vRest = 0;
            dif = 0;
            sQuot = 0;

// variable de la conversion de la partie decimale

            a = 0;

        }


    }
    while( key == 1 );


    return 0;
}


//___________________________________________
int read_buff( char **pointer)
{

    char c ;

    int siz = 0;

    *pointer = NULL;
    *pointer =  malloc(1);

    while( ( c = getchar() ) != '\n' )

        if ( c != ' ' )
        {

            *pointer = realloc( *pointer, (siz + 2) * sizeof(char));
            *( *pointer + siz ) = c ;
            siz++;

        };

    *( *pointer + siz ) = '\0';
    siz++;

    return siz;
}

void get_num(int *num )
{
    int tab_lg, i;

    char *tab_tab = NULL;

    *num = 0;

    tab_lg = read_buff( &tab_tab );
    for( i = 0; i < tab_lg - 1 ; i++ )
    {

        if( i < tab_lg-2 )
        {
            *num += (tab_tab[i] - '0') * 10;
        }
        else
        {
            *num += tab_tab[i] - '0';
        }

    }
    free( tab_tab );

}

char get_hex( int *num )
{

    switch( *num )
    {

    case 10:
        return 'a';
        break;
    case 11:
        return 'b';
        break;
    case 12:
        return 'c';
        break;
    case 13:
        return 'd';
        break;
    case 14:
        return 'e';
        break;
    case 15:
        return 'f';

    case 0:
        return '0';
        break;
    case 1:
        return '1';
        break;
    case 2:
        return '2';
        break;
    case 3:
        return '3';
        break;
    case 4:
        return '4';
        break;
    case 5:
        return '5';
        break;
    case 6:
        return '6';
        break;
    case 7:
        return '7';
        break;
    case 8:
        return '8';
        break;
    case 9:
        return '9';
        break;


    }
    return '?';
}

int b_ret( int *b, int *ret)
{
    int k;
    *ret = 0;
    if( *b > 9)
    {
        for( k = 1; k < 300; k++)
        {
            if( (10*k-1)  < *b && *b < (10*(k+1)) )
            {
                *b -= (10*k);
                *ret = k;
                k = 300;
            }
        }
    }
    return *b;
}

char get_C(void)
{
    char c;
    c = getchar();
    return c;
}