C++ "..." ins Delphi Übersetzten

[nitschchedu]

Hallo Leute,
ich übersetzte gerade wieder mal was ins Delphi.
Und dabei bin ich auf vollgende Funktion gestossen:

Code:

VixError Vix_GetProperties(VixHandle handle, 
                           VixPropertyID firstPropertyID, ...);

Wie übersetzte ich das "..." ins Delphi ? *ratlos*

PS: VixError, VixHandle, VixPropertyID sind Integer <--

[SirThornberry]

für mich sieht das nach offenem parameter aus wo man noch mehrere weitere parameter angeben kann.

[Torpedo]

SirThornberry hat recht. So wird das auch bei printf gemacht.

printf("Test");
printf("Zahl: %d",i);
printf("Zahl: %d, noch eine: %d",i,j);
usw.

Natürlich kann man nicht für jede Anzahl an Parametern eine neue Funktion schreiben, deshalb gibt es "...".

[nitschchedu]

Stimmt vom printf kenne ich das auch aber wie schreibe ich das in Delphi ?

Delphi-Quellcode:

function Vix_GetProperties(handle: VixHandle; firstPropertyID: VixPropertyID; ....): VixError;

die Punkte gehen ja in Delphi nicht !? :(

[Dezipaitor]

nennt sich va_list (so auch der typ)

siehe http://www.c-plusplus.de/forum/viewt...is-284500.html

Ich glaube aber nicht, dass man es nach Delphi so einfach portieren kann.
Das muss man erstmal an einer eigenen C++ Fkt testen.

Denke mal, dass "..." entweder ein Array von irgendwas(bester Fall) oder ein Pointer ist.

Du müsstest also den Aufruf kapseln in einer eigenen Funktion die den Aufruf übernimmt.

zum test kannste mal folgendes verwenden

procedure xy(<deine Parameter>; const XY : array of const)

[OregonGhost]

Willst du die Signatur übersetzen, damit du die C++-Funktion in deinem Delphiprogramm aufrufen kannst, oder willst du die komplette Funktion übersetzen?

[nitschchedu]

Zitat:

Zitat von Dezipaitor

..
procedure xy(<deine Parameter>; const XY : array of const)

Das habe ich auch gerade in ne Anderen Projekt gefunden ^^ .. das würde dann so aussehen

Delphi-Quellcode:

function Vix_GetProperties(handle: VixHandle; firstPropertyID: VixPropertyID; Args:array of const): VixError;

...

Zitat:

Zitat von OregonGhost

Willst du die Signatur übersetzen, damit du die C++-Funktion in deinem Delphiprogramm aufrufen kannst, oder willst du die komplette Funktion übersetzen?

Das ist ne Export Funktion einer DLL, ich will eine DLL benutzten und in C++ steht die Funktion so da.

[Dezipaitor]

lass es uns wissen, wenn das Array of Const kompatibel mit dem C++ ist.

[Robert Marquardt]

Ich weiss jetzt gerade die Syntax nicht, aber eine variable Anzahl von Parametern laesst sich in neueren Delphi-Versionen deklarieren. Die Funktion ist dann uebrigens zwingend cdecl.
va_list ist nicht die richtige Deklaration. Das ist der Mechanismus mit dem in C eine variable Anzahl Parameter implementiert wird. Dieser Mechanismus ist seinerseits in C benutzbar und ueblicherweise gibt es Funktionsfamilien mit allen Parametervarianten (namentlich printf).

[Apollonius]

Zitat:

Ich weiss jetzt gerade die Syntax nicht, aber eine variable Anzahl von Parametern laesst sich in neueren Delphi-Versionen deklarieren.

Wo? Ab wann? Will haben!

[Robert Marquardt]

Da ich es in der Hilfe von D6 nicht gefunden habe, duerfte es erst ab D7 implementiert sein. Schau dir mal die Hilfe zu Parametern an.

[Apollonius]

Mein Delphi 2005 Personal kennt nur offene Array-Parameter, und die sind ganz anders implementiert als in C.

[Robert Marquardt]

Ah, endlich gefunden, also auch in D6. varargs Direktive. Nur fuer externe Deklarationen in DLLs.

Delphi-Quellcode:

function Vix_GetProperties(handle: VixHandle; firstPropertyID: VixPropertyID): VixError; cdecl; varargs;

[Apollonius]

Danke für den Tipp.
Ich habe es eben getestet. Ein Kuriosum ist an dieser Stelle, dass bei mir auch ohne cdecl warnungsfrei kompiliert wird, und auf Assemblerebene kann man die Aufrufkonvention register erkennen. Da sollte der Compiler mindestens eine Warnung schmeißen (bei mehr als drei Parametern ist schließlich der Stack futsch) oder besser noch abbrechen.

[nitschchedu]

So kommen wir nun zur auflösung ^^
nach vielen Test habe ich rausgefunden das

Delphi-Quellcode:

function Vix_GetProperties(handle: VixHandle; firstPropertyID: VixPropertyID): VixError; cdecl; varargs;

das geht :cheers:
Danke allen für die Hilfe ;-)

[nitschchedu]

Ich habe mal wieder eine übersetzungs frage :gruebel: .

Code:

#define NETWORK_ADDRESS_LENGTH_IP sizeof (NETWORK_ADDRESS_IP)

habe ich so versucht

Delphi-Quellcode:

  Tndu_NETWORK_ADDRESS_LENGTH_IP = SizeOf(Tndu_NETWORK_ADDRESS_IP);

aber es kommt der Fehler :

Zitat:

[Pascal Fehler] nduNtDDNdis.pas(1789): E2029 '..' erwartet, aber ';' gefunden

Wie übersetzt man das ?

[Apollonius]

Das ist eine Konstante.

[nitschchedu]

Ah ok :oops: aber jetzt noch mal eine Frage

Code:

typedef struct _NDIS_TCP_LARGE_SEND_OFFLOAD_V1
{

    struct
    {
        ULONG     Encapsulation;
        ULONG     MaxOffLoadSize;
        ULONG     MinSegmentCount;
        ULONG     TcpOptions:2;
        ULONG     IpOptions:2;
    } IPv4;
   
} NDIS_TCP_LARGE_SEND_OFFLOAD_V1, *PNDIS_TCP_LARGE_SEND_OFFLOAD_V1;

Macht das überhaupt sinn eine Struktur in einer Sturktur ... wenn nix weiter kommt !? :gruebel:
Vor allem im Variabelnamen ":2" was soll das :gruebel: :wiejetzt:

[himitsu]

Das mit dem :2 kann ich auch nicht beantworten (konnt jetzt auch im MSDN nicht rauslesen).

Vielleicht kommen ja in den anderen NDIS_TCP_LARGE_SEND_OFFLOAD_V* ja noch weitere Strukturen dazu und die wollten einfach nur bei allen Diesen einen gleichen/ähnlichen Aufbau. :zwinker:
(praktisch nur etwas logischer für den Programmierer, daber sonst hat es keinen wirklichen Sinn)

[nitschchedu]

Ah ok also wenn ich das auch so mache müsste das aber Funktionieren ?

Delphi-Quellcode:

  Tndu_NDIS_TCP_LARGE_SEND_OFFLOAD_V1 = record
     IPv4: record
       Encapsulation: ulong;
      MaxOffLoadSize: ulong;
      MinSegmentCount: ulong;
      TcpOptions: ulong;      //TcpOptions:2;
      IpOptions: ulong;         //IpOptions:2;
    end;
  end;

[OregonGhost]

Sind die Dinger mit den Doppelpunkten nicht Bitfelder? Also nicht wirklich zwei ULONGs, sondern je zwei Bit lange vorzeichenlose Integer :stupid:

[himitsu]

Jupp (abgesehn von dem :2 )

vom inneren Speicheraufbau entspricht es ja genau Folgendem, aber mit dem Doppelrecord liegt es wenigstens nah an Windows seiner Definition, was logisch besser wäre.

Delphi-Quellcode:

Tndu_NDIS_TCP_LARGE_SEND_OFFLOAD_V1 = record
  Encapsulation: ulong;
  MaxOffLoadSize: ulong;
  MinSegmentCount: ulong;
  TcpOptions: ulong;  //TcpOptions:2;
  IpOptions: ulong;   //IpOptions:2;
end;

wegen dem ...Options, im MSDN steh jedenfalls nur was von "A ULONG value that a miniport driver sets to indicate ...", also für'n Anfang würde ich es wohl auch erstmal so versuchen :stupid:

[add]

Zitat:

Zitat von OregonGhost

Sind die Dinger mit den Doppelpunkten nicht Bitfelder? Also nicht wirklich zwei ULONGs, sondern je zwei Bit lange vorzeichenlose Integer :stupid:

hmmm ... Bitfelder .... :gruebel: ... also BOOL/LongBool?

Code:

[color=silver]TcpOptions: LongBool;
IpOptions:  LongBool;[/color]

[Muetze1]

Naja, mit LongBool kommste nicht hin, weil das original laut Definition aus 2 Bits besteht. Somit haben sie 2^2 mögliche Kombinationen und nicht nur 2^1.

Die Definition besagt, diese Variable belegt nur Bit 0 und 1 und kann somit auch nur Werte zwischen 0 und 3 aufnehmen.

[nitschchedu]

Wie sieht denn das nu im Delphi aus :gruebel: und wieso steht dann ulong da wenn dann durch das ":2" was anderes rauskommt ?
Die logig verstehe ich dahinter nicht ! :roll:

[OregonGhost]

In C definiert man so eben Bitfelder. Man nimmt einen zugrundeliegenden Typ und teilt ihn in Bits auf. z.B.

Code:

struct {
  unsigned char highnibble: 4;
  unsigned char lownibble: 4;
};

ergibt eine Struktur, die ein Byte in Nibbles einteilt. Ich glaube, solange es alles passt und man den Typ zwischendurch nicht ändert, ergibt der Typ die Gesamtgröße. Du könntest also probieren, deine aufeinanderfolgenden Bitfelder als einen ULONG zu definieren, eigentlich müsste die Größe hinkommen.

[Muetze1]

Beide Bitfelder liegen in einem LONG, somit einem LongWord. Dabei sind TCPOptions Bit 0 & 1 und IPOptions sind Bit 2 & 3.

Ansonsten nochmal kurz hier lesen.

[himitsu]

mal wieder was Neues gelernt :shock:

also wenn die Beiden jetzt im Grunde in dem selben ULONG/LongWord drinliegen, dann sieht es wohl so aus :angel2:

Delphi-Quellcode:

type 
  _NDIS_TCP_LARGE_SEND_OFFLOAD_V1 = record
    IPv4: record 
      Encapsulation:   LongWord;
      MaxOffLoadSize:  LongWord;
      MinSegmentCount: LongWord;
      Tcp_Ip_Options:  LongWord; 
    end;
  end;
  NDIS_TCP_LARGE_SEND_OFFLOAD_V1  = _NDIS_TCP_LARGE_SEND_OFFLOAD_V1;
  PNDIS_TCP_LARGE_SEND_OFFLOAD_V1 = ^_NDIS_TCP_LARGE_SEND_OFFLOAD_V1;

const
  TcpOptionsMask = $00000003;
  IpOptionsMask  = $0000000C;

[Muetze1]

<stimme vom sesamstrassen-buchstaben-dealer> Genaauuuu </stimme vom sesamstrassen-buchstaben-dealer>

[nitschchedu]

So erstmal danke für das bisherige ;-) aber es geht weiter ! ^^

Habe nun folgendes gefunden

Code:

//
// Macro definition for defining IOCTL and FSCTL function control codes.  Note
// that function codes 0-2047 are reserved for Microsoft Corporation, and
// 2048-4095 are reserved for customers.
//

#define CTL_CODE( DeviceType, Function, Method, Access ) (                 \
    ((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method) \
)

und das

Code:

#define _NDIS_CONTROL_CODE(request,method) \
            CTL_CODE(FILE_DEVICE_PHYSICAL_NETCARD, request, method, FILE_ANY_ACCESS)

#define IOCTL_NDIS_QUERY_GLOBAL_STATS   _NDIS_CONTROL_CODE(0, METHOD_OUT_DIRECT)

und als weiteres

Code:

#if ((NTDDI_VERSION >= NTDDI_LONGHORN) || NDIS_SUPPORT_NDIS6)
....
#endif // (NTDDI_VERSION >= NTDDI_LONGHORN)

Wie übersetzt ich das ins Delphi :-D ?

[himitsu]

Code:

// Macro definition for defining IOCTL and FSCTL function control codes.  Note
// that function codes 0-2047 are reserved for Microsoft Corporation, and
// 2048-4095 are reserved for customers.

#define CTL_CODE( DeviceType, Function, Method, Access ) (                 \
    ((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method) \
)

das ist ein Makro ... sowas kennt Delphi nicht.

entweder du machst eine Funktion draus
oder du rechnest es direkt aus.

zu Zweitem:
du könntest (was wohl am Besten sein wird) dieses direkt in der Konstante ausrechnen lassen:
mußt dann nur deine Konstantendefinition nach diesem Muster umsetzen

Delphi-Quellcode:

const {ConstName} = ({DeviceType} shl 16) or ({Access} shl 14) or ({Function} shl 2) or {Method};

... su kannst es natürlich auch selber ausrechnen und der Konstante den errechneten Wert zuweisen.

Code:

#define xyz 

#if xyz
  ...
#endif

Delphi-Quellcode:

{$DEFINE xyz}

{$IFDEF xyz}
  ...
{$ENDIF}

siehe OH :zwinker:

[nitschchedu]

Ok Danke ^^ ich probiere es aus ... bei der letzten sache ging es mehr ähr darum wie rausbekomme welche Windows Version das ist und dem entsprechent die Funktion oder Variable einblende oder nicht :roll:

[himitsu]

Mit Compilerdirektiven kann man die Windowsversion nicht ermitteln/prüfen ... diese werden vom Compiler ausgewertet und sind unabhängig von der Windowsversion wo dann das kompilierte Programm drauf läuft.

Du kannst höchstens ermitteln mit welche Compilereinstellungen und welchen Bibliotheken das Programm kompiliert wird ... also z.B. für welche Zielplattformen die Anwendung vorgesehn ist.