Prototype
struct EMemory::SC_BLOCK { void *pBlock;
ulonglong ullBlockSize;
ulonglong ullReserved0;
uchar *pucReserved1;
ulong ulReserved2;
};

Cette structure est utilisée par les fonctions BlocksCountGet, BlocksFind, BlocksSubstitute et BlocksSuppress faisant office de tableau contenant, sous forme séquentielle, tous les blocs d'octets à traiter.

 

Variables membres

void *pBlock

adresse du bloc d'octets.

ulonglong ullBlockSize

taille du bloc d'octets.

Si la taille est égale à 0, cette structure n'est pas prise en compte lors de l'utilisation au sein de la fonction concernée.

ulonglong ullReserved0

cette variable est réservée à l'usage personnel des fonctions l'utilisant. Il est inutile de l'initialiser et vous ne devez pas l'utiliser.

uchar *pucReserved1

cette variable est réservée à l'usage personnel des fonctions l'utilisant. Il est inutile de l'initialiser et vous ne devez pas l'utiliser.

ulong ulReserved2

cette variable est réservée à l'usage personnel des fonctions l'utilisant. Il est inutile de l'initialiser et vous ne devez pas l'utiliser.

 

Remarque

Lorsque vous spécifiez un bloc d'octets dont une partie des données sont similaires à celles d'un autre bloc d'octets, les fonctions traitent en priorité celui qui contient le plus de données.

Eclaircissons cela par un exemple. Nous déclarons deux blocs d'octets :

Code :

EMemory eMem( "ABCAB", 5 ); // objet EMemory alloué de 5 octets
EMemory::SC_BLOCK sctBlock[] = {
  { "AB", 2, 0, 0, 0 },
  { "ABC", 3, 0, 0, 0 }
  };

Comme vous pouvez le constater, les données du premier bloc sont présentent dans le second. Si l'on écrit une fonction de recherche simple, le second bloc d'octets ne sera jamais trouvé car le premier le sera toujours en premier. La fonction nous dirait qu'elle a trouvé le bloc 0x41 et 0x42 à l'offset 0 et à l'offset 3.

La problématique n'est pas une histoire d'ordre d'énumération des blocs (les fonctions de l'objet EMemory n'en tiennent pas compte). Nous aurions bien pû déclarer la série de blocs d'octets comme ceci :

Code :

EMemory::SC_BLOCK sctBlock[] = {
  { "ABC", 3, 0, 0, 0 },
  { "AB", 2, 0, 0, 0 }
  };

que cela donnerait le même résultat.

Tout simplement lorsque la fonction aura trouvé les valeurs contigues 0x41 et 0x42, elle cessera son travail car elle a effectivement trouvé un bloc à chercher.

Les fonctions de l'objet EMemory utilisant les structures EMemory::SC_BLOCK tentent en priorité de traiter les blocs les plus longs parmi ceux partageant une même série d'octets.

Donc ces fonctions de l'objet nous dirons qu'elles ont traité le bloc d'octets 0x41, 0x42 et 0x43 à l'offset 0 et le bloc d'octets 0x41 et 0x42 à l'offset 3.

 

Exemple

Description :

Exemples d'initialisation de structures EMemory::SC_BLOCK et de passage en argument.

Les initialisations "automatiques" sont utiles lorsque l'on connait par avance les blocs d'octets à recherche.

Par contre les initialisations "dynamiques" sont utiles lorsque l'on ne connait pas par avance les blocs d'octets à recherche. On peut ainsi construire le tabeau de blocs d'octets suivant les besoins. Ne pas oublier de libérer la mémoire allouée dynamiquement après que l'on n'en a plus besoin.

Code :

EMemory eMem( "ABCDE", 5 ); // objet EMemory alloué de 5 octets
ulonglong ullOffsetFound;


//-------------------------------------------
//- Initialisation automatique simple directe
//-------------------------------------------

EMemory::SC_BLOCK scBlock0 = { "ABC", 3, 0, 0, 0 };

while ( eOk( eMem.BlocksFind( &ullOffsetFound, NULL, &scBlock0, 1 ) ) && ullOffsetFound != EMemory::DataNotFound )
...
... Code additionnel ...
...



//--------------------------------------------
//- Initialisation automatique simple différée
//--------------------------------------------

EMemory::SC_BLOCK scBlock1;

scBlock1.pBlock = "ABC";
scBlock1.ullBlockSize = 3;

while ( eOk( eMem.BlocksFind( &ullOffsetFound, NULL, &scBlock1, 1 ) ) && ullOffsetFound != EMemory::DataNotFound )
...
... Code additionnel ...
...



//-------------------------------------------------------
//- Initialisation automatique multiple (tableau) directe
//-------------------------------------------------------

EMemory::SC_BLOCK sctBlock2[] = {
  { "ABC", 3, 0, 0, 0 },
  { "DE", 2, 0, 0, 0 },
  { "F", 1, 0, 0, 0 }
  };

while ( eOk( eMem.BlocksFind( &ullOffsetFound, NULL, sctBlock2, 3 ) ) && ullOffsetFound != EMemory::DataNotFound )
ou
while ( eOk( eMem.BlocksFind( &ullOffsetFound, NULL, &sctBlock2[0], 3 ) ) && ullOffsetFound != EMemory::DataNotFound )
...
... Code additionnel ...
...



//--------------------------------------------------------
//- Initialisation automatique multiple (tableau) différée
//--------------------------------------------------------

EMemory::SC_BLOCK sctBlock3[3];

sctBlock3[0].pBlock = "ABC";
sctBlock3[0].ullBlockSize = 3;

sctBlock3[1].pBlock = "DE";
sctBlock3[1].ullBlockSize = 2;

sctBlock3[2].pBlock = "F";
sctBlock3[2].ullBlockSize = 1;

while ( eOk( eMem.BlocksFind( &ullOffsetFound, NULL, sctBlock2, 3 ) ) && ullOffsetFound != EMemory::DataNotFound )
ou
while ( eOk( eMem.BlocksFind( &ullOffsetFound, NULL, &sctBlock3[0], 3 ) ) && ullOffsetFound != EMemory::DataNotFound )
...
... Code additionnel ...
...



//------------------------------------------
//- Initialisation dynamique simple différée
//------------------------------------------

EMemory::SC_BLOCK *pscBlock4 = (EMemory::SC_BLOCK*)malloc( sizeof(EMemory::SC_BLOCK) );

pscBlock4->pBlock = "ABC";
pscBlock4->ullBlockSize = 3;

while ( eOk( eMem.BlocksFind( &ullOffsetFound, NULL, pscBlock4, 1 ) ) && ullOffsetFound != EMemory::DataNotFound )
...
... Code additionnel ...
...

//- Ne pas oublier de libérer la mémoire allouée
free( pscBlock4 );



//----------------------------------------------------------------------------
//- Initialisation dynamique multiple (tableau) différée par la méthode malloc
//----------------------------------------------------------------------------

EMemory::SC_BLOCK *psctBlock5 = (EMemory::SC_BLOCK*)malloc( sizeof(EMemory::SC_BLOCK) * 3 );

psctBlock5[0].pBlock = "ABC";
psctBlock5[0].ullBlockSize = 3;

psctBlock5[1].pBlock = "DE";
psctBlock5[1].ullBlockSize = 2;

psctBlock5[2].pBlock = "F";
psctBlock5[2].ullBlockSize = 1;

while ( eOk( eMem.BlocksFind( &ullOffsetFound, NULL, psctBlock5, 3 ) ) && ullOffsetFound != EMemory::DataNotFound )
ou
while ( eOk( eMem.BlocksFind( &ullOffsetFound, NULL, &psctBlock5[0], 3 ) ) && ullOffsetFound != EMemory::DataNotFound )
...
... Code additionnel ...
...

//- Ne pas oublier de libérer la mémoire allouée
free( psctBlock5 );



//-------------------------------------------------------------------------
//- Initialisation dynamique multiple (tableau) différée par la méthode new
//-------------------------------------------------------------------------

EMemory::SC_BLOCK *psctBlock6 = new EMemory::SC_BLOCK[3];

psctBlock6[0].pBlock = "ABC";
psctBlock6[0].ullBlockSize = 3;

psctBlock6[1].pBlock = "DE";
psctBlock6[1].ullBlockSize = 2;

psctBlock6[2].pBlock = "F";
psctBlock6[2].ullBlockSize = 1;

while ( eOk( eMem.BlocksFind( &ullOffsetFound, NULL, psctBlock6, 3 ) ) && ullOffsetFound != EMemory::DataNotFound )
ou
while ( eOk( eMem.BlocksFind( &ullOffsetFound, NULL, &psctBlock6[0], 3 ) ) && ullOffsetFound != EMemory::DataNotFound )
...
... Code additionnel ...
...

//- Ne pas oublier de libérer la mémoire allouée
delete psctBlock6;

 

Voir aussi
E_RTN EMemory::BlocksCountGet( ulonglong *pullBlockCounted, ulonglong *pullBlockWeightAccrued, EMemory::SC_BLOCK *pscBlockToCount, ulonglong ullBlockToCountCount, ulonglong ullOffset = 0, ulonglong ullOffsetSize = EMemory::SizeUpToEnd );
E_RTN EMemory::BlocksFind( ulonglong *pullOffsetFound, ulonglong *pullBlockIdxFound, EMemory::SC_BLOCK *pscBlockToFind, ulonglong ullBlockToFindCount, ulonglong ullOffset = 0, ulonglong ullOffsetSize = EMemory::SizeUpToEnd );
E_RTN EMemory::BlocksSubstitute( ulonglong *pullBlockCountSubstitued, void *pBlockToPut, ulonglong ullBlockToPutSize, EMemory::SC_BLOCK *pscBlockToFind, ulonglong ullBlockToFindCount, ulonglong ullOffset = 0, ulonglong ullOffsetSize = EMemory::SizeUpToEnd );
E_RTN EMemory::BlocksSuppress( ulonglong *pullBlockCountSuppressed, ulonglong *pullBlockWeightAccrued, EMemory::SC_BLOCK *pscBlockToSuppress, ulonglong ullBlockToSuppressCount, ulonglong ullOffset = 0, ulonglong ullOffsetSize = EMemory::SizeUpToEnd );

 

Minimum
Version 1.0.0