Traduction C++/C en delphi

**jprenou** · 19/05/2007, 21h06

Bonjour

Je voulais savoir si quelqu'un avait les compétences et le temps pour m'aider à traduire ce bout de code en delphi.
J'avoue que mes connaissances sont limitées de ce coté.

Merci d'avance à celui ou celle ou ceux qui prendront le temps de m'aider.

A+

JP

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
HANDLE MPUSBOpen(DWORD instance,    // Input
                 PCHAR pVID_PID,    // Input
                 PCHAR pEP,         // Input
                 DWORD dwDir,       // Input
                 DWORD dwReserved)  // Input <Future Use>
{
    char path[MAX_PATH];
    DWORD dwReqLen;
 
    HANDLE handle;
    handle = INVALID_HANDLE_VALUE;
 
    // Check arguments first
    if((pVID_PID != NULL) && ((dwDir == MP_WRITE) || (dwDir == MP_READ)))
    {
            char path_io[MAX_PATH];
            strcpy(path_io,path);
            if(pEP != NULL) strcat(path_io,pEP);
 
            if(dwDir == MP_READ)
            {
                handle = CreateFile(path_io,
                                    GENERIC_READ,
                                    0,
                                    NULL,
                                    OPEN_EXISTING,
                                    FILE_ATTRIBUTE_NORMAL|FILE_FLAG_OVERLAPPED,
                                    NULL);
            }
            else
            {
                handle = CreateFile(path_io,
                                    GENERIC_WRITE,
                                    0,
                                    NULL,
                                    OPEN_EXISTING,
                                    FILE_ATTRIBUTE_NORMAL|FILE_FLAG_OVERLAPPED,
                                    NULL);
            }//end if
    }//end if
    return handle;
}//end MPUSBOpen(...)

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
 
DWORD MPUSBRead(HANDLE handle,          // Input
                PVOID pData,            // Output
                DWORD dwLen,            // Input
                PDWORD pLength,         // Output
                DWORD dwMilliseconds)   // Input
{
    BOOL bResult;
    DWORD nBytesRead;
    OVERLAPPED gOverlapped;
    DWORD dwResult;
 
    dwResult = MPUSB_FAIL;
 
    // set up overlapped structure fields
    gOverlapped.Internal     = 0;
    gOverlapped.InternalHigh = 0;
    gOverlapped.Offset       = 0;
    gOverlapped.OffsetHigh   = 0;
    gOverlapped.hEvent       = CreateEvent(NULL, FALSE, FALSE, NULL);
 
    if(pLength != NULL)*pLength = 0;
 
    // attempt an asynchronous read operation
    bResult = ReadFile(handle,pData,dwLen,&nBytesRead,&gOverlapped);
 
    if(!bResult)
    {
        // deal with the error code
        switch (GetLastError())
        {
            case ERROR_HANDLE_EOF:
            {
                // we have reached the end of the file
                // during the call to ReadFile
                break;
            }
            case ERROR_IO_PENDING:
            {
                // asynchronous i/o is still in progress
                switch(WaitForSingleObject(gOverlapped.hEvent, dwMilliseconds))
                {
                    case WAIT_OBJECT_0:
                        // check on the results of the asynchronous read
                        // and update the nBytesRead...
                        bResult = GetOverlappedResult(handle, &gOverlapped,
                                                      &nBytesRead, FALSE);
                        if(!bResult)
                        {
                            printf("Error: %d", GetLastError());
                        }
                        else
                        {
                            if(pLength != NULL)
                                *pLength = nBytesRead;
                            dwResult = MPUSB_SUCCESS;
                        }//end if else
                        break;
                    case WAIT_TIMEOUT:
                        CancelIo(handle);
                        break;
                    default:
                        CancelIo(handle);
                        break;
                }//end switch
            }//end case
            default:
                CancelIo(handle);
                break;
        }//end switch
    }
    else
    {
        if(pLength != NULL)
            *pLength = nBytesRead;
        dwResult = MPUSB_SUCCESS;
    }//end if else
 
    ResetEvent(gOverlapped.hEvent);
    CloseHandle(gOverlapped.hEvent);
 
    return dwResult;
}//end MPUSBRead

**sjrd** · 19/05/2007, 21h30

Regarde toujours dans les tutoriels sur la conversion de C en Delphi.

**jprenou** · 19/05/2007, 22h24

Bonjour sjrd,

Merci d'abord pour ta réponse.
J'ai bien sur essayé par moi même mais sans succès. C'est pour cela que je me permettais de demander un coup de pied.

En espèrant qu'un dévéloppeur puisse m'aider.

A+

JP

**maxim_um** · 20/05/2007, 00h40

Salut,

Traduire ton code je sais pas faire, mais d'après ce que j'y est lu, les liens suivants devraient de faire retrouver le moral ...

La table de conversion
et le lien que tu cherches désespérément.

Voilà, j'espère que ça répondra à ton besoin.

**jprenou** · 20/05/2007, 00h47

merci d'avoir pris le temps de regarder.

La table de conversion est très intéressante. Merci encore.

Par contre, j'ai déjà développer le lien avec la dll dans mon application. Mais je voulais l'intégrer directement dans mon application sans passer par la dll fourni par microchip. Si j'arrive à traduire ces bouts de code correctement cela me permettra d'avoir un meilleur temps de réaction qu'avec une dll.

Si toutefois un développeur ailé peut m'aider.

Ce serait le bien venu.

JP

**sjrd** · 20/05/2007, 15h38

Bon, c'est mon jour de bonté :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
function MPUSBOpen(instance : DWord; pVID_PID, pEP : PChar;
  dwDir, dwReserved : DWord) = Handle;
var PathArr, PathIOArr : array[0..MAX_PATH-1] of Char;
    Path, PathIO : PChar;
    dwReqLen : DWord;
begin
  Result := INVALID_HANDLE_VALUE;
  Path := @PathArr[0];
  PathIO := @PathIOArr[0];
 
  // Check arguments first
  if (pVID_PID <> nil) and ((dwDir = MP_WRITE) or (dwDir == MP_READ)) then
  begin
    StrCopy(PathIO, Path);
    if (pEP <> nil) then
      StrCat(PathIO, pEP);
 
    if dwDir == MP_READ then
    begin
      Result := CreateFile(PathIO, GENERIC_READ, 0, nil, OPEN_EXISTING,
        FILE_ATTRIBUTE_NORMAL or FILE_FLAG_OVERLAPPED, nil);
    end else
    begin
      Result := CreateFile(PathIO, GENERIC_WRITE, 0, nil, OPEN_EXISTNG,
        FILE_ATTRIBUTE_NORMAL or FILE_FLAG_OVERLAPPED, nil);
    end;
  end;
end;
 
function MPUSBRead(hand : Handle; pData : Pointer; dwLen : DWord;
  pLength : PDWord; dwMillisecons : DWord) : DWord;
var bResult : DWordBool;
    nBytesRead : DWord;
    gOverlapped : OVERLAPPED;
begin
  Result := MPUSB_FAIL;
 
  // set up overlapped structure fields
  with gOverlapped do
  begin
    Internal := 0;
    InternalHigh := 0;
    Offset := 0;
    OffsetHigh := 0;
    hEvent := CreateEvent(nil, False, False, nil);
  end;
 
  if pLength <> nil then
    pLength^ := 0;
 
  // attemps an asynchronous read operation
  bResult := ReadFile(hand, pData, dwLen, @nBytesRead, @gOverlapped);
 
  if not bResult then
  begin
    // deal with error code
    case GetLastError() of
      ERROR_HANCLE_EOF : ; // reached end of file during ReadFile
      ERROR_IO_PENDING :
      begin
        case WaitForSingleObject(gOverlapped.hEvent, dwMilliseconds) of
          WAIT_OBJECT_0 :
          begin
            // check on the results of the asynchronous read
            // and update the nBytesRead...
            bResult := GetOverlappedResult(hand,
              @gOverlapped, @nBytesRead, False);
            if not bResult) then WriteLn('Error: ', GetLastError()) else
            begin
              if pLength <> nil then
                pLength^ := nBytesRead;
              Result := MPUSB_SUCCESS;
            end;
          end;
          WAIT_TIME_OUT : CancelIo(hand);
          else CancelIo(hand);
        end;
      end;
      else CancelIo(hand);
    end;
  end else
  begin
    if pLength <> nil then
      pLength^ := nBytesRead;
    Result := MPUSB_SUCCESS;
  end;
 
  ResetEvent(gOverlapped.hEvent);
  CloseHandle(gOverlapped.hEvent);
end;

Par contre j'ai un gros doute sur le premier StrCpy (en C) : path n'a pas encore été initialisé à ce moment ! Tu devrais vérifier ta source, je crois bien qu'il y a un problème.

**jprenou** · 20/05/2007, 16h36

OUAAAAAAAAAAAAAHHHHHHHH MERCI BEAUCOUP.

srjd tu as tout à fait raison pour la variable Path. J'avais enlevé un bout de code qui utilisait cette fonction pour initialiser la variable.
Après test de ta traduction (merci encore et encore), cette fonction est obligatoire pour que le reste du code fonctionne correctement.
Mais alors la, il me parle chinois.

Enfin si tu as encore du temps pour m'aider, c'est promi je te le rendrais dans une autre vie.

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
 
DWORD MPUSBGetDeviceLink(DWORD instance,    // Input
                         PCHAR pVID_PID,    // Input
                         PCHAR pPath,       // Output
                         DWORD dwLen,       // Input
                         PDWORD pLength)    // Output
{
    if(pLength != NULL)*pLength = 0;        // Initialization
 
    HDEVINFO info = SetupDiGetClassDevs((LPGUID)&GUID_DEVINTERFACE_MCHPUSB,
                                        NULL,
                                        NULL,
                                        DIGCF_PRESENT|DIGCF_DEVICEINTERFACE);
    if(info==INVALID_HANDLE_VALUE)
	{
        SetupDiDestroyDeviceInfoList(info);
		return MPUSB_DEV_NO_INFO;
	}// end if
 
	// Get interface data for the requested instance
	SP_DEVICE_INTERFACE_DATA intf_data;
	intf_data.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
 
	if(!SetupDiEnumDeviceInterfaces(info,
                                    NULL,
                                    (LPGUID)&GUID_DEVINTERFACE_MCHPUSB,
                                    instance,
                                    &intf_data))
	{
		SetupDiDestroyDeviceInfoList(info);
		return MPUSB_DEV_INVALID_INST;
	}// end if
 
	// Get size of symbolic link
	DWORD ReqLen;
	SetupDiGetDeviceInterfaceDetail(info, &intf_data, NULL, 0, &ReqLen, NULL);
 
	PSP_DEVICE_INTERFACE_DETAIL_DATA intf_detail = \
    (PSP_DEVICE_INTERFACE_DETAIL_DATA)(new char[ReqLen]);
 
	if( intf_detail == NULL)
	{
		SetupDiDestroyDeviceInfoList(info);
        delete intf_detail;
		return MPUSB_DEV_NO_INFO;
	}// end if
 
    // Get symbolic link name
	intf_detail->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
    // sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA) should equals 5.
    // In C++ Builder, go to Project/Options/Advanced Compiler/Data Alignment
    // and select "byte" align.
 
	if(!SetupDiGetDeviceInterfaceDetail(info,
                                        &intf_data,
                                        intf_detail,
                                        ReqLen,
                                        NULL,
                                        NULL))
	{
		SetupDiDestroyDeviceInfoList(info);
		delete intf_detail;
		return MPUSB_DEV_NO_INFO;
	}// end if
 
    // Check for a valid VID&PID - if argument is not null)
    if(pVID_PID != NULL)
    {
        if(MPUSBIsVidPidEqual(intf_detail->DevicePath, pVID_PID) == NULL)
        {
            SetupDiDestroyDeviceInfoList(info);
		    delete intf_detail;
		    return MPUSB_DEV_VIDPID_NOT_FOUND;
        }// end if
    }// end if
 
	// Set the length of the path string
	if(pLength != NULL)
        *pLength = (DWORD)strlen(intf_detail->DevicePath);
 
    // Copy output string path to buffer pointed to by pPath
    if(pPath != NULL)
    {
        // Check that input buffer has enough room...
        // Use > not >= because strlen does not include null
        if(dwLen > strlen(intf_detail->DevicePath))
	        strcpy(pPath, intf_detail->DevicePath);
        else
        {
            SetupDiDestroyDeviceInfoList(info);
            delete intf_detail;
            return MPUSB_FAIL;
        }// end if
    }// end if
 
	// Clean up
	SetupDiDestroyDeviceInfoList(info);
	delete intf_detail;
	return MPUSB_SUCCESS;
 
}// end MPUSBGetDeviceLink

**sjrd** · 20/05/2007, 19h06

Bon c'est la dernière que je te fais. Ensuite je t'engage à regarder comment la traduction est faite, et à le faire par toi-même si tu en as encore.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
function MPUSBGetDeviceLink(instance : DWord; pVID_PID, pPath : PChar;
  dwLen : DWord; pLength : PDWord) : DWord;
var info : HDEVINFO;
    intf_data : SP_DEVICE_INTERFACE_DATA;
    ReqLen : DWord;
    intf_detail : PSP_DEVICE_INTERFACE_DETAIL_DATA;
 
  procedure CleanUp(AResult : DWord);
  begin
    SetupDiDestroyDeviceInfoList(info);
    if Assigned(info_detail) then
      FreeMem(info_detail);
    Result := AResult;
  end;
 
begin
  // Initialization
  intf_detail := nil;
  if (pLength <> nil) then
    pLength^ := 0;
 
  info := SetupDiGetClassDevs(LPGUID(@GUID_DEVINTERFACE_MCHPUSB), nil, nil,
    DIGCF_PRESENT or DIGCF_DEVICEINTERFACE);
 
  if (info = INVALID_HANDLE_VALUE) then
  begin
    CleanUp(MPUSB_DEV_NO_INFO);
    exit;
  end;
 
  // Get interface data for the requested instance
  intf_data.dbSize := sizeof(SP_DEVICE_INTERFACE_DATA);
 
  if not SetupDiEnumDeviceInterfaces(info, nil,
    LPGUID(@GUID_DEVINTERFACE_MCHPUSB), instance, @intf_data) then
  begin
    CleanUp(MPUSB_DEV_INVALID_INST);
    exit;
  end;
 
  // Get size of symbolic link
  SetupDiGetDeviceInterfaceDetail(info, @intf_data, nil, 0, @ReqLen, nil);
 
  intf_detail := PSP_DEVICE_INTERFACE_DETAIL_DATA(GetMem(ReqLen));
 
  if intf_detail = nil then
  begin
    CleanUp(MPUSB_DEV_NO_INFO);
    exit;
  end;
 
  // Get symbolic link name
  intf_detail.cbSize := sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA); // should be 5
 
  if not SetupDiGetDeviceInterfaceDetail(info, @intf_data, intf_detail,
    ReqLen, nil, nil) then
  begin
    CleanUp(MPUSB_DEV_NO_INFO);
    exit;
  end;
 
  // Check for a valid VID & PID - if argument is not null
  if pVID_PID <> nil then
  begin
    if MPUSBIsVidPidEqual(intf_detail.DevicePath, pVID_PID) = nil then
    begin
      CleanUp(MPUSB_DEV_VIDPID_NOT_FOUND);
      exit;
    end;
  end;
 
  // Set the length of the path string
  if pLength <> nil then
    pLength^ := DWord(StrLen(intf_detail.DevidePath));
 
  // Copy output string path to buffer pointed to by pPath
  if pPath <> nil then
  begin
    // Check that input buffer has enough room...
    // Use > not >= because StrLen does not include nil
    if dwLen > StrLen(intf_detail.DevicePath) then
      StrCopy(pPath, intf_detail.DevicePath)
    else
    begin
      CleanUp(MPUSB_FAIL);
      exit;
    end;
  end;
 
  // Clean up
  CleanUp(MPUSB_SUCCESS);
end;

Si tu voulais bien aussi éditer tes précédents messages pour mettre [code=C] au lieu de [code] tout seul, afin que la coloration syntaxique se fassen en C et pas en Delphi (ce qui donne très mal évidemment).

**jprenou** · 20/05/2007, 21h50

Merci.

J'ai édité les messages qui restaient en code pour les transformer en Code=C++

Je vais essayer tout ça.

A+

JP

**jprenou** · 26/05/2007, 01h15

Bonjour,

J'ai essayé la traduction de Srjd.

Elle semble correcte. J'ai cependant un problème sur le ReadFile.
Il me renvoie toujours false. Pourtout je recupère le handle par une autre fonction. Je suis certain que le handle est bon.

Mais le ReadFile est toujours à false

Quelqu'un pourrait m'aider.

Merci beaucoup par avance.

**jprenou** · 26/05/2007, 01h30

Re salut,

En fait,

Je suis obligé de remplacer cette ligne

bResult := ReadFile(hand, pData, dwLen, @nBytesRead, @gOverlapped);

par cette ligne

bResult := ReadFile(hand, pData, dwLen, nBytesRead, @gOverlapped);

pourtant la ligne C++ la ligne qui marche est bien:
bResult = ReadFile(handle,pData,dwLen,&nBytesRead,&gOverlapped);

Alors est ce il y a plusieurs ReadFile. Les fonctions ne marchent pas pareil sous C++ et Delphi.
Pourtant c'est une fonction de l'API Windows.

Si quelqu'un à des infos pour m'aider à comprendre cela.

Merci par avance

**CapJack** · 26/05/2007, 02h13

C'est parce que les références de pointeurs du C sont remplacés dans Delphi par des passages de paramètres par variable.

**jprenou** · 26/05/2007, 04h23

SAlut CapJack,

Peux tu m'en dire un peu plus ?
Est ce que cela pourrait expliquer que mon readfile me renvoie false à chaque fois. Mes paramètres ne sont peut être pas bon. La traduction C vers Delphi n'est surement pas exactes alors.

Peux tu m'aider ?

Merci par avance.

JP

**sjrd** · 26/05/2007, 10h48

Envoyé par CapJack

C'est parce que les références de pointeurs du C sont remplacés dans Delphi par des passages de paramètres par variable.

Ca n'est jamais le cas pour les API Windows. Ca reste des passages par adresse (donc pointeurs).

**CapJack** · 26/05/2007, 14h51

Laors là, sjrd, je suis vraiment désolé de te contredire, mais c'est totalement faux ! Si j'affirme ce que j'ai écrit, c'est que j'ai vérifié...

Extrait de Windows.pas :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
function ReadFile(hFile: THandle; var Buffer; nNumberOfBytesToRead: DWORD;
  var lpNumberOfBytesRead: DWORD; lpOverlapped: POverlapped): BOOL; stdcall;

Et ce n'est qu'un exemple parmi beaucoup d'autres.

Il ne faut donc d'arrobas que sur le dernier paramètre.

**sjrd** · 26/05/2007, 15h35

Envoyé par CapJack

Laors là, sjrd, je suis vraiment désolé de te contredire, mais c'est totalement faux ! Si j'affirme ce que j'ai écrit, c'est que j'ai vérifié...

Aïe, au temps pour moi. J'aurais dû vérifier moi-même.

Désolé

**jprenou** · 26/05/2007, 15h50

merci à vous deux.

J'essaye encore et encore de faire marcher mon ReadFile mais il est toujours à false.

Je ne comprends pas pourquoi.

Pouvez m'aider ?

Merci encore

JP

**jprenou** · 26/05/2007, 16h08

J'ai trouvé grace à vous

Merci beaucoup

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
function MPUSBRead(hand : Handle; var pData; dwLen : DWord;
  pLength : PDWord; dwMillisecons : DWord) : DWord;
var bResult : DWordBool;
    nBytesRead : DWord;
    gOverlapped : OVERLAPPED;
begin

Traduction C++/C en delphi

Delphi

Discussions similaires

Partager

Partager