TRAITEMENT BINAIRE - ENTIER (C)

#include <math.h>
#include <stdio.h>
#include <stdlib.h>

#define BITS       20
#define BON        1
#define MAUVAIS    0
#define OVER       2
#define BASE       16
#define EOS        '\0'


int entier2binaire(char*, int );
int binaire2entier(char*);
void reverse(char* );
int powrec(int , int );
void not(char*);
char* and(char* , char*);
char* add(char*, char*);
char lsl(int, char*);
char lsr(int, char*);
char rol(int, char*);
char rol_single(char*);
char ror(int , char*);



int main( int argc, char *argv[])
{
int flag, flag2, n, m, choix, i, MAX, ret;
char tab[BITS], *mes, car;
char tab2[BITS], *tab3, *tab4;
MAX = powrec(BASE, BITS);   /* l'entier maximal représenté sur BITS bits dans la base BASE */

printf("\n***************************************************************\n");
printf("\tManipulation des chaines binaires\n");
printf("***************************************************************\n\n");
 printf("\t0 ==> Quitter \n");
 printf("\t1 ==> Convertir un entier en binaire\n");
 printf("\t2 ==> Complement logique\n");
 printf("\t3 ==> ET logique\n");
 printf("\t4 ==> Addition deux registres\n");
 printf("\t5 ==> Decallage logique de bits vers la gauche\n");
 printf("\t6 ==> Decallage logique de bits vers la droite\n");
 printf("\t7 ==> Rotation de bits vers la gauche\n");
 printf("\t8 ==> Rotation de bits vers la droite\n");
 printf("\t9 ==> Convertir un binaire en entier \n\n");

 op:
 printf("Entrez l'operation a faire : ");
 ret = scanf("%d", &choix);

 if(ret)
 {
        switch(choix)
        {
        case 0:
             printf("\n Aurevoir...\n");
             goto end;
             break;

        case 1:
            printf("Entrez l'entier : ");
             scanf("%d", &n);
             flag = entier2binaire(tab, n);
             switch(flag)
             {
             case 0:
             printf("%d est un nombre negatif\n");
             goto op;
             break;
             case 1:
             printf("%d => 'B' %s \n", n, tab);
             goto op;
             break;
             default:
             printf("Debordement de la memoire : %d n'est pas codable sur %d bits \n", n, BITS);
             goto op;
             break;
             }
             break;

         case 2:
              printf("Entrez l'entier a complementer : ");
              scanf("%d",&n);
              entier2binaire(tab, n);
              printf(" %d => 'B' %s \n", n, tab);
              not(tab);
              printf("/%d => 'B' %s\n", n, tab);
              goto op;
              break;

          case 3:
               printf("Entrez le premier entier : ");
               scanf("%d", &n);
               printf("Entrez le second entier : ");
               scanf("%d", &m);
               entier2binaire(tab, n);
               entier2binaire(tab2, m);
               tab3 = and(tab, tab2);
               printf(" p  = 'B' %s \n",  tab);
               printf(" q  = 'B' %s \n",  tab2);
               printf("p^q = 'B' %s \n",  tab3);
               goto op;
               break;

          case 4:
               printf("Entrez le premier entier : ");
               scanf("%d", &n);
               printf("Entrez le second entier : ");
               scanf("%d", &m);
               entier2binaire(tab, n);
               entier2binaire(tab2, m);
               tab4 = add(tab, tab2);
               printf(" p  = 'B' %s \n",  tab);
               printf(" q  = 'B' %s \n",  tab2);
               printf("p+q = 'B' %s \n",  tab4);
               goto op;
               break;

          case 5:
               printf("Entrez l'entier : ");
               scanf("%d", &n);
               printf("Entrez le nombre de bits de decallage vers la gauche : ");
               scanf("%d", &m);
               entier2binaire(tab, n);
               printf("  p = 'B' %s \n", tab);
               car = lsl(m, tab);
               printf("l~p = 'B' %s => %c\n", tab, car);
               goto op;
               break;

          case 6:
               printf("Entrez l'entier : ");
               scanf("%d", &n);
               printf("Entrez le nombre de bits de decallage vers la droite : ");
               scanf("%d", &m);
               entier2binaire(tab, n);
               printf("  p = 'B' %s \n", tab);
               car = lsr(m, tab);
               printf("r~p = 'B' %s => %c\n", tab, car);
               goto op;
               break;

          case 7:
               printf("Entrez l'entier : ");
               scanf("%d", &n);
               printf("Entrez le nombre de bits de rotation vers la gauche : ");
               scanf("%d", &m);
               entier2binaire(tab, n);
               printf("    p = 'B' %s \n", tab);
               car = rol(m, tab);
               printf("LOL p = 'B' %s => %c\n", tab, car);
               goto op;
               break;

          case 8:
               printf("Entrez l'entier : ");
               scanf("%d", &n);
               printf("Entrez le nombre de bits de rotation vers la droite : ");
               scanf("%d", &m);
               entier2binaire(tab, n);
               printf("    p = 'B' %s \n", tab);
               car = ror(m, tab);
               printf("LOR p = 'B' %s => %c\n", tab, car);
               goto op;
               break;

          case 9:
               printf("Entrez le binaire : ");
               scanf("%s", tab3);
               n = binaire2entier(tab3);
               switch(n)
               {
               case 0:
               printf("%s n'est pas un binaire \n", tab3);
               goto op;
               break;
               default:
               printf("'B' %s = %d \n", tab3, n);
               goto op;
               break;
               }

          default:
                  printf("Mauvaise entree! \n");
                  goto op;
                  break;

        }
 }
 else
 {
                  printf("Mauvaise entree! \n");
                  goto end;
}






   end:
      system("PAUSE");
      return 0;
}

/* La fonction qui converti un entier positif en binaire sur 20 bits*/
int entier2binaire(char *ch, int n)
{
int retour;
int i = 0;

if( n < 0)
{
retour = MAUVAIS;
}
else{
while(i < BITS)
{
*(ch + i) = ((n%BASE) + '0');
n /=2;
i++;
}
 if(n != 0)
retour = OVER;
else{
*(ch + BITS)= EOS;
reverse(ch);
retour = BON;
}
}


return retour;
}

/*La procedure qui renverse une chaine */
void reverse(char *ch)
{
int i, n;
char ch2[BITS];
n = BITS;
i = 0;
strcpy(ch2, ch);
while((*(ch + n - 1) = *(ch2 + i)) != EOS)
{
n--;
i++;
}
}

/* que fait cette fonction? */
int powrec(int base, int n)
{
int i, result = 0;
for(i=0; i<n; i++)
result += pow(base, i);

return result;
}

/* complement logique */
void not(char *tab)
{
int i = 0;
while(*(tab + i) != EOS)
{
*(tab + i) = (*(tab + i) == '0')? '1' : '0';
i++;
}
}

/* et logique */
char* and(char *ch1, char* ch2)
{
int i ;
char *ch;
ch = (char*)malloc((strlen(ch1)+1)*sizeof(char));
i = 0;

while(*(ch1 + i) != EOS)
{
*(ch + i) = ((*(ch1 + i) == '0') || (*(ch2 + i) == '0'))?  '0' : '1';
i++;
}
*(ch + i) =EOS;
return ch;
}

/* addition entre registre */
char* add(char *ch1, char *ch2)
{
char *ch;
int eval, i, r, n;
i = 0;
r = 0;
n = strlen(ch1) - 1;

ch = (char*)malloc((n + 1)*sizeof(char ));
while(n >=0 )
{
 eval = *(ch1 + n) + *(ch2 + n) -'0' - '0' + r;

if(eval == 0)
{
*(ch + n) = '0';
r = 0;
}
if(eval == 1)
{
*(ch + n) = '1';
r = 0;
}
if(eval == 2)
{
*(ch + n) = '0';
r = 1;
}
if(eval == 3)
{
*(ch + n) = '1';
r = 1;
}
n--;
}
 *(ch + BITS) = EOS;
 if(r)
printf("retenu = %d \n", r);
return ch;
}

/* decallage logique de val bits a gauche */
char lsl(int val, char *ch)
{
char *ch1, car;
int i, n;
i = 0;
n = strlen(ch);

car = *(ch + val -1);
while( i < (n - val))
{
*(ch + i) = *(ch + i + val);
i++;
}

while(*(ch + i) != EOS)
{
*(ch + i) = '0';
i++;
}
return car;
}

/* decallage logique de val bits a droite */
char lsr(int val, char *ch)
{
char *ch1, car;
int i, n;

reverse(ch);
car = lsl(val, ch);
reverse(ch);
return car;
}

/* rotation d'un bit à gauche, pourquoi? */
char rol_single(char *ch)
{
int i;
char car;
i=0;
car = *ch;
while(*(ch + i + 1) != EOS)
{
*(ch + i) = *(ch + i +1);
i++;
}
*(ch + i) = car;

return car;
}

/* rotation de val bit a gauche */
char rol(int val, char *ch)
{
char car;
int i = 0;
car = *(ch + val-1);
while(i < val)
{
rol_single(ch);
i++;
}

return car;
}


/* rotation de val bits a droite */
char ror(int val, char *ch)
{
char car;
reverse(ch);
car = rol(val, ch);
reverse(ch);
 return car;
 }

 int binaire2entier(char *ch)
 {
 int i, result, n;
 i = 0;
 result = 0;

 n = strlen(ch) -1;

 while(*(ch + i) != EOS)
 {
 if(*(ch + n) != '0' && *(ch + n) != '1')
 {
 result = MAUVAIS;
 break;
 }
 else{
 result += (*(ch + n) -'0')*pow(BASE, i);
 i++;
 n--;
 }
 }

 return result;
 }