Tipps für Header-Übersetzungen

[Luckie]

So, ich habe das erstemal eine einfache Header-Übersetzung gemacht. Und zwar gibt es ab Windows 2000 sogenannte TimerQueues. Damit kann man Threads erzeugen, die in bestimmten Intervallen immer wieder aufgerufen werden. Man braucht also keine Endlosschleife in einem Thread oder so. Da es dies erst ab Windows2000 gibt, sind die entsprechenden Funktionen nicht in der windows.pas deklariert, so dass ich es selber gemacht habe. Und das ist bei rausgekommen:

Delphi-Quellcode:

{************************************************************}
{                                                            }
{                          TimerQueue                        }
{                                                            }
{               Copyright (c) 2004 Michael Puff              }
{                                                            }
{  When I die I want 'Hello, world' carved on my headstone.  }
{                                                            }
{************************************************************}


unit TimerQueue;

interface

type
  THandle = Cardinal;
  DWORD = Cardinal;
  ULONG = Cardinal;
  BOOL = Boolean;

const
  WT_EXECUTEDEFAULT = $00000000;
  WT_EXECUTEINIOTHREAD = $00000001;
  WT_EXECUTEINUITHREAD = $00000002;
  WT_EXECUTEINWAITTHREAD = $00000004;
  WT_EXECUTEONLYONCE = $00000008;
  WT_EXECUTEINTIMERTHREAD = $00000020;
  WT_EXECUTELONGFUNCTION = $00000010;
  WT_EXECUTEINPERSISTENTIOTHREAD = $00000040;
  WT_EXECUTEINPERSISTENTTHREAD = $00000080;
  WT_TRANSFER_IMPERSONATION = $00000100;

type
  WAITORTIMERCALLBACKFUNC = procedure(P: Pointer; B: ByteBool); stdcall;
  WAITORTIMERCALLBACK = WAITORTIMERCALLBACKFUNC;

function CreateTimerQueue: THandle; stdcall;
function CreateTimerQueueTimer(var phNewTimer: THandle; TimerQueue: THandle;
  Callback: WAITORTIMERCALLBACK; Parameter: Pointer; DueTime, Period: DWORD;
  Flags: ULONG): BOOL; stdcall;
function ChangeTimerQueueTimer(TimerQueue: THandle; Timer: THandle; DueTime:
  ULONG; Period: ULONG): Boolean; stdcall;
function DeleteTimerQueueTimer(TimerQueue, Timer, CompletionEvent: THandle):
  BOOL; stdcall;
function DeleteTimerQueueEx(TimerQueue: THandle; CompletionEvent: THandle):
  Boolean;

implementation

function CreateTimerQueue; external 'kernel32.dll' name 'CreateTimerQueue';
function CreateTimerQueueTimer; external 'kernel32.dll' name
'CreateTimerQueueTimer';
function ChangeTimerQueueTimer; external 'kernel32.dll' name
'ChangeTimerQueueTimer';
function DeleteTimerQueueTimer; external 'kernel32.dll' name
'DeleteTimerQueueTimer';
function DeleteTimerQueueEx; external 'kernel32.dll' name 'DeleteTimerQueueEx';

end.

In einem Demo-Projekt hab eich sie getestet und es funktioniert. Was mich jetzt interessieren würde, was gibt es bei Header-Übersetzungen zu beachten:
- Datentypen
- Stil. Ist das soweit bei mir in Ordnung? Was sollte man naders / besser machen? Benennung der Parameter? ...?
- Was sollte im Unit-Header-Kommentar stehen?
- ...
- ...

Und fällt einem ein sinnvoller Name für die Unit ein? Im Original sind die Funktionen in der Windows.h drinne und die Konstanten in WinNT.h.

[NicoDE]

- die Datentypen sind merkwürdig gemischt (wirklich sicher, dass BOOL = ByteBool ist?)
- Anpassungen für den C++Builder wären nicht schlecht (HPPEMIT, EXTERNALSYM, NOINCLUDE, ... - leider kommt Delphi 2/3 damit nicht klar)
- oben könnte die Lizenz und Copyrights stehen (such Dir eine aus, bei manchen ist es Pflicht)
- ungarische Notation bei Parametern kannste weglassen
- 'kernel32.dll' ist bereits in Windows.pas (Konstante kernel32)
- für den Funktionstyp sollte ein Typ mit Delphi-Notation eingeführt werden (TFNXxx, TXxx, TFnXxx, ...)
- die Deklaration von eigenen Typen (C->D Mapping) ist hier eigentlich nicht nötig (in Windows.pas vorhanden)


Gruss Nico

ps: zwecks Unitname, wie wär's mit 2-3 Buchstaben Deines Namens als Präfix

[Luckie]

Zitat:

Zitat von NicoDE

- die Datentypen sind merkwürdig gemischt (wirklich sicher, dass BOOL = ByteBool ist?)

Du meinst hier:

Delphi-Quellcode:

TWAITORTIMERCALLBACKFUNC = procedure(P: Pointer; B: ByteBool); stdcall;

Hm, im PSDK steht es jetzt als Boolean. Weiß auch nicht wie ich auf byteBool kam. :gruebel: Habe es geändert.

Zitat:

- Anpassungen für den C++Builder wären nicht schlecht (HPPEMIT, EXTERNALSYM, NOINCLUDE, ... - leider kommt Delphi 2/3 damit nicht klar)

Kann ich nur schlecht testen, da ich ihn nicht habe.

Zitat:

- oben könnte die Lizenz und Copyrights stehen (such Dir eine aus, bei manchen ist es Pflicht)

Nun ja, da wollte ich ja wissen, was rein muss.

Zitat:

- ungarische Notation bei Parametern kannste weglassen

Korrigiert. War nur bei einem Parameter der Fall.

Zitat:

- 'kernel32.dll' ist bereits in Windows.pas (Konstante kernel32)

Macht es sinnd die Windows.pas einzu binden, wenn es auch ohen geht?

Zitat:

- für den Funktionstyp sollte ein Typ mit Delphi-Notation eingeführt werden (TFNXxx, TXxx, TFnXxx, ...)

So: ???

Delphi-Quellcode:

type
  TFNWAITORTIMERCALLBACKFUNC = procedure(P: Pointer; B: Boolean); stdcall;
  TFNWAITORTIMERCALLBACK = TFNWAITORTIMERCALLBACKFUNC;

Zitat:

- die Deklaration von eigenen Typen (C->D Mapping) ist hier eigentlich nicht nötig (in Windows.pas vorhanden)

Meinst du das:

Delphi-Quellcode:

type
  THandle = Cardinal;
  DWORD = Cardinal;
  ULONG = Cardinal;
  BOOL = LongBool;

Nun ja. Ohne windows.pas sinnvoll, denke ich.

Zitat:

ps: zwecks Unitname, wie wär's mit 2-3 Buchstaben Deines Namens als Präfix

Hehe: PufTimerQueue. :mrgreen:

[NicoDE]

Zitat:

im PSDK steht es jetzt als Boolean.

BOOLEAN = ByteBool
BOOL = LongBool

Zitat:

Kann ich nur schlecht testen, da ich ihn nicht habe.

dcc32.exe -JPHNE Foo.pas

Zitat:

Macht es sinnd die Windows.pas einzu binden, wenn es auch ohen geht?

Ich finde es spricht nichts dagegen...

Zitat:

So: ???

Ich meinte es eher so:

Delphi-Quellcode:

type
  WAITORTIMERCALLBACKFUNC =
    procedure(Parameter: Pointer; TimerOrWaitFired: Boolean); stdcall;
  {$EXTERNALSYM WAITORTIMERCALLBACKFUNC}
  TWaitOrTimerCallback = WAITORTIMERCALLBACKFUNC;

Zitat:

Nun ja. Ohne windows.pas sinnvoll, denke ich.

Dann kannste die auch gleich durch native Typen ersetzen (sonst hat jeder ca. 5000 ULONG durch uses...)

Zitat:

PufTimerQueue. :mrgreen:

MpuTimerQueue. :mrgreen:

[Luckie]

Die Rückgabewerte sind BOOL, laut PSDK. Ich habe es jetzt für Delphi in LongBool geändert.
So das ganze sieht jetzt so aus:

Delphi-Quellcode:

{************************************************************}
{                                                            }
{                       MpuTimerQueue                        }
{                                                            }
{               Copyright (c) 2004 Michael Puff              }
{                                                            }
{  When I die I want 'Hello, world' carved on my headstone.  }
{                                                            }
{************************************************************}

unit MpuTimerQueue;

interface

uses
  windows;

const
  WT_EXECUTEDEFAULT = $00000000;
  WT_EXECUTEINIOTHREAD = $00000001;
  WT_EXECUTEINUITHREAD = $00000002;
  WT_EXECUTEINWAITTHREAD = $00000004;
  WT_EXECUTEONLYONCE = $00000008;
  WT_EXECUTEINTIMERTHREAD = $00000020;
  WT_EXECUTELONGFUNCTION = $00000010;
  WT_EXECUTEINPERSISTENTIOTHREAD = $00000040;
  WT_EXECUTEINPERSISTENTTHREAD = $00000080;
  WT_TRANSFER_IMPERSONATION = $00000100;

type
  WAITORTIMERCALLBACKFUNC = procedure(P: Pointer; B: Boolean); stdcall;
  TWAITORTIMERCALLBACK = WAITORTIMERCALLBACKFUNC;

function CreateTimerQueue: THandle; stdcall;
function CreateTimerQueueTimer(var NewTimer: THandle; TimerQueue: THandle;
  Callback: TWAITORTIMERCALLBACK; Parameter: Pointer; DueTime, Period: DWORD;
  Flags: ULONG): LongBool; stdcall;
function ChangeTimerQueueTimer(TimerQueue: THandle; Timer: THandle; DueTime:
  ULONG; Period: ULONG): LongBool; stdcall;
function DeleteTimerQueueTimer(TimerQueue, Timer, CompletionEvent: THandle):
  LongBool; stdcall;
function DeleteTimerQueueEx(TimerQueue: THandle; CompletionEvent: THandle):
  LongBool;

implementation

function CreateTimerQueue; external kernel32 name 'CreateTimerQueue';
function CreateTimerQueueTimer; external kernel32 name 'CreateTimerQueueTimer';
function ChangeTimerQueueTimer; external kernel32 name 'ChangeTimerQueueTimer';
function DeleteTimerQueueTimer; external kernel32 name 'DeleteTimerQueueTimer';
function DeleteTimerQueueEx; external kernel32 name 'DeleteTimerQueueEx';

end.

Für den C Builder habe ich es noch nicht angepasst. Was muss ich da noch machen und was bewirken die Direktiven? Und was macht dcc32.exe -JPHNE Foo.pas? da hab eich jetzt eine hpp-Datei. Was ist denn das?

[Robert Marquardt]

Alles was ich bemeckern wollte ist schon geaendert.

Der C++ Builder konvertiert das .pas File in ein .hpp File.
{$EMIT 'xxx'} fuegt xxx als Zeile in das .hpp File ein.
{$EXTERNALSYM xxx} weist den Konverter an das Symbol xxx nicht in .hpp File zu konvertieren.

[Luckie]

Zitat:

Zitat von Robert Marquardt

Alles was ich bemeckern wollte ist schon geaendert.

Puh, da hab eich ja Glück gehabt. ;)

Zitat:

Der C++ Builder konvertiert das .pas File in ein .hpp File.

Ich nehme mal an um es dann im C++ Bullder nutzen zu können.

Zitat:

{$EMIT 'xxx'} fuegt xxx als Zeile in das .hpp File ein.
{$EXTERNALSYM xxx} weist den Konverter an das Symbol xxx nicht in .hpp File zu konvertieren

Wann ist das jeweils nötig?

[Robert Marquardt]

Man will ueblicherweise im C++ Builder nicht die doppelt konvertierte Version verwenden, sondern den originalen Header.
Also mit EMIT ein "#include <originalheader.h>" einfuegen und alle Namen die es vom originalen Header in die Pascal-Konversion geschafft haben mit EXTERNALSYM versehen.
Nach der Konversion zum .hpp File bleiben dann nur noch die eventuell zusaetzlich eingefuehrten Namen uebrig.

[Luckie]

Könntest du mir das mal eben bitte an obigen Code demonstrieren? Wäre nett von dir.

[mirage228]

Zitat:

Zitat von Luckie

Könntest du mir das mal eben bitte an obigen Code demonstrieren? Wäre nett von dir.

Hi,

schau dir doch einfach an, wie es Borland bei der Windows.pas gemacht hat ;)

...moment, du hast ja die Personal, sorry :oops:

Naja Borland macht das einfach hinter jeden Typ, ein HPPEMIT bräuchtest du hier nur für das Include

Delphi-Quellcode:

// Auszüge Windows.pas

  LPSTR = PAnsiChar;
  {$EXTERNALSYM LPSTR}
  PLPSTR = ^LPSTR;
  {$EXTERNALSYM PLPSTR}

// ...

function FindClose(hFindFile: THandle): BOOL; stdcall;
{$EXTERNALSYM FindClose}

So müsstest du IMHO auch vorgehen ;)

mfG
mirage228