Newsgroup: it.comp.lang.delphi
Titolo: TRADURRE CODICE C++ IN DELPHI

QUALCUNO POTREBBE TRADURMI QUESTA STRUTTURA IN DELPHI 7 E LA RELATIVA
CHIAMATA ALLA FUNCTION SOTTO DICHIARATA  ?
DOVREBBE ESSERE UNA FUNCTION DI TIPO INTERA.
QUESTA E' UNA DELLE TANTE PROCEDURE FACENTE PARTI DI UNA DLL CHE
INTERAGISCE CON UNA SCHEDA CRITTOGRAFICA ERACOM.
E NON RIESCO A COLLOQUIARCI.
GRAZIE MILLE.
typedef struct {             // Format 00
   UCHAR		BCD; // BCD 00 - 99
} FORMAT00;
typedef struct {	     // Format 01
   UCHAR		bin; // binary 00 - ff
} FORMAT01;
typedef struct {	    // Universal Key Spec
	UCHAR format;
	union {		   // One of.....
		FORMAT00	fmt00;
		FORMAT01	fmt01;
              };
} KEYSPEC;
EXPORT int EFT_21_RetrieveKey(
	IN  UCHAR	Reserved[2],
	IN  KEYSPEC	*tfrTableIndex,
	OUT UCHAR	*keyType,
	OUT KEYSPEC	*retrievedKey,
	OUT UCHAR	KVC[3]);

 QUALCUNO POTREBBE TRADURMI QUESTA STRUTTURA IN DELPHI 7 E LA RELATIVA
[cut]
In primis non scrivere tutto in maiuscolo, equivale ad urlare.
Per il resto vai su
http://www.programmersheaven.com/zone24/cat277/4171.htm
da qui puoi scaricare un programmino che traduce i sorgenti C/C++
in Pascal/Delphi, la traduzione non e' perfetta, ma con un po' di buona
volonta' si puo' aggiustare in fretta. ;)
Ciao.
--
Ryo GQI

 OUT UCHAR KVC[3]);
type TKVCArray = array[0..2] of Byte;
function EFT_21_RetrieveKey(Reserved: Byte; var tfrTableIndex: KEYSPEC; var
keyType: UCHAR; var retirevedKey: KEYSPEC; var KVC: TKVCArray): Integer;
...
var Reserved: Byte;
var tfrTableIndex: KEYSPEC;
var keyType: UCHAR;
var retirevedKey: KEYSPEC;
var KVC: TKVCArray
...
ris := EFT_21_RetrieveKey(Reserved, tfrTableIndex, keyType, retirevedKey,
KVC);
 
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

Ti ringrazio... non ho risolto ma non fa nulla...ci riuscirò...
Scusa per il maiuscolo ma volevo solo farlo leggere bene.
Potrei farti un altra domanda.. :
DELPHI.
TYPE
  F11=array[0..16] of Byte;
  tFormato11=^F11;
KeyStore:tFormato11;
KeyStore:=new(tFormato11);
Dovrei riempire l'array con questi valori presi da un codice
C .. e sono in formato esadecimale.
{0x23,0x3C,0x59,0xE6,0xB0,0x93,0xBC,0xED,
0x23,0x3C,0x59,0xE6,0xB0,0x93,0xBC,0xED}
Il problema è : come mi strutturo l'array per far si
che venga valorizzato con valori esadeciamli ?
Grazie...

 che venga valorizzato con valori esadeciamli ?
A parte che il vettore deve andare da 0..15 (=16 valori) e non da 0..16 (=17
valori), non ho capito bene che cosa vuoi fare. L'equivalente di 0x in
Delphi è $, quindi il valore 0x59, ad esempio, si tramuta in $59.


Il discorso è che in una dll scritta in C.. ho questa procedura :
EXPORT int EFT_22_StoreKey(
	IN  UCHAR	Reserved[2],
	IN  KEYSPEC	*tfrTableIndex,
	IN  UCHAR	keyType,
	IN  KEYSPEC	*keyToStore,
	IN	UCHAR	KVC[3]);
e devo ridichiararla in delphi.
E come passare i valori a questa procedura, se con le @ o senza..
non riesco in questo.
Ciao e grazie. ;)
Il tipo Keyspec nel programma C e definito come seguente :
typedef struct {							// Format 00
	UCHAR		BCD;						// BCD 00 - 99
} FORMAT00;
typedef struct {							// Format 01
	UCHAR		bin;						// binary 00 - ff
} FORMAT01;
typedef struct {							// Format 02
	UCHAR		BCD[2];						// BCD 0000 - 9999
} FORMAT02;
typedef struct {							// Format 03
	USHORT bin;								// binary 0000 - ffff
} FORMAT03;
typedef struct {							// Format 10
	UCHAR eKM_Key[8];						// eKMvn(key)
} FORMAT10;
typedef struct {							// Format 11
	UCHAR eKM_Key[16];						// ECB mode eKMvn(*key)
} FORMAT11;
typedef struct {							// Format 12
	UCHAR eKM_Key[24];						// ECB mode eKMvn(**key)
} FORMAT12;
typedef struct {							// Format 13
	UCHAR eKM_Key[16];						// CBC mode eKMvn(*key)
} FORMAT13;
typedef struct {							// Format 14
	UCHAR eKM_Key[24];						// CBC mode eKMvn(**key)
} FORMAT14;
typedef struct {							// Format 15
	UCHAR		version;
	UCHAR		keyType;
	UCHAR		keySubType;
	UCHAR		KMID;
	UCHAR		authAlgID;
	UCHAR		attributeCount;
	UCHAR		padding;
	UCHAR		keyFieldLen;
	UCHAR		keyField[32];
	UCHAR		attributes[2];
	UCHAR		mac[8];
} FORMAT15;
typedef struct {							// Format 16
	UCHAR		algorithm;
	UCHAR		masterKeyLen;
	UCHAR		blockLen;
	UCHAR		mode;
	UCHAR		keyFieldLen;
	UCHAR		keyField[32];
} FORMAT16;
typedef struct {							// Format 17
	UCHAR		KMId;
	UCHAR		SecKeyBlock[88];
} FORMAT17;
typedef struct {							// Format 18
	UCHAR		KMId;
	UCHAR		SecKeyBlock[52];
} FORMAT18;
typedef struct {							// Format 19
	UCHAR		DataSpecType;
	UCHAR		EncPayload;
	UCHAR		KMId;
	USHORT		PayloadLen;
	UCHAR		Pad1[2];
	UCHAR		Bitmap[8];
	UCHAR		AuthCode[8];
} FORMAT19;
typedef struct {							// Format 20
	UCHAR format_BDK;
	union {
		FORMAT00	BDK_fmt00;
		FORMAT01	BDK_fmt01;
		FORMAT02	BDK_fmt02;
		FORMAT03	BDK_fmt03;
		FORMAT13	BDK_fmt13;
		FORMAT14	BDK_fmt14;
	};
	UCHAR	KSN[10];
	UCHAR	Derived_Key_Type;
} FORMAT20;
typedef struct {							// Format 50
	UCHAR format_KMC;
	union {
		FORMAT00	KMC_fmt00;
		FORMAT01	KMC_fmt01;
		FORMAT02	KMC_fmt02;
		FORMAT03	KMC_fmt03;
		FORMAT13	KMC_fmt13;
	};
	UCHAR	Card_Data[16];
	UCHAR	Card_Method;
} FORMAT50;
typedef struct {							// Format 51
	UCHAR format_KMC;
	union {
		FORMAT00	KMC_fmt00;
		FORMAT01	KMC_fmt01;
		FORMAT02	KMC_fmt02;
		FORMAT03	KMC_fmt03;
		FORMAT13	KMC_fmt13;
	};
	UCHAR	Card_Data[16];
	UCHAR	Card_Method;
	UCHAR	Session_Data[16];
	UCHAR	Session_Method;
} FORMAT51;
typedef struct {							// Format 80
	USHORT		modulusLen;
	UCHAR		modulus[512];
	USHORT		exponentLen;
	UCHAR		exponent[512];
} FORMAT80;
typedef struct {							// Format 81
	USHORT		modulusLen;
	UCHAR		modulus[512];
	USHORT		exponentLen;
	UCHAR		exponent[512];
	UCHAR		KMID;
	USHORT		keyType;
	UCHAR		authAlgID;
	USHORT		userDataLen;
	UCHAR		userData[1024];
	UCHAR		authDataLen;
	UCHAR		authData[16];
} FORMAT81;
typedef struct {							// Format 82
	USHORT		modulusLen;
	UCHAR		keyFormat;
	UCHAR		KMID;
	USHORT		keyType;
	UCHAR		authAlgID;
	USHORT		userDataLen;
	UCHAR		userData[1024];
	USHORT		SKLen;
	UCHAR		eKMv20_SK[1024];
	UCHAR		authDataLen;
	UCHAR		authData[32];
} FORMAT82;
typedef struct {							// Format 92
		UCHAR		subType;
		UCHAR		generationNum;
		UCHAR		versionNumber;
		UCHAR		expiryDate[2];
} FORMAT92;
typedef struct {							// Format 90
	UCHAR format;
	union {
		FORMAT00	fmt00;
		FORMAT01	fmt01;
		FORMAT02	fmt02;
		FORMAT03	fmt03;
		FORMAT13	fmt13;
		FORMAT92	fmt92;
	};
	UCHAR		cvIndex;
	UCHAR		eTK_KS[16];
} FORMAT90;
typedef struct {							// Format 91
	UCHAR format_KGK1;
	union {
		FORMAT00	KGK1_fmt00;
		FORMAT01	KGK1_fmt01;
		FORMAT02	KGK1_fmt02;
		FORMAT03	KGK1_fmt03;
		FORMAT13	KGK1_fmt13;
	};
	UCHAR format_KGK2;
	union {
		FORMAT00	KGK2_fmt00;
		FORMAT01	KGK2_fmt01;
		FORMAT02	KGK2_fmt02;
		FORMAT03	KGK2_fmt03;
		FORMAT13	KGK2_fmt13;
	};
	UCHAR	BLZ[4];
} FORMAT91;
typedef struct {						// Universal Key Spec
	UCHAR format;
	union {										// One of.....
		FORMAT00	fmt00;
		FORMAT01	fmt01;
		FORMAT02	fmt02;
		FORMAT03	fmt03;
		FORMAT10	fmt10;
		FORMAT11	fmt11;
		FORMAT12	fmt12;
		FORMAT13	fmt13;
		FORMAT14	fmt14;
		FORMAT15	fmt15;
		FORMAT16	fmt16;
		FORMAT17	fmt17;
		FORMAT18	fmt18;
		FORMAT19	fmt19;
		FORMAT20	fmt20;
		FORMAT50	fmt50;				// (EMV)
		FORMAT51	fmt51;				// (EMV)
		FORMAT80	fmt80;
		FORMAT81	fmt81;
		FORMAT82	fmt82;
		FORMAT90	fmt90;				// (ZKA)
		FORMAT91	fmt91;				// (ZKA)
		FORMAT92	fmt92;				// (ZKA)
	};
} KEYSPEC;

 non riesco in questo.
Ma scusa, le risposte le leggi ? ... nel mio messaggio iniziale ti ho
spiegato come fare.
Il C, a differenza di altri linguaggi, non possiede il passaggio per
riferimento degli argmenti di funzione, ma solo per valore, quindi se vuoi
passare una variabile che sia possibile modificare all'interno di una
funzione, è necessario passare un puntatore ad essa e usare l'indirezione
all'interno della funzione. In Delphi, invece, esiste il passaggio per
riferimento e qundi tutto ciò che viene dichiarato come puntatore, tra gli
argomenti di funzione, può essere tradotto con un passaggio per riferimento.
Per intenderci, la funzione che citi può essere riscritta come:
function EFT_22_StoreKey(Reserved: TArray2UCHAR;
var tfrTableIndex: TKeySpec;
keyType: UCHAR;
var keyToStore: TKeySpec;
KVC: TArray3UCHAR): Integer;
Questo a meno di definire i tipi, ovviamente, e mi sembra che a proposito
dei tipi io ti abbia già risposto.
