Conversion hexa avec nombre de byte variables

Version imprimable

06/06/2011, 15h27
Pascale38

Conversion hexa avec nombre de byte variables

Bonjour,

J'ai besoin d'une fonction qui me convertit une chaine repr�sentant de l'hexa en un int.
Je connais bien les fonctions de conversion classique StrToInt, StrToInt64, etc...
Sauf que la valeur que je dois convertir a une taille qui varie de 1 � 8 byte et cela � son importance car si par exemple la taille est de 2, ma valeur h�xa "E0C0" doit �tre convertit en -8000 et non en 57536.
Par contre si la taille vaut 4, l� oui je voudrai avoir la valeur 57536...
Il me faudrait donc une fonction "StrTo" plus g�n�rique, qui convertisse en h�xa mais � laquelle on puisse fournir la "taille" de la valeur en byte... Afin que les valeurs n�gatives soient converties correctement...
J'esp�re que je suis claire, j'en suis pas tr�s s�re !!!!
merci pour votre aide !!

Pascale38

IntToHex et StrToInt pour de la conversion num�rique 32 Bits !

HexToBin et BinToHex pour du Binaire Pur non sign�

Enfin, avec un petit peu de connaissance de l'architecture Little Endian du 686, la convertion par cast ou par affectation est tr�s simple !
Code:

1 2 3 4 function StrToIntSigned16(const S: string): Smallint; begin Result := Smallint(StrToInt(S)); // cast pour bien comprendre, mais je ne le crois pas obligatoire ! end;
Code:

1 2 3 4 short __fastcall StrToIntSigned16(const AnsiString S) { return (short)StrToInt(S); // le cast n'est même pas obligatoire, l'affectation est brute ! }
Code:

1 2 3 4 5 ShowMessage("0xE0C0 : " + IntToStr(StrToIntSigned16("0xE0C0"))); ShowMessage("$E0C0 : " + IntToStr(StrToIntSigned16("$E0C0"))); short IntSigned16 = StrToInt("0xE0C0"); ShowMessage("E0C0 Direct : " + IntToStr(IntSigned16));

06/06/2011, 16h49
Pascale38

merci pour ta r�ponse.

Ce que je voudrais �viter c'est justement de devoir caster en "short" si la taille de la valeur � convertir est de 2, en int si elle est de 4 en int64 si elle est de 8, etc...
Je voudrai savoir s'il n'est pas possible de faire �a de fa�on "g�n�rique".

HexToBin ne m'int�resse pas vraiment car je veux une valeur d�cimale...
A moins qu'il y ai un moyen simple ensuite de convertir ce binaire en d�cimal ??

merci !
Pascale38

Citation:

Envoy� par Pascale38

Ce que je voudrais �viter c'est justement de devoir caster en "short" si la taille de la valeur � convertir est de 2, en int si elle est de 4 en int64 si elle est de 8, etc...

Tu ne peux pas d�passer 8 pour des nombres entiers g�r�s nativement en C++, apr�s il faut passer � des lib comme l'�quivalent du BigInteger du C# 4.0

Si tu reste � 2, 4 et 8, tu utilises du Int64 syst�matiquement !
Tu v�rifies la taille de la chaine Hexa pour d�terminer quel est le bit de poids fort avec BTS, tu retire ce bit (16eme ou 32eme), et tu le remplace au 64eme bit (avec compl�ment binaire), ainsi tu conserve le signe sans avoir besoin de caster !

Ou autre m�thode, en fonction de la longueur tu choisi le cast !
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 //--------------------------------------------------------------------------- __int64 __fastcall StrToSignedInt(const AnsiString S) { int L = S.Length(); if (L >= 3) { if (S[1] == '0') { if (S[2] == 'x') L=-2; } else { if (S[1] == '$') L--; } switch (L) { case 2: return (char)StrToInt(S); case 4: return (short)StrToInt(S); case 8: return StrToInt(S); case 16: return StrToInt64(S); } } throw EConvertError(Sysconst_SInvalidInteger, OpenArray<TVarRec>(S), 0); }

06/06/2011, 17h33
Pascale38

oui caster selon la taille c'est bon j'ai depuis le d�but �a !! ;)

Par contre l� :

Citation:

Tu v�rifies la taille de la chaine Hexa pour d�terminer quel est le bit de poids fort avec BTS, tu retire ce bit (16eme ou 32eme), et tu le remplace au 64eme bit, ainsi tu conserve le signe sans avoir besoin de caster !

:mrgreen::calim2:
heu c'est trop fort pour moi 8O
Comment je fais �a ??
et BTS c'est quoi ???
Bon enfin si tu as le temps hein, parce que bon moi ce que je voulais c'est faire un truc "propre" quoi mais bon c'est pas grave !
merci en tout cas !!
Pascale38
07/06/2011, 11h26
Pascale38

Heu en fait le fait de "caster" ne r�ponds qu'� moiti� � mon probl�me, vu qu'en fait la taille peut �tre aussi 3 ou 5 ou 6 ou 7, et dans ces cas l� je n'ai pas de type pour caster !!
Donc retour � la case d�part...
Donc peux tu m'�clairer sur la m�thode dont tu parles l� :

Citation:

Tu v�rifies la taille de la chaine Hexa pour d�terminer quel est le bit de poids fort avec BTS, tu retire ce bit (16eme ou 32eme), et tu le remplace au 64eme bit (avec compl�ment binaire), ainsi tu conserve le signe sans avoir besoin de caster !

merci d'avance !
Pascale38

La notion de "propre" est toute relative !
utiliser le type de la bonne taille c'est LA m�thode !
La Longueur de la chaine source est d�j� une bonne indication !
Sinon, il faudrait utiliser le Log2 pour ne pas d�pendre la longueur de la chaine mais de la longueur du nombre en octet

Tiens, du tr�s vilain ASM !
Il y a surement mieux pour mettre les 1 du compl�ment � 2 mais bon, �a devrait �tre bon

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
#pragma inline
__int64 __fastcall BitSignReplace(int I /*EAX*/, short ByteCount /*EDX*/)
{
  __int64 Result;
  bool b = false;
  asm
  {
    MOV ECX, EDX
    SHL ECX, 3
    DEC ECX
 
    IfNeg:
    BT EAX, ECX
    JNC EndIfNeg
    MOV b, 1;
    EndIfNeg:
 
    MOV I, EAX
  }
  if (b)
  {
    switch (ByteCount)
    {
      case 1: Result = 0xFFFFFFFFFFFFFF00i64 | I; break;
      case 2: Result = 0xFFFFFFFFFFFF0000i64 | I; break;
      case 4: Result = 0xFFFFFFFFFF000000i64 | I; break;
    }
  }
  else
    Result = I;
 
  return Result;
}
 
 
//---------------------------------------------------------------------------
__int64 __fastcall StrToSignedInt(const AnsiString S)
{
  __int64 Result = StrToInt64(S);
 
  int P = Log2(Result);
  if ((0 <= P) && (P < 8))
  {
    return BitSignReplace(Result, 1);
  }
  else if ((8 <= P) && (P < 16))
  {
    return BitSignReplace(Result, 2); 
  }
  else if ((16 <= P) && (P < 32))
  {
    return BitSignReplace(Result, 4); 
  }
  else
    return Result;
}

Cela reste limit� au syst�me normal 1, 2 et 4 pour short, smallint et integer

En faisant le positionnement des Bits un par un (ouch)
Ce qui radicalement le r�sultat, � toi de savoir quels sont les positions du Bit de Signe autre que 7, 15 et 31 !

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
#pragma inline
__int64 __fastcall BitSignReplaceByBTS(int I /*EAX*/, int OldBitSign /*EDX*/)
{
  __int64 Result;
  bool b = false;
  asm
  {
    BT EAX, EDX
    JNC EndIf
    MOV b, 1;
    EndIf:
 
    MOV I, EAX
  }
  if (b)
  {
    asm
    {
      MOV ECX, 31
      MOV EAX, I
 
      StartLoop:
      CMP ECX, OldBitSign
      JE EndLoop
 
      BTS EAX, ECX
      DEC ECX
      JMP StartLoop
      EndLoop:
 
      MOV I, EAX
    }
    Result = 0xFFFFFFFF00000000i64 | I;
  }
  else
    Result = I;
 
  return Result;
}
 
//---------------------------------------------------------------------------
__int64 __fastcall StrToSignedIntByBTS(const AnsiString S)
{
  __int64 Result = StrToInt64(S);
 
  int P = Log2(Result);
  if ((0 <= P) && (P < 32))
  {
    return BitSignReplaceByBTS(Result, P);
  }
  else
    return Result;
}

L� tu me parlerais chinois que �a me ferait le m�me effet :mouarf:
Trop trop bas niveau pour moi.

Par contre je crois que j'ai trouv� ce que je cherchais (� partir d'un tableau de BYTE).
J'ai mis tout �a dans une fonction et voil� le r�sultat :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 __int64 ByteToInt(BYTE * array, int size){ int shift = (size - 1) * 8; long l=0; for (int i=0; i<size; i++, shift -= 8) { l += ((long) 0xFF & array[i]) << shift; } long hiOrderBit = ((long) array[0] & 0x80); if (hiOrderBit == 0x80){ __int64 mask = ((__int64) -1 << (size * 8)); l = l | mask; } return l; }
�a � l'air de fonctionner pas mal, et en tout cas de bien r�pondre � mon besoin !
Qu'en penses tu ?

Encore merci pour ton aide !!
Pascale38

Effectivement, tu g�res manuellement les octets en pensant qu'avec le LittleEndian l'ordre est invers� dans le tableau par rapport � ce que l'on �crirait en tant qu'humain !
C'est tr�s bien ta m�thode est nettement plus propre, du coup tu utilises BinToHex pour obtenir ton Byte* ?

Sinon, pour info, en modifiant StrToSignedIntByBTS, on obtient le m�me r�sultat !
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 //--------------------------------------------------------------------------- __int64 __fastcall StrToSignedIntByBTS(const AnsiString S) { __int64 Result = StrToInt64(S); double P = Log2(Result); if ((0 <= P) && (P < 56)) { return BitSignReplaceByBTS(Result, Ceil(P / 8) * 8 - 1); } else return Result; }
On pouvait obtenir aussi l'�quivalent en modifiant le switch
Code:

1 2 3 4 5 6 7 8 9 10 11 switch (ByteCount) { case 1: Result = 0xFFFFFFFFFFFFFF00i64 | I; break; case 2: Result = 0xFFFFFFFFFFFF0000i64 | I; break; case 3: Result = 0xFFFFFFFFFF000000i64 | I; break; case 4: Result = 0xFFFFFFFF00000000i64 | I; break; case 5: Result = 0xFFFFFF0000000000i64 | I; break; case 6: Result = 0xFFFF000000000000i64 | I; break; case 7: Result = 0xFF00000000000000i64 | I; break; }

07/06/2011, 16h33
Pascale38

ma m�thode 8O faut pas exag�rer, c'est de la r�cup hein, je n'en suis pas l'auteur !!! :mrgreen: donc les f�licitations � celui qui l'a �crite...

ben du coup non je n'ai pas utilis� BinToHex vu qu'� la base je re�ois directement les octets dans un char* ... Je l'avais convertit en String car plus lisible mais bon...

En ce qui concerne ta m�thode, le probl�me, c'est que je ne pense pas que mon client soit tr�s content s'il voit de l'assembleur dans mon code... :roll:

En tout cas merci beaucoup pour ton aide, et je mets le poste en r�solu !

Pascale38