[C] Traduzione routine per ignorante (io)

[ARCTiC]

Non capiscto un bit di C e C++ ...poi quando ci si mettono gli operatori matematici, le funzioni logiche, bitwise, shifting e l'uomo ragno, ne capisco pure meno.
Chi mi "traduce" questa routine, rendendo "compresibile" (a me) ...in VB6 o VB.NET o comunque in qualcosa che posso capire:

-
#if 0
dwCrc = *((PDWORD)(pMem+0x00c)); /* reverse crc to find seed */
for(pLow = pMem+0x4cb; pLow >= pMem+0x10; pLow--){
for(dw = 0; dw < 8; dw++){
if(dwCrc & 0x00000001){
dwCrc = (dwCrc>>1)^0x82608edb;}
else{
dwCrc = dwCrc>>1;}}
dwCrc ^= ((DWORD)*pLow)<<24;}
#endif
dwCrc = 0xe0c04495; /* generate crc crude way */
for(pLow = pMem+0x10; pLow <= pMem+0x4cb; pLow++){
dwCrc ^= ((DWORD)*pLow)<<24;
for(dw = 0; dw < 8; dw++){
if(dwCrc & 0x80000000){
dwCrc = (dwCrc<<1)^0x04c11db7;}
else{
dwCrc = (dwCrc<<1);}}}
*((PDWORD)(pMem+0x00c)) = dwCrc;
-

Per info: serve a calcolare la checksum di un file (inverse CRC-32).
pMem e' il puntatore a inizio file in memoria. Non credo che servano altre info (spero).
Grazie.

[/dev/null]

Se era una battuta fa molto ridere
Come è possibile tradurre del codice così?
Intanto manca la parte dove le var vengono definite, gli viene dato un valore e tutte il resto... Inoltre è indentato malissimo (ma quello si può rimediare)...


Ti posso dire soltanto che il pezzo di codice compreso tra

#if 0

e

#endif


viene ignorato...

[ARCTiC]

Be' ma il resto del codice e' comprensibile... mica potevo postare tutto il programma qui? A me interessa SOLO quel pezzo (e' ovvio che non puo' funzionare da solo... prima dell'IF quella variabile va trattata).
Il mio problema non e' capire la "logicita'" del codice, a quello ci arrivo ma a tradurre le espressioni matematiche (che in C sono molto diverse).

Che dichiarazioni ti servono?

static PBYTE pMem;
static PBYTE pLow;
register DWORD dwCrc, dw;

...non dovrebbe essere cosi' difficile tradurre una decina di linee, che poi non sono altro che operazioni sui bit. Solo che io non conosco proprio il C, almeno non a questo livello.

[/dev/null]

Farò del mio meglio...

Intanto sappi (sicuramente lo sai già) che i valori che partono con 0x sono numeri esadecimali...

// assegno a dwCrc il valore 0C04495 HEX
dwCrc = 0xe0c04495;

// assegno a pLow il valore di pMem + 10 HEX e ripeto il ciclo finche pLow e' minore di pMem+4CB HEX, incrementando ogni volta pLow
for (pLow = pMem+0x10; pLow <= pMem+0x4cb; pLow++) {

	// dwCrc = dwCrc XOR ( il valore puntato da pLow spostato di 24 bit verso sinisra)
	// *L'operatore << sposta bit per bit ogni bit del valore verso sinistra.
	// *ESEMPIO: Se *pLow = 0000000A HEX (10 BIN), *pLow << 24 diventa: 0A00000 HEX
	dwCrc ^= (*pLow) << 24;
	
	// per 8 volte
	for (dw = 0; dw < 8; dw++) {
		// se l'ultimo bit di dwCrc e' 1
		if (dwCrc & 0x80000000) {
			dwCrc = ( dwCrc spostato di 1 bit verso sinistra) XOR 04C11DB7 HEX
			dwCrc = (dwCrc<<1)^0x04c11db7;
		// altrimenti (se l'ultimo bit di dwCrc e' 0)
		} else {
			// sposto dwCrc di 1 bit verso sinistra
			dwCrc = (dwCrc<<1);
		}
	}
}
// il puntatore che punta alla cella di memoria con valore pari a ( pMem + C HEX ) prende il valore di dwCrc
*((PDWORD)(pMem+0x00c)) = dwCrc;

Se servono altri chiarimenti chiedi pure.



PS:

Sappi che gli operatori binari sono:

& = AND
// se confronti ogni bit del primo operando con ogni bit del secondo, quando trovi entrambi i bit a 1 il bit risultante e' 1, in tutti gli altri casi e' 0

| = OR
// se confronti ogni bit del primo operando con ogni bit del secondo, quando trovi entrambi i bit a 0 il bit risultante e' 0, in tutti gli altri casi e' 1

^ = XOR
// se confronti ogni bit del primo operando con ogni bit del secondo, quando i 2 bit sono diversi il bit risultante e' 1, se sono uguali e' 0

<< = spostamento verso sinistra
// sposto ogni bit del primo operando verso sinistra di tanti bit quanto il valore del secondo operando

>> = spostamento verso destra
// sposto ogni bit del primo operando verso destra di tanti bit quanto il valore del secondo operando

ESEMPI:
0011 & 0001 = 0001 (3 & 1 = 1)
0011 & 1000 = 0000 (3 & 8 = 0)

0011 | 0001 = 0011 (3 | 1 = 3)
0011 | 1000 = 1011 (3 | 8 = 11)

0011 ^ 0001 = 0010 (3 ^ 1 = 2)
0011 ^ 1000 = 1011 (3 ^ 8 = 11)

0011 << 0001 = 0110 (3 << 1 = 6)
0011 << 0010 = 1100 (3 << 2 = 12)

1100 >> 0001 = 0110 (12 >> 1 = 6)
1100 >> 0010 = 0011 (12 >> 2 = 3)

Come avrai notato, gli operatori di spostamento hanno l'effetto di raddoppiare o dimezzare il valore (se visto in decimale).

[ARCTiC]

Grazie mille.. stavo provando a convertire in VB6, ma ho gia' grossi problemi. Prima di tutto perche' non ho una funzione di shifting nativa, quindi sono costretto a moltiplicare il valore per 2^nbit.. poi con lo XOR su i due valori (la costante assegnata e il valore letto shiftato) va in overflow... comicio bene.

[ARCTiC]

Sono sempre io ... ...visto che sto procendo alla cieca, avrei bisogno di una mano di qualcuno di voi.
Siccome la routine di cui sopra serve a "calcolare un numero" (una checksum) non posso verificarne il funzionamento se non facendo innumerevoli prove, poiche' il programma funziona comunque, pure se sbaglio un passaggio, ma ovviamente il risultato sara' sbagliato.

Mi servirebbe quindi un'anima pia che mi compili quel pezzo di codice in C (io non ho nessun compilatore) e mi possa offrire una serie di risultati in modo da poterli confrontare con la mia routine:

Il primo "pezzo" assegnando il valore all'IF manualmente (0/1), il secondo pezzo assegnando una DWORD manualmente ed eseguendo un solo ciclo del for (che nel programma originale legge le longword in seguenza da un file di 1212 bytes = 303 cicli) e poi postarmi il debug (risultato delle operazioni) ad ogni passaggio della routine.
In questo modo io posso proporre lo stesso valore di input e verificare che il risultato ad ogni passaggio sia identico.

Lo so che e' una rottura di bolas... ma non so piu' dove sbattere la tesa.

[ARCTiC]

Nessuno o nessuna che voglia aiutare un ragazzo carino e disponibile come me?

[Iena87]

dwCrc ^= (*pLow) << 24;

questa parte nn l'ho capita...o meglio lo spostamento l'ho capito, ma dwCrc ^= (*pLow) nn ho capito bene, cioè corrisponde a

dwCrc = dwCrc ^(*pLow)

Giusto? Cioè assegna a dwCrc l'XOR tra dwCrc e il valore puntato da pLow e poi ciò che viene lo sposta di 24 bit a sx ???
Ma lo spostamento di tanti bit, a meno che nn si disponga di oggetti di dimensioni sufficienti, su un byte nn porterebbe ad un valore 0, essendo lo spostamento appunto uno spostamento e nn una rotazione?
E cmq ci vorrebbero le parentesi per questa espressione, perchè se si vuole eseguire dopo lo spostamento, bisogna mettere le parentesi avendo questo una precedenza maggiore rispetto all'operatore ^

[iguana13]

dwCrc ^= (*pLow) << 24;

significa

dwCrc = dwCrc ^ ((*pLow) << 24);

ed anche per me non ha senso.

Un altro problema è che in Visual Basic i puntatori non esistono, quindi è inpossibile tradurre questo codice!

[ARCTiC]

Scusate, perche' mai lo spostamento di tanti bit dovrebbe produrre zero? Stiamo parlando di una longword (32bit), "avanza" un intero byte ...difatti quello spostamento a sinistra di 24 bits non fa altro che passare l'ultimo byte della longword al primo byte:

000000FF <<24bit = FF000000

(sempre se ci ho capito qualcosa)

Tornando al codice.. ho capito solo adesso (maledetto io che non capisco un cavolo di C) che quel segmento #if 0 #endif non viene nemmeno compilato (mi era stato gia' detto.. ma io credevo che si riferiva alla parte precente (non postata) di codice), e' servito solo al tizio la prima volta per leggersi il seed iniziale (quel 0xe0c04495 che poi diventa costante nel programma finale) in quanto l'algoritmo "originale" del CRC32 imposta il valore iniziale a 0xFFFFFFFF.

Parlando poi del VB, mi sa pure a me che tradurre quel codice cosi' com'e' scritto e' impossibile (servono molti piu' passaggi, perche' mancano pure le funzioni logiche piu' elementari).
Ora sto utilizzando una routine standard per il CRC32, cambiando il polinomio a 0x04c11db7 e l'init a 0xe0c04495 ...ma lo stesso non funziona.