bonjour,
 
qqn pourrait m'explique comment convertir en asm une suite de caractéres ASCII en hexa puis en décimal ? Je vous donne un exemple :
 
angel en hexa donne 616E67656Ch et 616E67656Ch en décimal donne 418464097644, je voudrai donc obtenir cette procédure en asm pour l'insérer ensuite dans mon proggie mais je ne sais pas comment faire ... de plus je souhaiterai savoir si cela est valable pour x caractéres ? (x == l'infini)
 
Merci à vous !

 
 
 
 
Personne ne prog en asm ?  

Angelicca a écrit a écrit :   Personne ne prog en asm ?

 
Pas moi  

Très difficile l'ASM.... bon courage et mes respects !

PompUsine a écrit a écrit : Très difficile l'ASM.... bon courage et mes respects !

 
disons que c'est plus un jeu qu'autre chose, c'est amusant de manier des registres  
 
 

Pkoi en asm ?

Parceque l'ASM en fait c'est ZE langage...
Tu peux tout faire en ASM, ce que tu peux faire en JAVA, C, C++... tu peux le faire en ASM, mais tu ne peux pas forcément faire l'inverse  

 
comme ça en fait    ,disons que mon prog est en une partie en C++, et une autre partie en asm ( avec asm {} ) et je suis interessé par ce genre de conversion de bas niveau capable d'etre effectuées en asm ...
 
voila  
 
 

PompUsine a écrit a écrit : Parceque l'ASM en fait c'est ZE langage... Tu peux tout faire en ASM, ce que tu peux faire en JAVA, C, C++... tu peux le faire en ASM, mais tu ne peux pas forcément faire l'inverse

 
Bien en fait moi je dit le contraire, en C++ tu peux incorporer du ASM donc tu peux tout faire ce que ASM peut faire et encore plus  

pour l'hexa en binaire pur, tu prends chaque chiffre hexa
de gauche à droite
 
registre final<-0
 
pour chaque chiffre  
    shift registre final 4 bits vers la gauche
   
    si <= '9'          (0 à 9)
      registre temporaire<-chiffre-'0'
    sinon              ('A' à 'F' ou 'a' à 'f'
      si chiffre > 'F'
         chiffre = chiffre + 'A' - 'a' (conversions caps)
      finsi
    registre temporaire<-chiffre-'A'+ 10
  finsi
   
  registre final <- reg final OU LOGIQUE reg temporaire
 
fin pour
 
valà

[edtdd]--Message édité par bjone--[/edtdd]

l'asm est très simple et basique....
ça colle avec l'algo....
 
quand on sait faire de l'asm, on est capable de voir les problèmes avec beaucoup plus de simplicité...
c ce qui manque à beaucoup de programmeurs la simplicité...

en asm x86 ça donnerai un truc dans ce gout: (version code de warrior pas décidé )
 
esi <= chaine de caractère
ecx <= longueur  
 
xor eax,eax
xor ebx,ebx
 
lp:
  shl eax,4
  mov bl,[esi]
  cmp bl,'9'
  ja AZrange
  sub bl,'0'
  jmp ok
AZrange:
   cmp bl,'Z'
   jbe AZOk
   add bl,'A'-'a'
AZOk:
   add bl,10-'A'
ok:
  or eax,ebx
  inc esi
  dec ecx
  jnz lp
 
eax <= valeur

reg src <= valeur
 
tant que reg src > 9
   reg src ; reg reste <- reg src/10
   ajouter reg reste + '0' à la chaine
   et avancer dans la chaine vers la gauche
fin tant que
ajouter reg src + '0' à la chaine
 
heu c ça ?
 
putainnnnnnnnnn je dois réfléchir
 
donc la valeur 100  
 
reg src <- 100
 
passe 1
  div 10
  reg src <- 10
  reste 0
  chaine=>          0
passe 2
  div 10
  reg src <- 1
  reste 0
  chaine =>        00
fin src < 10
chaine =>         100
 
donc en asm:
 
edi : pointe sur la "fin" d'un tableau d'au moins 14 caractères
 
eax <- valeur src
 
mov ebx,10
lp:
  cmp eax,9
  ja fini
   
  xor edx,edx  
 
  div ebx  
  (division de edx:eax par ebx, 64 bits/32bits => 32 bits)
 
  add dl,'0'
  mov [edi],dl
  inc edi
  jmp lp
 
fini:
 
add al,'0'
mov [edi],al
 
vala...
à toi de rajouter la gestion du signe si tu veux, et de corriger si j'ai marqué des conneries...

[edtdd]--Message édité par bjone--[/edtdd]

c vrai que pris comme ça c pas lisible
enfin une petit révision..... ça fait po de mol

merci bjone, je vais étudier ça
 
 

Ca me semble plus complique que ca la conversion hexa -> numerique surtout si la chaine hexa peut etre infini... pour ascii hexa en asm par contre c'est bcp plus facile
 
 char *Ascii;
 char *Hex;
 
 Ascii=new char[256];
 Hex=new char[256];
 sprintf(Ascii,"angel" );
 
 __asm
 {
  // Ascii pointeur sur car, chaine terminée par 0
  // Hex pointeur sur car, chaine terminée par 0
  mov edx,Ascii
  mov ebx,Hex
whileptpas0:
  mov cl,[edx]
  cmp cl,0
  je  FinWhile
  //cl=Ascii[i]>>4
  sar cl,4
  //if(c>9)
  cmp cl,9
  jle Infa9
  add cl,37h //'A'-10
  jmp Suite
Infa9:
  add cl,30h // '0'
Suite:
  mov [ebx],cl
  inc ebx
  mov cl,[edx]
  //c=Ascii[i]& 0fh
  and cl,0fh
  cmp cl,9
  jle Infa9_2
  add cl,37h //'A'-10
  jmp Suite_2
Infa9_2:
  add cl,30h // '0'
Suite_2:
  mov [ebx],cl
  inc ebx
  inc edx
  jmp whileptpas0
FinWhile:
  mov byte ptr[ebx],0 // 0 final sur la chaine Hex
 
 }
 
 
 printf("%s\n",Hex);
 delete []Ascii;
 delete []Hex;

aïe aïe aïe ... je suis content d'être né 20 ans plus tard et de pas avoir eu tout ca à me patoger !!  
 
vive le java !!!!!

[edtdd]--Message édité par benou--[/edtdd]

 
c clair c rapidement illisible....
c pour ça qui faut garder l'asm pour les routines critiques en temps...