besoin d'explication d'une algorithme

Version imprimable

Bonjours

Le code suivant represente les octets lus sous cette forme

http://img682.imageshack.us/img682/2...titre1ffff.jpg

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
void hexdump(unsigned char *data, unsigned int amount) 
 
{
 
      unsigned int      dp, p;
      const char        trans[] =
      "................................ !\"#$%&'()*+,-./0123456789"
      ":;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklm"
      "nopqrstuvwxyz{|}~...................................."
      "....................................................."
      "........................................";
 
   for (dp = 1; dp <= amount; dp++)  {
      printf ("%02x ", data[dp-1]);
      if ((dp % 8) == 0)
         printf (" ");
      if ((dp % 16) == 0) {
         printf ("| ");
         p = dp;
         for (dp -= 16; dp < p; dp++)
            printf ("%c", trans[data[dp]]);
         printf ("\n");
      }
   }
   if ((amount % 16) != 0) {
      p = dp = 16 - (amount % 16);
      for (dp = p; dp > 0; dp--) {
         printf ("   ");
         if (((dp % 8) == 0) && (p != 8))
            printf (" ");
      }
      printf (" | ");
      for (dp = (amount - (16 - p)); dp < amount; dp++)
         printf ("%c", trans[data[dp]]);
   }
   printf ("\n");
   return ;
}

data : pointe sur l'adresse de départ
amount : longueur

je l'ai trouvé dans un code source d'un hex editor et je n arrive pas à le comprendre

pouvez vous m'expliquer l'algorithme utilisé dans le code
merci d'avance

03/04/2010, 17h18
bruno_pages

Bonjour,

Citation:

Envoyé par Koty20

amount : langueur

:lol: c'est sans doute un lapsus
vous vouliez dire longueur

honnêtement ce code est très simple à comprendre, et je ne vais quand même pas tout expliquer ligne à ligne, donc indiquez qu'elle partie du code vous ne comprenez pas

P.S. ce code n'est pas du C++ mais du C, vous avez donc posté au mauvais endroit

:mouarf:

le loop suivant :

Code:

for (dp -= 16; dp < p; dp++)

et la partie :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
  if ((amount % 16) != 0) {
      p = dp = 16 - (amount % 16);
      for (dp = p; dp > 0; dp--) {
         printf ("   ");
         if (((dp % 8) == 0) && (p != 8))
            printf (" ");
      }
      printf (" | ");
      for (dp = (amount - (16 - p)); dp < amount; dp++)
         printf ("%c", trans[data[dp]]);
   }
   printf ("\n");
   return ;
}

03/04/2010, 18h48
screetch

c'est du code assez mauvais (du moins pour la relecture...)
le code lit chaque octet pour l'ecrire sous forme exadéimale. Puis il revient en arrière de 16 octets, et réaffiche le tout comme si c'etait de l'ascii'le premier point dont tu parles : la boucle for en question repart de 16 octets en arriere pour les réafficher en ascii

le deuxieme point : si la taille du buffer a afficher en hexadecimal n'est pas un multiple exact de 16, alors ce code affiche le reste. c'est quasiment un copié collé du bidule au dessus mais ca prend en compte le cas ou la derniere ligne ne contient que 5 octets par exemple, au lieu de 16
03/04/2010, 22h54
Koty20

Merci screetch :ccool:

Peut-tu m'écrire le code d'une manière simple ?:oops:

une possibilité un peu moins tordue

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
static const char s_trans[] =
      "................................ !\"#$%&'()*+,-./0123456789"
      ":;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklm"
      "nopqrstuvwxyz{|}~...................................."
      "....................................................."
      "........................................";
void hexdump(unsigned char *data, unsigned long amount)
{
    unsigned long current;
    unsigned long extendedAmount;
    static const lineSize = 16;
 
    /* Arrondit amount au multiple de lineSize supérieur */
    extendedAmount = ((amount+lineSize-1)/lineSize)*lineSize;
 
    for (current = 0; current < extendedAmount; current++)
    {
        if(current < amount)
        {
            printf ("%02x ", data[current]);
        }
        else
        {
            printf("   ");
        }
        // a la moitié de la ligne, ajouter un espace
        if ((current % (lineSize/2)) == lineSize/2 - 1)
            printf (" ");
        /* a la fin de la ligne, un espace et le récapitulatif */
        if (((current % lineSize) == lineSize - 1))
        {
            unsigned int previous = current - 16;
            printf ("| ");
            for (previous = current - 15; previous <= current && previous < amount; previous++)
            {
                printf ("%c", s_trans[data[previous]]);
            }
            printf ("\n");
        }
    }
    printf ("\n");
    return;
}

un code avec deux for imbriqués qui me parait le plus naturel :

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
static const char s_trans[] =
      "................................ !\"#$%&'()*+,-./0123456789"
      ":;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklm"
      "nopqrstuvwxyz{|}~...................................."
      "....................................................."
      "........................................";
 
void hexdump(unsigned char *data, unsigned long amount)
{
    unsigned long currentLine;
    static const lineSize = 16;
 
    for (currentLine = 0; currentLine < amount; currentLine += lineSize)
    {
        int lineCounter;
        for(lineCounter = 0; lineCounter < lineSize; ++lineCounter)
        {
            int current = currentLine + lineCounter;
            if(current < amount)
            {
                printf ("%02x ", data[current]);
            }
            else
            {
                printf("   ");
            }
            // a la moitié de la ligne, ajouter un espace
            if (lineCounter == lineSize/2 - 1)
                printf (" ");
        }
        /* a la fin de la ligne, un espace et le récapitulatif */
        printf (" | ");
        for(lineCounter = 0; lineCounter < lineSize && currentLine + lineCounter < amount; ++lineCounter)
        {
            int current = currentLine + lineCounter;
            printf ("%c", s_trans[data[current]]);
        }
        printf ("\n");
    }
    printf ("\n");
    return;
}

ce deuxième code est plus proches de l'idée originale : on ecrit 16 caractères (si on peut, sinon des espaces), puis on les réecrit en ASCII.
On peut aussi changer le nombre de colones. Le principal avantage c'est de rendre plus explicite les chiffres magiques (les 8 et les 16) mais tu pourras constater que ca marche avec 7 ou 32.

05/04/2010, 15h21
Koty20

Merci screetch :ccool: