DLL vor allem anderen aus Ressourcen laden?

[HaCkAttaCk2001]

Hi.

Ich hab noch ne Frage!

Muss ich das type jedes mal wieder angeben?

Beispiel:

Delphi-Quellcode:

type
  TACloseAudio = function: Integer; stdcall;
  function ACloseAudio: Integer;
  //hier
  TAOpenAudio = function(var pInfo: TAudioInfo): Integer; stdcall;
  function AOpenAudio(var pInfo: TAudioInfo): Integer;

Wenn ich das so mach, wie es Delphi doch selbst eigentlich auch macht, dann bekomm ich den Fehler: "Unbekannte Anweisung: TAOpenAudio". Schreibe ich aber dort wo ich das "//hier" geschrieben habe, ein "type" hinein, erzeugt das Programm beim Beenden eine Schutzverletzung.
Diese Schutzverletzung sehe ich aber nur in Delphi! Wenn ich das Projekt erzeuge und dann die .exe ausführe, kommt die Schutzverletzung nicht!

Was muss ich machen?! Die Verletzung ignorieren?

C ya!

[NicoDE]

Zitat von HaCkAttaCk2001:

Das soll also heißen, dass ich für jede Prozedur ein type und den Rest anlegen muss? *seufz*

Eben das kannst Du vermeiden (zumindest die stupide Handarbeit)

Nehmen wir an es gibt folgende Deklarationen:

Delphi-Quellcode:

function foo: Integer; stdcall; external 'foo.dll' name 'foo';
function bar(const i: Integer): Integer; stdcall; external 'bar.dll' name 'bar';

...dann kannst Du:
- Die Zeilen markieren
- Im Menü 'Search / Replace... (Strg+R)' auswählen
- Option 'Regular Expressions' aktivieren
- 'Text to find:'

Code:

^ *function *{[a-z_A-Z0-9]*}{.*}; external *{[a-z_A-Z0-9.']*} *name *{[a-z_A-Z0-9.']*};$

- 'Replace with:'

Code:

{$IFDEF DYNAMIC_LINK}[color=red]\r// foo\r[/color]{$ELSE}\rfunction \0\1; external \2 name \3;\r{$ENDIF DYNAMIC_LINK}

...und dann wird bei 'Replace All' daraus

Delphi-Quellcode:

{$IFDEF DYNAMIC_LINK}
// foo
{$ELSE}
function foo: Integer; stdcall; external 'foo.dll' name 'foo';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
// foo
{$ELSE}
function bar(const i: Integer): Integer; stdcall; external 'bar.dll' name 'bar';
{$ENDIF DYNAMIC_LINK}

\r// foo\r kannst Du durch Deinen Wrapper ersetzen, wobei:
- \r ist ein Zeilenumbruch
- \0 ist der Name der Funktion
- \1 sind die Parameter der Funktion
- \2 ist der Name der Dll
- \3 ist der Export-Name


Gruss Nico

[SirThornberry]

Zitat:

... Wie verhält es sich aber, wenn ich, wie in dem Fall den ich hier zu bearbeiten habe, ca. 50 Prozeduren so umschreiben muss? Muss ich da für alles ein Type etc. anlegen? ...

Du hast doch bestimmt nicht 50 Proceduren mit unterschiedlichem Funktionkopf.
angenommen du hast die funktionen

Delphi-Quellcode:

function GetIrgendwas1(Labelcaption: String): Integer;
function GetIrgendwas2(Editcaption: String): Integer;

so sind diese ja vom gleichen typ und du musst nicht für beide einen extra typ anlegen

Delphi-Quellcode:

type
  TGetIntegerBySetString = function(StringtoGive: String): Integer;

Es gäbe auch noch die Variante das du eine Extra Exe-Datei anlegst und darein per Ressource die eigentliche Exe sowie die Dll einbindest. Beim start der neuen Exe extrahierst du dann einfach die exe und die dll und somit hat sich dein problem mit dem dynamichen einbinden erledigt.

[HaCkAttaCk2001]

Hi.

Also die Übergaben sind recht verschieden... aber du hast recht, so könnte ich ein wenig Schreibarbeit sparen.

Das mit dem Ersetzen sieht jetzt erstmal kompliziert für mich aus, vor allem, weil ich noch nie mit solchen Ausdrücken gearbeitet habe. Aber ich werd's auf jeden Fall mal versuchen!

Da gibts jetzt noch die eine Frage, die schon weiter oben steht. Muss ich nun immer wieder "type" schreiben oder reicht einmal "type" und dann die ganzen Definitionen? Siehe oben. Das mit der Schutzverletzung irritiert mich halt ein wenig.


C ya.

[franksch88]

Du solltest mal versuchen alle types zusammen machen, und dann alle functions zusammen.

Anstatt

Code:

type
  TACloseAudio = function: Integer; stdcall;
  function ACloseAudio: Integer;

type
  TAOpenAudio = function(var pInfo: TAudioInfo): Integer; stdcall;
  function AOpenAudio(var pInfo: TAudioInfo): Integer;

versuchs lieber so:

Code:

type
  TACloseAudio = function: Integer; stdcall;
  TAOpenAudio = function(var pInfo: TAudioInfo): Integer; stdcall;
  TAOthertype = function:String; stdcall;

function ACloseAudio: Integer;
function AOpenAudio(var pInfo: TAudioInfo): Integer;
function AOtherFunction: String;

Ist nicht nur mit types so, sondern auch mit uses, var, und const. Du hattest vorher nähmlich ein Type deklariert, danach eine funktion deklariert, aber die nächste Anweisung hat Delphi nicht erkannt (weil das letzte deklarierte eine "function" war, und das muss man für jede deklaration extra dazuschreiben). Wenn du aber alle Types nacheinander deklarierst, bruachst du (genau so wie bei var und const) nur einmal das wort Type hinzuschreiben, und nur Types dazwischenlegen.

[HaCkAttaCk2001]

Hi.

Die Frage hat sich erledigt... es darf nicht so aussehen:

Delphi-Quellcode:

type
  TACloseAudio = function: Integer; stdcall;
  function ACloseAudio: Integer;

  TAOpenAudio = function(var pInfo: TAudioInfo): Integer; stdcall;
  function AOpenAudio(var pInfo: TAudioInfo): Integer;

Sondern es muss so sein:

Delphi-Quellcode:

type
  TACloseAudio = function: Integer; stdcall;
  TAOpenAudio = function(var pInfo: TAudioInfo): Integer; stdcall;
  
  function AOpenAudio(var pInfo: TAudioInfo): Integer;
  function ACloseAudio: Integer;

[franksch88]

sagte ich doch....

[NicoDE]

Zitat von HaCkAttaCk2001:

Das mit dem Ersetzen sieht jetzt erstmal kompliziert für mich aus, vor allem, weil ich noch nie mit solchen Ausdrücken gearbeitet habe. Aber ich werd's auf jeden Fall mal versuchen!

Sieht nur auf den ersten Blick kompliziert aus, da der Ausdruck ziemlich lang geworden ist. Wenn man damit etwas gearbeitet hat, möchte man es nicht mehr missen und kommt schnell auch ohne Blick in die Delphi-Hilfe aus...

...wie oben schon erwähnt wurde, wird es wohl am schnellsten gehen, die EXE und die DLL aus einem Stub zu entpacken...
...oder fertige Lösungen wie PEBundle ( http://www.collakesoftware.com ) zu verwenden...