Code ASCII étendu et console

Bonjour,

J'esp=E8re ne pas me tromper de section. Etant donn=E9 que je cherche des
informations sur l'encodage des caract=E8re, je suppose que je suis au
bon endroit. En gros je cherche =E0 tester les lettres de l'ascii =E9tendu
afin de leur assigner une valeur d=E9cimale de mani=E8re =E0 pouvoir
application mon "encryption".

Pour m'entra=EEner j'essaye de manipuler les chaines de caract=E8res ainsi
que la lecture/=E9criture de fichiers. Le code suivant permet
"d'encrypter" selon une transformation tr=E8s complexe :joke:, les
caract=E8res A-Z et 0-9, tout autre caract=E8re est sinon transform=E9 en
'x'. Le programme lit un fichier contenant la chaine de caract=E8re =E0
transformer puis ensuite il fait son boulot.

Maintenant j'aimerais pouvoir le faire avec tout les caract=E8res du
code ASCII =E9tendu. J'utilise la fonction CharToOem pour afficher ces
caract=E8res. Jusque l=E0 pas de soucis. Quand je viens =E0 les tester c'es=
t
autre chose afin de leur assigner leur valeur d=E9cimale. Je sais que
pour le '=E9' ont peut l'afficher en utilisant \202, donc en faisant le
test avec cela, la transformation s'op=E8re. Maintenant pour les autres
caract=E8res, comment je fais pour obtenir ces codes s'ils existent ?
Oui je vais me taper 256 lignes -.-. Je ne vois pas comment faire
autrement. Peut =EAtre que je me fourvoie et qu'il y a mieux =E0 faire ?

Merci d'avance


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



int TailleFichier ( FILE
*fichier );
void MemoriserFichier ( FILE *fichier, char
*Chaine );
void CharToInt ( char *Chaine, int Taille, int
*Entier );
void Encryption ( int *Entier, int Taille, int
*EntierEncryptes );
void MethodeEncryption ( int *Entier, int Taille, char
*Chaine );
void AfficherTableauChar ( char *Tableau, int
Taille );
void AfficherTableauInt ( int *Tableau, int
Taille );

int main (void)
{

// On compte le nombre de charact=E8res dans le fichier
FILE *f0 =3D fopen("cle.txt","r");
int taille=3DTailleFichier(f0);
fclose(f0);

// On alloue en m=E9moire les tableaux n=E9cessaires
char *Raw =3D malloc(taille*sizeof(char));
char *Temp =3D malloc(taille*sizeof(char));
char *Encrypted =3D malloc(taille*sizeof(char));
int *RawToAscii =3D malloc(taille*sizeof(int ));
int *AsciiToEncrytp =3D malloc(taille*sizeof(int ));

printf("taille=3D%d\n",taille);

// On enregistre la chaine de caract=E8res contenue dans le fichier
FILE * f1 =3D fopen("cle.txt","r");
MemoriserFichier(f1, Temp);
fclose(f1);


CharToOem ( Temp,Raw );
CharToInt ( Raw, taille, RawToAscii );
Encryption ( RawToAscii, taille, AsciiToEncrytp );
MethodeEncryption( AsciiToEncrytp, taille, Encrypted );

AfficherTableauChar(Raw, taille );
printf("\n");
AfficherTableauInt (RawToAscii, taille );
printf("\n");
AfficherTableauInt (AsciiToEncrytp, taille);
printf("\n");
AfficherTableauChar(Encrypted, taille );

getchar();
}

void AfficherTableauChar( char *Tableau, int Taille )
{
int i=3D0;
for ( i ; i<Taille ; i++ )
{
printf("%c",Tableau[i]);
}
}

void AfficherTableauInt( int *Tableau, int Taille )
{
int i=3D0;
for ( i ; i<Taille ; i++ )
{
printf("%d",Tableau[i]);
}
}


int TailleFichier( FILE *fichier )
{
int taille=3D0;
char c;
if(fichier !=3D NULL)
{
while(fscanf(fichier,"%c",&c) !=3D EOF)
{
taille++;
}
}

return taille;
}


void MemoriserFichier( FILE *fichier, char *Chaine )
{
if(fichier !=3D NULL)
{
int i=3D0;
char c;
while(fscanf(fichier,"%c",&c) !=3D EOF)
{
Chaine[i]=3Dc;
i++;
}
}
}

void CharToInt( char *Chaine, int Taille, int *Entier )
{

int i=3D0;
for ( i ; i<Taille ; i++ )
{

char c=3DChaine[i];
switch ( c )
{

case '\201' :
Entier[i]=3D10;
break;

case 'B' :
Entier[i]=3D11;
break;

case 'C' :
Entier[i]=3D12;
break;

case 'D' :
Entier[i]=3D13;
break;

case 'E' :
Entier[i]=3D14;
break;

case 'F' :
Entier[i]=3D15;
break;

case 'G' :
Entier[i]=3D16;
break;

case 'H' :
Entier[i]=3D17;
break;

case 'I' :
Entier[i]=3D18;
break;

case 'J' :
Entier[i]=3D19;
break;

case 'K' :
Entier[i]=3D20;
break;

case 'L' :
Entier[i]=3D21;
break;

case 'M' :
Entier[i]=3D22;
break;

case 'N' :
Entier[i]=3D23;
break;

case 'O' :
Entier[i]=3D24;
break;

case 'P' :
Entier[i]=3D25;
break;

case 'Q' :
Entier[i]=3D26;
break;

case 'R' :
Entier[i]=3D27;
break;

case 'S' :
Entier[i]=3D28;
break;

case 'T' :
Entier[i]=3D29;
break;

case 'U' :
Entier[i]=3D30;
break;

case 'V' :
Entier[i]=3D31;
break;

case 'W' :
Entier[i]=3D32;
break;

case 'X' :
Entier[i]=3D33;
break;

case 'Y' :
Entier[i]=3D34;
break;

case 'Z' :
Entier[i]=3D35;
break;

case '0' :
Entier[i]=3D0;
break;

case '1' :
Entier[i]=3D1;
break;

case '2' :
Entier[i]=3D2;
break;

case '3' :
Entier[i]=3D3;
break;

case '4' :
Entier[i]=3D4;
break;

case '5' :
Entier[i]=3D5;
break;

case '6' :
Entier[i]=3D6;
break;

case '7' :
Entier[i]=3D7;
break;

case '8' :
Entier[i]=3D8;
break;

case '9' :
Entier[i]=3D9;
break;

default :
Entier[i]=3D999;
break;

}
}

}

void Encryption( int *Entier, int Taille, int *EntierEncryptes )
{
int i=3D0;
for ( i ; i<Taille ; i++ )
{
EntierEncryptes[i] =3D 35-Entier[i];
}
}

void MethodeEncryption( int *Entier, int Taille, char *Chaine )
{

int i=3D0;
for ( i ; i<Taille ; i++ )
{

int e=3DEntier[i];
switch ( e )
{

case 0 :
Chaine[i]=3D'0';
break;

case 1 :
Chaine[i]=3D'1';
break;

case 2 :
Chaine[i]=3D'2';
break;

case 3 :
Chaine[i]=3D'3';
break;

case 4 :
Chaine[i]=3D'4';
break;

case 5 :
Chaine[i]=3D'5';
break;

case 6 :
Chaine[i]=3D'6';
break;

case 7 :
Chaine[i]=3D'7';
break;

case 8 :
Chaine[i]=3D'8';
break;

case 9 :
Chaine[i]=3D'9';
break;

case 10 :
Chaine[i]=3D'\201';
break;

case 11 :
Chaine[i]=3D'B';
break;

case 12 :
Chaine[i]=3D'C';
break;

case 13 :
Chaine[i]=3D'D';
break;

case 14 :
Chaine[i]=3D'E';
break;

case 15 :
Chaine[i]=3D'F';
break;

case 16 :
Chaine[i]=3D'G';
break;

case 17 :
Chaine[i]=3D'H';
break;

case 18 :
Chaine[i]=3D'I';
break;

case 19 :
Chaine[i]=3D'J';
break;

case 20 :
Chaine[i]=3D'K';
break;

case 21 :
Chaine[i]=3D'L';
break;

case 22 :
Chaine[i]=3D'M';
break;

case 23 :
Chaine[i]=3D'N';
break;

case 24 :
Chaine[i]=3D'O';
break;

case 25 :
Chaine[i]=3D'P';
break;

case 26 :
Chaine[i]=3D'Q';
break;

case 27 :
Chaine[i]=3D'R';
break;

case 28 :
Chaine[i]=3D'S';
break;

case 29 :
Chaine[i]=3D'T';
break;

case 30 :
Chaine[i]=3D'U';
break;

case 31 :
Chaine[i]=3D'V';
break;

case 32 :
Chaine[i]=3D'W';
break;

case 33 :
Chaine[i]=3D'X';
break;

case 34 :
Chaine[i]=3D'Y';
break;

case 35 :
Chaine[i]=3D'Z';
break;

default :
Chaine[i]=3D'x';
break;

}
}

}