PureBoard

Verfasst: **04.12.2008 10:46**

Hallo!

Hab ein Problem mit einer DLL welche ich In PureBasic für ein
externes Programm geschieben habe.

Ich hab alle Functionen erstellt und anschl. die Dll Compiliert.
Das hat auch alles wunderbar geklappt.

Nun ist jetzt mein Problem, dass dieses externe Programm die Funktionen
über die Ordinal Zahl (Reihenfolge) aufruft.

Hab mir dann meine Dll angesehen und festgestellt, dass die
Funktionen welche von Purebasic ersellt wurden in alphabetischer
Reihenfolge gereiht sind.

Hier ein Auschnitt meiner Funktionen ohne Code.

Code: Alles auswählen

ProcedureDLL      EnumServers()
  EndProcedure
 ProcedureDLL      Reset()
  EndProcedure
 ProcedureDLL      GetVersion()
  EndProcedure
 ProcedureDLL      QueryStatus2()
  EndProcedure

Nach dem erstellen er Dll hat
EnumServers Ordinal 1
GetVersion Ordinal 2
QueryStatus2 Ordinal 3
usw.

Ich bräuchte zb. QueryStatus2 auf der 1 Position also Odinal 1
,GetVersion auf 3 usw

Hab schon bei mdsn nachgesehen und dort steht das man in C++
die Ordinal folge mit einer def. Datei machen kann.

Mein frage?
Ist dies auch in PureBasic möglich.

Ich hoffe es ist halbwegs verständlich.

Bestan Dank schon im Voraus

Lg DieChefs

Verfasst: **04.12.2008 12:02**

Du mußt doch nur die Namen der Prozeduren entsprechend alphabetisch anpassen.

z.B.:

Code: Alles auswählen

ProcedureDLL DoQueryStatus()
ProcedureDLL EnumServers()
ProcedureDLL GetVersion()
ProcedureDLL Reset()

Verfasst: **04.12.2008 12:06**

Danke für die schnelle Antwort.

Das hab ich schon ausprobiert.
Es geht leider nicht.
Ich muss die Funktionsnamen so lassen wie sind.
Sie werden ja von einem Externen Programm aufegrufen.

Dieses Prüft ob die Functioien mit dem Namen da sind.

Leider geth das nicht.

Verfasst: **04.12.2008 12:16**

Also es prüft, ob die Funktionen mit dem richtigen Namen bestehen, aber ruft sie mit ihrer
Ordinalzahl auf? Sehr merkwürdig...

Dann erstelle einfach ein paar Fake-Procedures mit dem richtigen Namen und lass das
Programm dann die richtigen Funktionen nutzen, indem du die zu nutzen Proceduren
alphabetisch in der richtigen Reihenfolge z.B. mit dem Namen 'AAA_Name' beginnen lässt.

Zugegeben ein blöder Würgaround, aber als Linux-Nutzer fällt mir da momentan auch nicht
mehr ein.

Verfasst: **04.12.2008 12:37**

Ganz so ist es nicht das Hauptprogramm verwentet sie beim Namen

Und einige Plugins per Ordinalzahl.
Und diese Plugins funktionieren dann nicht mehr.

Verfasst: **04.12.2008 12:51**

Dann halt so:

Code: Alles auswählen

DeclareDLL   QueryStatus2(a, b, c)
DeclareDLL   Reset()
DeclareDLL.s GetVersion() 

;-Just for the ordinal
ProcedureDLL AAAA(a, b, c)
	ProcedureReturn QueryStatus2(a, b, c)
EndProcedure

ProcedureDLL AAAB()
	ProcedureReturn Reset()
EndProcedure

ProcedureDLL.s AAAC()
	ProcedureReturn GetVersion()
EndProcedure

;-Real procedures
ProcedureDLL QueryStatus2(a, b, c)
	ProcedureReturn a + b
EndProcedure

ProcedureDLL Reset()
	ProcedureReturn #True
EndProcedure

ProcedureDLL.s GetVersion()
	Global Result.s = "1.000"
	
	ProcedureReturn Result
EndProcedure

[Edit]
Doppelposting und Quark entfernt...

Verfasst: **04.12.2008 12:55**

Würgaround, so wie ich das jetzt interpretiere (Overhead ist so minimal, und wenn schon so äusserst seltsame Verhaltensweisen von Software verlangt darf man das auch seltsam programmieren...):

Code: Alles auswählen

;folgende funktionen haben den namen den sie brauchen

Procedure.l richtigefunc(param.l)
  ProcedureReturn param
EndProcedure

Procedure.l andererichtigefunc(param.l)
  ProcedureReturn param
EndProcedure

;folgende funtionen sollten den richtigen ordinalwert in der reihenfolge aufgrund
;des namens kriegen und dienen nur als wrapper!

Procedure.l aaa_01_dummyordinalfunc (param.l)
  ProcedureReturn richtigefunc(param)
EndProcedure

Procedure.l aaa_02_dummyordinalfunc (param.l)
  ProcedureReturn andererichtigefunc(param)
EndProcedure

Was aber trotzdem alles ein Quatsch ist und bleibt.

Edit: brauche zu lange zum posten....
Ist trotzdem ein Quatsch das!

Verfasst: **04.12.2008 16:34**

Ja das würde Funktionieren,
Es sind jedoch Funktionen mit einer Ordinal Zahl von 516 und mehr
d.h ich müsse 515 Functionen zuvor erstellen.

Hab das ganze in C mit einem .Def File z.b Test.def gesehen.

<Test.def>

LIBRARY testdll
DESCRIPTION "test"
EXPORTS
Reset @1 <--- Hier werden die Ordinalzahlen vergeben.
EnumServers @2
GetVersion @512

Nur weiss ich nicht wie ich das dem polib oder dem Polink übergeben
kann das er es auch verwendet.

Verfasst: **04.12.2008 18:45**

Purebasic uebergibt leider selber eine DEF-Datei.
Selbst wenn man ueber eine Linkerdatei eine DEF-datei angibt, wird diese irgendwie ignoriert.

Aber folgendes funktioniert :

erstelle folgendes Programm,

Code: Alles auswählen

For i = 0 To CountProgramParameters()
  param.s + ProgramParameter(i) + " "
Next 

RunProgram("wordpad.exe","purebasic.def","",#PB_Program_Wait)
RunProgram("polink2.exe",param,"",#PB_Program_Wait|#PB_Program_Hide)

unter den Namen "Polink.exe".
Gehe in dein PB Ordner, wechsel in den "Compilers" Ordner, sichere dir
die original "Polink.exe". Aendere den Names der original "polink.exe"
in "polink2.exe". Kopiere deine gerade erstellte "polink.exe" in den Ordner
"Compilers" (also neben "polink2.exe").

Wenn du jetzt deine DLL erstellst, oeffnet sich Wordpad und du kannst
selber anordnen. also einfach ein Leerzeichen und danach @ordinal.

z.b. so :

Code: Alles auswählen

LIBRARY "test.dll"
EXPORTS
"EnumServers"="Procedure2" @4

"GetVersion"="Procedure4"  @3

"QueryStatus2"="Procedure6"  @2
 
"Reset"="Procedure0"  @1

Wenn du Wordpad wieder schliesst wird die dll kompiliert.

wenn du alles fertig hast, kannst du deine "polink.exe" loeschen und "Polink2.exe" wieder "polink.exe" nennen.

du kannst deine PB Installation damit aber auch versauen, also nur machen wenn du weisst was du da tust..

Verfasst: **04.12.2008 20:26**

Vielen Dank!

Ja ich weiss was du meintest.

War schon am experimentieren mit dem polink und polib.

Genau das was ich gebraucht habe.

So funktioniert es wunderbar.

Many Thanks.

PureBoard

Dll Funktionen in bestimmter Reihenfolge

Dll Funktionen in bestimmter Reihenfolge