Funktionsaufruf mit mehr als 15 Parametern

  • Hallo zusammen!

    XProfan speichert Fließkomma-Zahlen zwar auch in 64Bit aber entweder anders als übliche DOUBLE oder es liegt daran, dass XProfan bei externen DLL-Aufrufen nur mit 4Byte/32Bit Funktionsparameter übergeben kann. Der übliche und einzige mir bekannte Trick, dies zu umgehen, ist diesen Wert als 2 Parameter zu übergeben im Format long(a&,0), long(a&,4).

    Nun habe ich aber eine Funktion, welche 9 Parameter hat, wende ich den Trick an sind es 18 und Profan beschwert sich, dass es mehr als 15 sind. Profan2CPP kennt dieses Limit nicht und führ den Befehl korrekt aus:

    Code
    ogl("gluLookAt",long(eyeX&,0), long(eyeX&,4), long(eyeY&,0), long(eyeY&,4), long(eyeZ&,0), long(eyeZ&,4), long(centerX&,0), long(centerX&,4), long(centerY&,0), long(centerY&,4), long(centerZ&,0), long(centerZ&,4), long(upX&,0), long(upX&,4), long(upY&,0), long(upY&,4), long(upZ&,0), long(upZ&,4))

    Ich habe schon vieles probiert inklusive dem Bau eines einzigen Bereiches den ich wahlweise direkt oder als Char$(params#,0,72) übergebe. Der Fehler ist wohl, dass Profan nur genau 4 Byte pro Parameter übergibt und ich so nie auf die angeforderten 72 Byte komme.

    Kennt ihr irgendwelche Worarounds?

    Viele Grüße

    Sven

    • Anzeige

    Hallo!

    Wenn du gerade an deiner Website arbeitest oder dein aktuelles Hosting überdenkst: Wir betreiben mit NetzLiving eine Hosting-Plattform, die speziell auf Performance, Sicherheit und einfache Verwaltung ausgelegt ist.

    • ✔️ Schnelle Ladezeiten (optimiert für WordPress, WoltLab & Co.)
    • ✔️ Deutsche Server & DSGVO-konform
    • ✔️ Persönlicher Support (kein 0815-Ticket-System)

    Mehr erfahren

  • Hast du auch schon über den Typ Single probiert ?

    In der Hilfe steht da ja auch was :

    Normalerweise ist dieser Typ ja speziell dafür gemacht worden.

    Opengl ist ja auch eine DLL und mit oGL("API-Funktion",.....) kann man ja die API aufrufen. Also genau, wie in deinem Fall.

    Ist halt nur die Frage, wie RGH über den oGL() -Aufruf den Floatparameter übergibt. Probier es doch mal mit der DLL direkt.

    Da gibt es auch noch die Opengl.ph .https://xprofan.net/intl/de/header/

    Dort ist auch dein Befehl

    gluLookAt

    definiert. Vielleicht kommst du dann der Lösung näher.

    Wir sind die XProfaner.

    Sie werden von uns assimiliert.

    Widerstand ist zwecklos!

    Wir werden alle ihre Funktionen und Algorithmen

    den unseren hinzufügen.

  • Danke für deine Antwort! Leider will gluLookAt ein GLdouble (64 Bit IEEE-754 floating-point value). Wie in der Beschreibung von Profan steht kommt Single als 32 Bit an. Die Formate wären ggf. kompatibel, dennoch muss ich die restlichen 32Byte auffüllen, was so aussehen könnte:
    ogl("gluLookAt", single(par1&),0,single(par2&),0,...)

    Ob das grundsätzlich geht weiß ich nicht aber ich komme ja wieder auf 2x9 = 18 Parameter. Wenn ich nur die 9x Single() verwende, kommen am Ende 2 Zahlen in eine gepackt heraus und die zweite Hälfte ist gar nicht gesetzt.

  • Schau mal hier :

    Forum/ogl : glOrtho stürzt ab... XProfan

    Da hat es wohl was ähnliches gegeben und wie es Uwe Pascal Niemeier gelöst hat.

    Vielleicht muß man da tatsächlich einen Bereich# nehmen und nicht einen Long oder Pointer.

    Vielleicht irre ich mich da aber auch.

    Was die Anzahl Parameter betrifft, kann ich auch nicht weiterhelfen, außer dem oben Gesagten.

    (z.b. DLL direkt ansprechen)

    Wir sind die XProfaner.

    Sie werden von uns assimiliert.

    Widerstand ist zwecklos!

    Wir werden alle ihre Funktionen und Algorithmen

    den unseren hinzufügen.

    Einmal editiert, zuletzt von H.Brill (31. Juli 2023 um 17:21)

  • Danke für die Recherche! Long() funktioniert ja super, egal welche Variante. Ob man da einen Bereich nimmt oder die Adresse von einer Variable geht beides nur wird in beiden Fällen auch die Parameteranzahl verdoppelt, bei glOrtho klappt das noch von 6 auf 12 Parameter, von 9 auf 18 leider nicht mehr. Ich denke, wenn ich es wirklich in XProfan verwenden möchte, muss ich erst eine Wrapper-DLL dafür schreiben (ironischerweise auch in Profan aber compiliert in C++).

  • Hast du auch alles ausgeschöpft, was XProfan bietet ?

    External + Call haben wir ja auch noch.

    Vielleicht sowas :

    Code
    declare Long dll, adr
    cls
    dll = ImportDLL("Glu32.dll", "")
    adr = faddr("gluLookAt")
    Print adr
    Call(adr, P1...P19)
    Waitkey
    FreeDll dll

    vielleicht erlaubt das mehr Parameter.

    Wenn das auch nicht geht, wird es schwer. Da müßte man an den Parameterstack der Funktion gluLookAt ran kommen.

    Dann hat RGH wohl die 15Parametergrenze xprofan-systemweit eingebaut.

    Da hätten wir ja noch einen Bug, bzw. worauf RGH nicht geachtet hat..

    Es kann ja wohl nicht sein, daß man keine API/DLL - Funktionen mit mehr als 15 Parametern

    aufrufen kann. Zumal er den Aufruf der GLU-API mit oGL("Name",...) auch noch anbietet.

    Vielleicht könnte er auch eine Ausnahme dafür schaffen :

    Set("DLLParameters", anzahl&) -> Set("DLLParameters", 20)

    oder statt anzahl& 0 / 1, das die Parametergrenze aus bzw. anschaltet.

    Aber vielleicht geht das für ihn auch aus technischer Sicht nicht. evtl. Begrenzung bei Delphi ?

    Leider meldet sich RGH ja nicht mehr, um solche Sachen zu beantworten.

    Wir sind die XProfaner.

    Sie werden von uns assimiliert.

    Widerstand ist zwecklos!

    Wir werden alle ihre Funktionen und Algorithmen

    den unseren hinzufügen.

    2 Mal editiert, zuletzt von H.Brill (1. August 2023 um 08:14)

  • Du ahnst es, es kam die gleiche Fehlermeldung.

    Der Befehl ist gar nicht so ungebräuchlich, es ist letztendlich der normale Weg, die Kamera oder den Betrachter bei einer OpenGL Szene zu setzen. So bleibt nur der Weg, alles andere um den Betrachter zu Bewegen oder zu Drehen. Beide Wege sind im Prinzip anerkannt aber je nach Projekt ist es doch leichter zu handlen, wenn man nicht erst umdenken muss.

    Das Herumwerkeln in der ProjektionsMatrix ist nichts, was mir Spaß macht aber mit ein bisschen Hilfe von ChatGPT konnte ich eine funktionierende Ersatzfunktion erstellen. Ob sie wirklich in jedem Kontext wie das Original arbeitet kann ich noch nicht sagen aber in meinem Code hat es funktioniert:

  • Dann kann man wohl nichts dran ändern, aber schön, daß du einen

    Workarround dazu gefunden / überlegt hast.

    Ich habe es trotzdem mal bei xprofan.net bei Wünsche und Anregungen

    reingestellt.

    Vielleicht reagiert RGH doch noch, bzw. kann was dazu sagen.

    Mehr als 15 Parameter kann ja doch mal öfter vorkommen, nicht nur

    bei OpenGL. Wenn es Delphi-technisch nicht möglich ist, käme vlt.

    auch eine Bereichsvariable mit einer Struktur (wegen verschiedenen

    Datentypen) als einziger Parameter in Frage. Dann ist aber das Problem,

    wie er das wieder zu einzelnen Parametern außeinander dröselt.

    API-technisch dürfte ein Aufruf mit mehr als 15 Parametern kein Problem

    sein, da es dann diese Funktion einfach nicht gäbe oder halt mit weniger

    Parametern.

    Wir sind die XProfaner.

    Sie werden von uns assimiliert.

    Widerstand ist zwecklos!

    Wir werden alle ihre Funktionen und Algorithmen

    den unseren hinzufügen.

  • Hallo,

    da wird die Glu32.dll aufgerufen. Und jede 32-bit-DLL hat Parameter, die *immer* exakt 4 Bytes breit sind und absolut niemals irgendetwas anderes. Man kann also niemals einen Float-*Wert* direkt als Parameter an eine DLL übergeben. Wohl aber die *Adresse* einer Variablen, die so einen Wert enthält. Die Adresse ist nämlich bei 32-bit-Systemen immer 4 Bytes breit und passt damit als DLL-Parameter.

    Es müsste also wohl

    ogl("gluLookAt",@Addr(eyeX!), @Addr(eyeY!), ...

    heißen. Probier das doch mal aus. Wenn das auch nicht geht, verstehe ich diese DLL nicht, um ehrlich zu sein.

    Gruß, Jens-Arne

  • Wenn es Delphi-technisch nicht möglich ist, käme vlt.

    auch eine Bereichsvariable mit einer Struktur (wegen verschiedenen

    Datentypen) als einziger Parameter in Frage. Dann ist aber das Problem,

    wie er das wieder zu einzelnen Parametern außeinander dröselt.

    Es kann und muß nichts aufgedröselt werden. Auch die Adresse einer Struktur geht nicht. An eine DLL kannst Du Parameter nur in der Form geben, wie die DLL die haben will. Die dröselt das nämlich auf, was Du anbietest. Entweder byval, also den Wert direkt oder byref, das wäre dann eine Adresse. Das ist nicht einfach mal so wahlfrei verwendbar, sondern wird eindeutig durch die DLL vorgeschrieben. Die erwartet einfach, daß genau so viele Werte auf dem Stack liegen, wie sie haben will.

    Weiterhin muß die Aufrufkonvention stdcall oder cdecl richtig eingesetzt werden. Glücklicherweise müssen wir wenigstes darüber kaum nachdenken, in der Windowswelt wird überwiegend stdcall verwendet. Das paßt eigenlich auf alle gängigen DLLs. Und notfalls gäbe es da auch noch Set("CallConv", S) ;)

    Gruß Volkmar

  • Ich meinte das ja eher beim oGL() - Aufruf. Die Funktionen der glu32.dll werden ja nicht vom Programmierer

    direkt zur DLL, sondern durch die oGL - Funktion, die RGH bereitstellt, aufgrufen. und genau dazwischen

    (nach Übergabe an oGL() <--> Dann Aufruf der eigentlichen DLL-Funktion) müßte das passieren.

    Egal, ob byval oder byref, es beantwortet aber immer nocht nicht die Frage, warum man in XProfan nur

    DLL-Funktionen mit höchstens 15 Parametern aufrufen kann. Bei Xprofans eigenen oder selber geschriebenen

    Funktionen könnte ich es ja noch verstehen. Aber was hat XProfan bei fremden DLL-Funktionen damit am Hut ?

    XProfan linkt die Funktionen ja nur mit ein, bzw. stellt deren Funktionsadressen bereit. Der Funktionsaufruf samt

    Parameter bleibt immer noch dem Anwender, der die Funktion braucht, überlassen. Es kommt ja jetzt darauf an,

    wie RGH die DLL-Funktionen handhabt. Soviel, wie ich weiß, werden diese in eine interne Liste aufgenommen,

    wo auch die selbst geschrieben Procs stehen. Wie geht es dann weiter ? Wird dann zwischen selber geschriebenen

    und externen Funktionen unterschieden und wie werden sie aufgerufen ? Vielleicht liegt in dieser Extrationsschicht

    der Hase begraben. Aber diese Internas kennt nur RGH.

    Wenn das API-technisch mit mehr als 15 Parametern nicht ginge, hätte der Autor der Funktion gluLookAt diese

    erst gar nicht mit 19 Parametern angeboten.

    Man müßte mal schauen, wie das ganze rein über API aussieht. Also Laden der DLL mit LoadLibrary, GetProcAdrr()

    usw. Jetzt müßte man noch wissen, wie man eine DLL-Funktion über API aufruft. Wenn das geht, liegt es mit

    Sicherheit an XProfans Interna.


    Ich habe mal bei gluLookAt nachgeschaut. Das sind ja gar keine 19 Parameter, sondern 9.

    bei PureBasic :

    und bei MS :

    gluLookAt-Funktion (Glu.h) - Win32 apps
    Die gluLookAt-Funktion definiert eine Anzeigetransformation.
    learn.microsoft.com

    Das hat eindeutig damit zu tun, daß RGH immer nur 32bittig übergibt. Also müssen die 9 64Bitwerte auseinander genommen werden.

    Bei Call und External steht ja :

    Spoiler anzeigen

    Call

    Fließkommawerte und -variablen werden grundsätzlich als 32-Bit-Single übergeben. Hierbei ist es unerheblich, ob die Variable eine FLOAT oder SINGLE ist. Nötigenfalls wird konvertiert.

    Da müßte RGH doch einen Fehler bekommen, da die Funktion eindeutig 64Bit-Werte verlangt.

    Irgendwie scheitert es an meinem Vertändnis, was das Weiterreichen der Parameter betrifft.

    Wir sind die XProfaner.

    Sie werden von uns assimiliert.

    Widerstand ist zwecklos!

    Wir werden alle ihre Funktionen und Algorithmen

    den unseren hinzufügen.

    3 Mal editiert, zuletzt von H.Brill (3. August 2023 um 08:46)

  • Aber was hat XProfan bei fremden DLL-Funktionen damit am Hut ?

    XProfan linkt die Funktionen ja nur mit ein, bzw. stellt deren Funktionsadressen bereit. Der Funktionsaufruf samt

    Parameter bleibt immer noch dem Anwender, der die Funktion braucht, überlassen.

    So ist es eben nicht. Der Aufrufer, also Profan, ist verantwortlich, die Parameter genau in der Form, Varianten habe ich genannt, bereit zu stellen, wie die DLL die verlangt. Dir bleibt nichts überlassen, da mußt Du Dich dran halten. Da wird nicht einfach nur eine Funktionsadresse irgendwie verlinkt. Da wird der Stack des Systems entsprechend den Forderungen der DLL mit den Parametern oder den Adressen der Parameter und der Rücksprungadresse belegt.

    Einzige Möglichkeit wäre, das Limit der Parameterzahl aufzuheben. Das sollte sicher machbar sein. Roland hat sich da bei der Festlegung der Parameterzahl an Funktionen, die Windows bereitstellt, orientiert. Da reichen 15 Parameter, mehr gibt es da nicht.

    Bei anderen Programmiersprachen funktioniert es ohne Limit, die arbeiten anders. Profan erzeugt auch nach dem Compilieren keinen nativen Code. Man kann mal ganz dumm sagen, der Compiler in Profan komprimiert den Quelltext nur (ersetzt die Namen der Funktionen durch Token und faßt alle Funktionsaufrufe in einer Liste zusammen). Es ist ungefähr das, was Basicinterpreter in der Zeit der speicherschwachen 8-Bit-Rechner jeweils nach der Eingabe einer Zeile gemacht haben. Sogar das Format des Kompilates läßt da Paralellen erkennen :wink:. Da die keine Funktionsliste erstellen konnten und man auch rückwärts und durch Angabe der Zeilennummer schnell durch den Quelltext lesen kann, ist das Format dort allerdings etwas komplexer.

    Der komprimierte Quelltext wird dann mit dem Runtime-Modul zu einer Datei gelinkt und die Runtime arbeitet dann den komprimierten Quelltext genau so ab, wie der Interpreter den normalen Quelltext. Und da liegt eben auch wieder ein Problem. Nach dem Aufruf einer externen Funktion muß der Rücksprung in die Runtime verweisen, damit die überhaupt weiter arbeitet. Der Rücksprung in den Quelltext muß da wieder gesondert behandelt werden.

    Gruß Volkmar

  • Nur mal so als spontaner Gedanke... Da sich das 15er-Limit in Profan wohl nicht so ohne Weiteres umschiffen lässt, könnte man sich ggf. einen Workarround basteln, indem man den Aufruf solch einer "parameterlastigen" Funktion in eine DLL (evtl. als MemoryModul) verlagert. Man müsste dann alle Parameter häppchenweise in max. 15er-Paketen auf den Stack innerhalb der DLL packen, von dort dann wieder herunterholen und der nachfolgend aufzurufenden Funktion übergeben. Aber ob sich der Aufwand lohnt...?!

    Matthias Arlt
    WinXP SP2/Win7 - XProfan 10/11/FreeProfan32 - Xpia

  • Das Prinzip wäre machbar. Eine DLL, der man alle Parameter als Liste, also Zeiger auf einen Speicherblock, übergibt und die DLL nimmt dann aus der Liste die Einzelwerte und gibt sie entsprechend als Folge von Einzelparametern weiter. Dann braucht es nur einen Aufruf, nur das Format der Parameter wird durch die DLL den Erfordernissen angepaßt.

    Gruß Volkmar

  • Ja, so dachte ich mir das. Parameterübergabe 'en bloc' ist natürlich auch elegant. Und um das Ganze dann noch universell zu gestalten, könnte man ja den Namen der Funktion und das beinhaltende Modul auch gleich noch per Parameter übergeben. Oder ggf. noch andere Optionen einbauen...

    Matthias Arlt
    WinXP SP2/Win7 - XProfan 10/11/FreeProfan32 - Xpia

  • So ist es eben nicht. Der Aufrufer, also Profan, ist verantwortlich, die Parameter genau in der Form, Varianten habe ich genannt, bereit zu stellen, wie die DLL die verlangt.

    Eben nicht. Warum schreibt RGH in der Hilfe zu Call und External , daß 32 Bit prinzipiell übergeben werden ggf. wird umgewandelt ?

    Ist das auch bei ImportDLL so ?

    Steht ja auch so oben im Zitat von der Hilfe. Was ist jetzt, wenn die DLL 64Bit Parameter verlangt ?

    Anbei mal eine Test DLL, mit EBASIC erstellt, zum Ausprobieren :

    Hab jetzt schon einiges probiert, bei der 64Bit Variante (funk64) funktioniert es nicht.

    Kann das jemand zum Laufen bringen ?

    Dateien

    Wir sind die XProfaner.

    Sie werden von uns assimiliert.

    Widerstand ist zwecklos!

    Wir werden alle ihre Funktionen und Algorithmen

    den unseren hinzufügen.

  • Warum schreibt RGH in der Hilfe zu Call und External , daß 32 Bit prinzipiell übergeben werden ggf. wird umgewandelt ?

    Eben genau drum. Die Parameter müssen in der Form vorliegen, wie die DLL zu erwartet. 32-Bit-DLLs erwarten üblicherweise 32-Bit-Parameter. Also werden Fließkommazahlen immer automatisch umgewandelt. Was willst Du mit den 64-Bit-Parametern erreichen? Profan übergibt alles als 32 Bit. Da kannst Du in die DLL einbauen, was Du willst.

    Funktionieren kann das, indem Du die Adressen der 64-Bit-Werte übergibst. Dann muß allerdings der Code der DLL dementsprechend anders sein. Der muß nun seinerseits jeweils 64 Bit aus der übergebenen Adresse lesen. Also Parameter byref. Ich kenne ebasic nicht, weiß nicht, ob da eine Möglichkeit zu besteht, Werte byref zu übergeben. Und für die Rückgabe gilt das auch. Profan erwartet da einen 32-Bit-Wert, also kann nur eine Funktion aufgerufen werden, die das auch liefert.

    Und das ist in der 32-Bit-Welt so üblich. Nicht umsonst macht selbst Microsoft das so. Da wird in Funktionen, die mehr als 32 Bit liefern ein zusätzlicher Parameter verwendet. Der enthält die Adresse eines Speicherbereiches, wo das Ergebnis durch die DLL reingeschrieben werden muß.

    Gruß Volkmar

    Nachtrag: Profan nimmt als Rückgabewert immer den Inhalt des Prozessorregisters EAX.

  • Dann frage ich mich, warum es die Funktion Single() gibt, wenn der Wert sowieso in 32Bit beim Übergeben umgewandelt wird.

    Die Floatvariablen sind ja nur wegen der doppelten Genauigkeit interessant, was man ja meistens nicht braucht.

    Ist auch wahrscheinlich wegen der Abwärtskompabilität von Profan geschuldet, als es damals nur ! und Float gab..

    Da könnte man bei den oGL - Geschichten doch gleich Single (entweder als Variable oder mit Single() konvertiert) übergeben.

    Dann müßten ja auch die von der API geforderten 9 Parameter von gluLookAt reichen.


    siehe

    Spoiler anzeigen

    Hilfsfunktionen für 32-Bit-Fließkommazahlen

    28.9 - Hilfsfunktionen für 32-Bit-Fließkommazahlen

    Na egal, es wird mir langsam zu kompliziert. Arbeite lieber mit den normalen Dingen.

    Trotzdem Danke für die Statements.

    Wir sind die XProfaner.

    Sie werden von uns assimiliert.

    Widerstand ist zwecklos!

    Wir werden alle ihre Funktionen und Algorithmen

    den unseren hinzufügen.

  • Vielen Dank für die zahlreichen Beiträge. Leider ist bei mir bei dem Thema viel Halbwissen dabei. Grundsätzlich gilt, dass man jeden Datentyp umwandeln und damit einiges zum Laufen bringen kann. Die 2x long() statt einem long wegen der 32 Bit Parameterbeschränkung von Profan sind da schon gehakt, wenn auch in diesem Fall eine Sackgasse.

    H.Brill Single() macht Profan aus einem 64 Bit Float ein 32 Bit Float mit dem es selbst nicht rechnen es aber an Funktionen übergeben kann. Ich glaube die Wrapper-Funktion ogl("",) macht das automatisch für jeden Float-Wert den man reinwirft. Die Anmerkung in der Hilfe, dass ein 32 Bit Float in ein 32 Bit Longint gepseichert wird finde ich irreführend... sind 32 Bit nicht gleich 32 Bit? Es ist doch die Zielfunktion, welche die Bitfolge interpretiert wie sie möchte.

    Jens-Arne Wie andere Sprachen das machen weiß ich nicht aber es funktioniert ja mit anderen Funktionen der glu32.dll auch mit zwei Parametern als long. Der einzige "Fehler" ist das Parameterlimit von Xprofan, sonst würde es gehen.

  • Was mich noch interessieren würde, ist, wo du die Parameterzahl von 19 her hast.

    Die normalen oGL-Funktionen arbeiten ja normal mit einem normalen Floatwert, der

    dann in 32Bit umgewandelt wird.

    Woher weiß RGH denn, wann eine API-Funktion benutzt wird ? Gut, das könnte

    er herausbkommen, weil der erste Wert von oGL (Containerfunktion) der Funktionsname

    ist. Und wenn der dann nicht in seiner Liste steht, ist es eine API. bzw. kann man das

    noch am Anfang mit "glu..." usw. erkennen.

    Ist halt gut, daß man das jetzt weiß. Da es nicht in der Hilfe steht, hätte ich mir einen

    Wolf gesucht. Sowas müßte doch dann unbedingt in die Hilfe rein.

    Was ist denn eigentlich von MakeLong() zu halten ? Sollte ja nur für Words (2 Bytes) gehen.

    z& = MakeLong(1.50, 2.30) bringt auch ein Ergebnis. Nehme an, wegen der autom. Konvertierung.

    Wird wohl ein falsches Ergebnis sein.

    Sowas bräuchte man dann auch für 2 Floatzahlen. Wäre einfacher, als über Bereiche.

    Wir sind die XProfaner.

    Sie werden von uns assimiliert.

    Widerstand ist zwecklos!

    Wir werden alle ihre Funktionen und Algorithmen

    den unseren hinzufügen.

Jetzt mitmachen!

Sie haben noch kein Benutzerkonto auf unserer Seite? Registrieren Sie sich kostenlos und nehmen Sie an unserer Community teil!