Traduction C++/C en delphi

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

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, 20h30

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

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

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** · 19/05/2007, 23h40

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** · 19/05/2007, 23h47

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, 14h38

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.

Traduction C++/C en delphi

Delphi

Vue hybride

Discussions similaires

Partager

Partager