Prototype
E_RTN EMemory::BlocksFind( ulonglong *pullOffsetFound,
ulonglong *pullBlockIdxFound,
EMemory::SC_BLOCK *pscBlockToFind,
ulonglong ullBlockToFindCount,
ulonglong ullOffset = 0,
ulonglong ullOffsetSize = EMemory::SizeUpToEnd );

Cette fonction cherche dans l'intervalle de travail un bloc d'octets ayant l'une des valeurs de la série de blocs d'octets pscBlockToFind.

 

Argument

ulonglong *pullOffsetFound

adresse d'une variable de type ulonglong où sera copiée l'offset de l'octet trouvé.

Si le bloc d'octets n'a pas été trouvé et si cet argument n'est pas NULL alors la valeur EMemory::DataNotFound est copiée dans la variable (*puimOffsetRtn=EMemory::DataNotFound).

Si cette information ne vous intéresse pas cet argument peut être NULL (la fonction ne retournera pas d'erreur à ce propos).

ulonglong *pullBlockIdxFound

adresse d'une variable de type ulonglong où sera stockée l'index du bloc trouvé.

Si cette information ne vous intéresse pas cet argument peut être NULL (la fonction ne retournera pas d'erreur à ce propos).

EMemory::SC_BLOCK *pscBlockToFind

adresse de la structure de type EMemory::SC_BLOCK ou du tableau de structures de type EMemory::SC_BLOCK à rechercher.

ulonglong ullBlockToFindCount

nombre de structure de type EMemory::SC_BLOCK contenu dans le pointeur pscBlockToFind à rechercher.

ulonglong ullOffset = 0

offset de départ de l'intervalle de travail de recherche.

ulonglong ullOffsetSize = EMemory::SizeUpToEnd

étendue de l'intervalle de travail de recherche.

 

Retour

E_RTN

voir la section retour de la librairie Eclat.

 

Exemple 1

Description :

Recherche et affichage d'offset de tous les blocs d'octets ayant soit la valeur 0x0D, soit la valeur 0x0A, soit les valeur 0x0D et 0x0A, soit la valeur 0x00 dans un objet EMemory alloué de 26 octets d'espace de travail contenant les données 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x0D, 0x0A, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x0D, 0x4C, 0x4D, 0x4E, 0x4F, 0x0A, 0x50, 0x51, 0x52, 0x00, 0x53, 0x54 et 0x0D ("ABCDEF\x0D\x0AGHIJK\x0DLMNO\x0APQR\x00ST\x0D" en ASCII).

Code :

EMemory eMem( "ABCDEF\x0D\x0AGHIJK\x0DLMNO\x0APQR\x00ST\x0D", 26 ); // objet EMemory alloué de 26 octets
ulonglong ullOffsetStart = 0;
ulonglong ullOffsetFound = 0;
ulonglong ullBlockIdxFound;
EMemory::SC_BLOCK sctBlock[]={
  { "\x0D", 1, 0, 0, 0 },
  { "\x0A", 1, 0, 0, 0 },
  { "\x0D\x0A", 2, 0, 0, 0 },
  { "\x00", 1, 0, 0, 0 }
  };

eMem.TraceEx( _T("eMem") );

while ( eOk( eMem.BlocksFind( &ullOffsetFound, &ullBlockIdxFound, sctBlock, 4, ullOffsetStart ) ) && ullOffsetFound != EMemory::DataNotFound )
  {
  ETrace::DoEx( _T("Bloc indexé trouvé = %I64u, à l'offset %I64u.\n"), ullBlockIdxFound, ullOffsetFound );
  ullOffsetStart = ullOffsetFound + scBlock[ullBlockIdxFound].ullBlockSize;
  }

Sortie :

### Object EMemory 'eMem' Trace #
# Object address='0x0012F458', status='EMemory::ObjectStatus_Enable' (code '3').
# Buffer address='0x00000004', workspace size='26' byte(s).
# Array data from offset '0x00000000' to offset '0x00000019', length=26 byte(s).
# Offset start 0x00000000 41 42 43 44 45 46 0D 0A 47 48 49 4A 4B 0D 4C 4D [ABCDEF..GHIJK.LM]
# Offset start 0x00000010 4E 4F 0A 50 51 52 00 53 54 0D .. .. .. .. .. .. [NO.PQR.ST.]
### End #

Bloc indexé trouvé = 2, à l'offset 6.
Bloc indexé trouvé = 0, à l'offset 13.
Bloc indexé trouvé = 1, à l'offset 18.
Bloc indexé trouvé = 3, à l'offset 22.
Bloc indexé trouvé = 0, à l'offset 25.

Vue :

00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
00 01 02 03 04 05 06 07 08 09 0A 0B
41
A		 42
B		 43
C		 44
D		 45
E		 46
F		 0D 0A 47
G		 48
H		 49
I		 4A
J
10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E ..
0C 0D 0E 0F 10 11 12 13 14 15 16 17 18 19
4B
K		 0D 4C
L		 4D
M		 4E
N		 4F
O		 0A 50
P		 51
Q		 52
R		 00 53
S		 54
T		 0D

 

Exemple 2

Description :

Cet exemple est un peu plus complexe que le précédent. Il fait la même chose mais avec un intervalle de travail qui s'étand de l'offset 1 sur une taille de 24 octets (un surcroît de code est nécessaire pour ajuster la taille de recherche).

Code :

EMemory eMem( "ABCDEF\x0D\x0AGHIJK\x0DLMNO\x0APQR\x00ST\x0D", 26 ); // objet EMemory alloué de 26 octets
ulonglong ullOffsetStart = 1;
ulonglong ullOffsetSize = 24;
ulonglong ullOffsetFound = 0;
ulonglong ullBlockIdxFound;
EMemory::SC_BLOCK scBlock[]={
  { "\x0D", 1, 0, 0, 0 },
  { "\x0A", 1, 0, 0, 0 },
  { "\x0D\x0A", 2, 0, 0, 0 },
  { "\x00", 1, 0, 0, 0 }
  };

eMem.TraceEx( _T("eMem") );

while ( eOk( eMem.BlocksFind( &ullOffsetFound, &ullBlockIdxFound, scBlock, 4, ullOffsetStart, ullOffsetSize ) ) && ullOffsetFound != EMemory::DataNotFound )
  {
  ETrace::DoEx( _T("Bloc indexé trouvé = %I64u, à l'offset %I64u.\n"), ullBlockIdxFound, ullOffsetFound );
  ullOffsetSize -= ullOffsetFound + scBlock[ullBlockIdxFound].ullBlockSize - ullOffsetStart;
  ullOffsetStart = ullOffsetFound + scBlock[ullBlockIdxFound].ullBlockSize;
  }

Sortie :

### Object EMemory 'eMem' Trace #
# Object address='0x0012F350', status='EMemory::ObjectStatus_Enable' (code '3').
# Buffer address='0x00000004', workspace size='26' byte(s).
# Array data from offset '0x00000000' to offset '0x00000019', length=26 byte(s).
# Offset start 0x00000000 41 42 43 44 45 46 0D 0A 47 48 49 4A 4B 0D 4C 4D [ABCDEF..GHIJK.LM]
# Offset start 0x00000010 4E 4F 0A 50 51 52 00 53 54 0D .. .. .. .. .. .. [NO.PQR.ST.]
### End #

Bloc indexé trouvé = 2, à l'offset 6.
Bloc indexé trouvé = 0, à l'offset 13.
Bloc indexé trouvé = 1, à l'offset 18.
Bloc indexé trouvé = 3, à l'offset 22.

Vue :

00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
00 01 02 03 04 05 06 07 08 09 0A 0B
41
A		 42
B		 43
C		 44
D		 45
E		 46
F		 0D 0A 47
G		 48
H		 49
I		 4A
J
10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E ..
0C 0D 0E 0F 10 11 12 13 14 15 16 17 18 19
4B
K		 0D 4C
L		 4D
M		 4E
N		 4F
O		 0A 50
P		 51
Q		 52
R		 00 53
S		 54
T		 0D

 

Voir aussi
struct EMemory::SC_BLOCK;
E_RTN EMemory::ByteFind( ulonglong *pullOffsetFound, uchar ucByteToFind, ulonglong ullOffset = 0, ulonglong ullOffsetSize = EMemory::SizeUpToEnd );
E_RTN EMemory::BytesFind( ulonglong *pullOffsetFound, uchar *pucByteFound, void *pBytesToFind, ulonglong ullBytesToFindSize, ulonglong ullOffset = 0, ulonglong ullOffsetSize = EMemory::SizeUpToEnd );
E_RTN EMemory::BlockFind( ulonglong *pullOffsetFound, void *pBlockToFind, ulonglong ullBlockToFindSize, ulonglong ullOffset = 0, ulonglong ullOffsetSize = EMemory::SizeUpToEnd );

 

Minimum
Version 1.0.0