Ausgeführt als Standard x86. Wenn als x64 ausgeführt, dann kein Crash!
Da war ein Bug beim Memory kopieren in 32 Bit drin. Ist gefixt und sollte nun funktionieren (neues Release ist oben).
Leider befasse ich mich weniger mit höherer Mathematik,
Das ist im Grunde der Sinn dieser UDF: Höhere Mathematik nutzen ohne sich mit dieser auseinander setzen zu müssen.
Hast du die OpenBLAS-DLLs im richtigen Ordner?
Ich habe gerade nochmal das Release heruntergeladen (siehe >>hier<<). Da ist alles fix und fertig drin was man da braucht und es läuft bei mir ohne diesen Fehler.
Müssten wir mal schauen wie wir das reproduzieren können: 32/64 Bit? Welches BS?
Von Ingenieuren für Ingenieure 😉
Ok für die Fraktion, für die das (zu Recht) noch etwas zu abstrakt ist, habe ich mal ein weiteres Beispiel dem Example-Ordner hinzugefügt: InteractiveCircleFit.au3 (und das sogar auf deutsch!...)
Mit dem Skript klickt der User beliebige Punkte auf der Zeichenfläche und das Skript gleicht über diese Punkte einen bestanpassenden Kreis aus.
Das Beispiel eignet sich meiner Meinung nach sehr gut da man hiermit schnell viele Dinge der Ausgleichungsrechnung visualisieren kann:
- was sind Beobachtungen, was sind Parameter?
- was sind diese "Residuen"?
- was bedeuten die Standardabweichungen?
- was genau wird da eigentlich "ausgeglichen"?
- was bedeutet "robuste Ausgleichung"?
Einfach mal herumspielen damit (neues Release liegt auf Github).
Hinweis zur Urheberschaft: Da ich nicht so der visuelle Typ bin und von Grafik in AutoIt null Ahnung habe, habe ich mich für dieses Beispielskript intensiv Claude bedient.
Ich bin vom Ergebnis sehr angetan und freue mich, dass auch Claude die Verwendung meiner UDF komplett verstanden hat.
Ich brauche immer praktische Beispiele, die mir die Nutzung veranschaulichen.
Dafür habe ich das Tutorial gestaltet sowie einen extra example-Ordner mit weiteren Beispielen gemacht. Angesehen?
Mit anderen Worten: willst du wirklich hier eine WTFPL license Lizenz geltend machen?
Ja - ist ein Hobby - mehr nicht.
Nun ist es soweit: 11 Jahre Arbeit an dieser UDF und nun habe ich ein vorzeigbares Ergebnis.
Es handelt sich hier nicht um etwas beliebiges was nun auch mal in AutoIt umgesetzt wurde.
Tatsächlich ist mir kein Projekt wie dieses auch in anderen Sprachen bekannt.
Die Fähigkeit Usern selbst komplexeste Ausgleichungsrechnung dermaßen simpel zugänglich zu machen ist meines Wissens nach einzigartig.
Ausgleichungsrechnung war eher eine Nische für Geodäten und Mathematiker. Tatsächlich ist es aber ein derart nützliches Werkzeug bei allen Arten von fehlerbehafteten Daten - sprich: Messungen.
Was bisher einer weiten Verbreitung entgegenstand war die doch komplexe Mathematik dahinter.
Genau hier setzt die UDF an in dem sie diesen Aspekt dem User abnimmt. Er muss nur noch sein Problem beschreiben - den Rest macht die UDF.
Ich empfehle unbedingt das Tutorial mal durchzulesen um einen Eindruck zu bekommen um was es geht.
Gleichzeitig hoffe ich auf intensive Diskussionen zu euren konkreten Problemen die sich mit dieser UDF lösen lassen.
Bin ich etwas emotional? Definitiv! Diese UDF ist schon so etwas wie mein Lebenswerk.
Vom Umfang und fachlicher Tiefe geht es weit über alles hinaus was ich bisher gemacht habe.
Adjustment UDF — Ausgleichungsrechnung für AutoIt
Die Ausgleichungsrechnung nach der Methode der kleinsten Quadrate bestimmt aus überbestimmten, widersprüchlichen Beobachtungen die optimalen Werte — und sagt dir dabei genau, wie zuverlässig die Ergebnisse sind. Sie ist die mathematische Grundlage hinter Positionierung, Navigation, Kalibrierung, Fitting, Regression, Signalverarbeitung und praktisch jedem Bereich, in dem Messungen auf die Realität treffen.
Diese UDF bringt diese Fähigkeit mit einer radikal einfachen Schnittstelle nach AutoIt: Beschreibe dein Modell als String-Formeln, füge Messungen mit ihren Unsicherheiten hinzu und rufe _adj_solve() auf. Keine Matrizenrechnung, keine numerischen Kopfstände, keine externen Tools — nur dein Problem und deine Daten.
Unter der Haube steckt eine vollständige Ausgleichungsengine auf Basis von OpenBLAS mit nichtlinearen iterativen Lösern, Varianzkomponentenschätzung, robusten Schätzern und vollständiger statistischer Diagnostik — die Art von Werkzeug, die normalerweise MATLAB oder spezialisierter wissenschaftlicher Software vorbehalten ist.
Download: Aktuelles Release auf GitHub
GitHub: https://github.com/Sylvan86/autoit-adjustment-udf
Schnellstart
#include "Adjustment.au3"
; 5 Messungen einer Strecke — finde den besten Schätzwert
Local $mSystem = _adj_createSystem()
_adj_addObsFunction($mSystem, "M1", "X", 10.02, 1.0)
_adj_addObsFunction($mSystem, "M2", "X", 9.98, 1.0)
_adj_addObsFunction($mSystem, "M3", "X", 10.01, 1.0)
_adj_addObsFunction($mSystem, "M4", "X", 10.03, 1.0)
_adj_addObsFunction($mSystem, "M5", "X", 9.99, 1.0)
_adj_setInitialValue($mSystem, "X", 10.0)
_adj_solve($mSystem)
ConsoleWrite(_adj_displayResults($mSystem))
; Ergebnis: X = 10.006 ± 0.009Das ist nur der einfachste Fall — ein Mittelwert. Die eigentliche Stärke liegt im gleichzeitigen Ausgleichen verschiedener Messungen mit unterschiedlichen Formeln. Zum Beispiel: Die Position eines Punktes aus Strecken- und Richtungsmessungen bestimmen, oder eine Kurve an Daten anpassen und dabei Nebenbedingungen erzwingen.
Funktionsübersicht
Für Experten — der volle Umfang der UDF:
Modelltypen
Die Modelltyperkennung erfolgt automatisch anhand der Eingabestruktur.
Löser und Iterationsverfahren
Statistik und Diagnostik
Varianzkomponentenschätzung (VKS)
Helmert-Methode: Separate Varianzfaktoren für verschiedene Beobachtungsgruppen (z.B. Strecken vs. Richtungen). Iterativ bis zur Konvergenz.
Robuste Schätzung (IRLS)
Skalenparameter: MAD, s0, a priori, benutzerdefiniert.
Weitere Features
Installation
Voraussetzungen:
Einrichtung:
$__g_hBLAS_DLL = DllOpen("libopenblas_x64.dll")
#include "Adjustment.au3"
Dokumentation
Die vollständige Dokumentation ist auf GitHub verfügbar:
Tutorial-Kapitel
Download
>>> Aktuelles Release von GitHub herunterladen <<<
Quellcode und Issue-Tracker: https://github.com/Sylvan86/autoit-adjustment-udf
Aus meiner Sicht ist das durchaus ein Bug. Jedoch nicht von AutoIt sondern vom Tool Au3Check, welches oftmals vor AutoIt selbst aufgerufen wird.
Kann man ganz gut daran erkennen wenn man es deaktiviert indem man am Anfang des Skriptes folgende Zeile setzt: #AutoIt3Wrapper_Run_AU3Check=N - dann läuft das Skript problemlos.
Ich selbst bin kein Fan von dem meiner Meinung nach ziemlich verbuggten Tool. Das Ding erkennt viel zu viele False-Positives.
Ich möchte, dass dieser Code (oder ein funktionierender Code) „sha3_256” hasht.
Na gut ich habe mal eine Variante gefunden die damit funktionieren könnte (C-Code im Anhang).
Bei der Umsetzung sind mir aber ein paar Erweiterungen für die JIT.au3 aufgefallen, die hierfür benötigt werden.
Es ist also mindestens die neue Version v0.2.1 (siehe Link im ersten Post) zu verwenden.
Dann kann man sich damit eine sha3_256-Funktion in AutoIt folgendermaßen bauen:
#include "JIT.au3"
; hash a string
Global $sString = "Hallo Welt"
Global $bHash = _sha3_256($sString)
ConsoleWrite('sha3_256("' & $sString & '") = ' & StringTrimLeft($bHash, 2) & @CRLF)
; hash a file
Global $hFile = FileOpen(@ScriptDir & "\sqlite-preprocessed-3520000.zip", 16)
Global $bFile = FileRead($hFile)
FileClose($hFile)
Global $bHash = _sha3_256($bFile)
ConsoleWrite('sha3_256("sqlite-preprocessed-3520000.zip") = ' & StringTrimLeft($bHash, 2) & @CRLF)
Func _sha3_256($sString)
;~ Local Static $mCode = _JIT_Compile(FileRead('sha3_256_portable.c'))
Local Static $mCode = _JIT_LoadBinary(@AutoItX64 _
? '{"b":"QVdJifhBuc3MzMxMjRWuBQAAQVZNjbigAAAATY2YwAAAAEFVSY2A6AAAAEFUVUiNbyBTSIHs4AAAAEiNfCQIkEiNTCSoTInGTIn68w9vQojzD28aSIPCEEiDwRDzD2+SUP////MPb0rI8w9vYqBmD+/CZg/vw2YP78xmD+/BDylB8Ew52nXESYtQSEkzUCBMjWwk2DHJSTNQcEkzkJgAAABNiexJifZJM5DAAAAASIlUJMiNcQRJg8QISInySQ+v8UjB7iKNNLYp8o1xAUiJ8UkPr/FIY9JIwe4ijRy2ic4p3khj9kiLdPSoSNHGSDN01KhJiXQk+IP5BXW3TIn2TInBZkEPb00AMdLzD28EEWYP78EPEQQRSIPCKEiB+sgAAAB15kiDwRBJg8UQSDnNddFIicNIi0wk+EiJ6kgp64PjCHQcSI1VKEgxTQBIOcJ0H2ZmLg8fhAAAAAAADx9AAEgxCkgxSihIg8JQSDnCdfBIiXQkkEyNLcQDAABNicQx20yJVCSYSIlEJKBMifhMiWQkiI00G02J702J4jHSifFNizJJg8cUSYPCKEkPr8lIwekiRI0kiYnxg8YDRCnhRI0kiUGLT+xBAdSDwgFNY+RJ08ZOiXTkCIP6BXXBTItkJIiDwwFJg8UESYPECIP7BXWcSYnHSIt0JJBIi0QkoEiJ+0yLdCSYRTHkQY1MJAFBjVQkAkmJzEkPr8lIwekiRI0UiUSJ4UQp0UhjyUyNLM+J0UkPr8lIwekijQyJKcoxyUhj0kyNFNdJi1QNAEj30kkjFApIMxQLSIkUDkiDwShIgfnIAAAAdd9Ig8MISIPGCEGD/AV1k02NVghIjR3+AwAASYsWSTEQSTnaD4Wv/f//SIHE4AAAAFtdQVxBXUFeQV/DZmYuDx+EAAAAAABmkEFVMcBNicVBVEmJ1FVXVlNIicu5GQAAAEiB7AgCAABIjawkkAAAAA8ptCRgAQAASInvDym8JHABAABEDymEJIABAABEDymMJJABAABEDymUJKABAABEDymcJLABAABEDymkJMABAABEDymsJNABAABEDym0JOABAABEDym8JPABAADzSKtJgfiHAAAAdmpJiepFMclmZi4PH4QAAAAAAJBLjRQMMclFMcAPH4AAAAAAD7YCSIPCAUjT4IPBCEkJwIP5QHXrSYPBCE0xAkmDwghJgfmIAAAAdcdIie9Jge2IAAAASYHEiAAAAOhh/P//SYH9hwAAAHeWuREAAAAxwEiJ50mJ4vNIq02F7XQ1RInqSInnTInmQYP9CHIJRInpwekD80ilMcD2wgQPhUoBAAD2wgIPhSoBAACD4gEPhRUBAABCxgQsBkmJ6UUx24CMJIcAAACAZmYuDx+EAAAAAABMidIxyUUxwA8fhAAAAAAAD7YCSIPCAUjT4IPBCEkJwIP5QHXrSYPDCE0xAUmDwghJg8EISYH7iAAAAHXDSInv6Kv7//9FMclOi0QNAEqNBAsxyWZmLg8fhAAAAAAAZmYuDx+EAAAAAAAPH4AAAAAATInCSIPAAUjT6oPBCIhQ/4P5QHXrSYPBCEmD+SB1uQ8otCRgAQAADyi8JHABAABEDyiEJIABAABEDyiMJJABAABEDyiUJKABAABEDyicJLABAABEDyikJMABAABEDyisJNABAABEDyi0JOABAABEDyi8JPABAABIgcQIAgAAW15fXUFcQV3DD7YUBogUB+nf/v//D7cMBmaJDAdIg8ACg+IBD4TK/v//692LBokHuAQAAAD2wgIPhK3+///r1czMAAAAAAEAAAA+AAAAHAAAABsAAAAkAAAALAAAAAYAAAA3AAAAFAAAAAMAAAAKAAAAKwAAABkAAAAnAAAAKQAAAC0AAAAPAAAAFQAAAAgAAAASAAAAAgAAAD0AAAA4AAAADgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAIKAAAAAAAAAioAAAAAAAIAAgACAAAAAgIuAAAAAAAAAAQAAgAAAAACBgACAAAAAgAmAAAAAAACAigAAAAAAAACIAAAAAAAAAAmAAIAAAAAACgAAgAAAAACLgACAAAAAAIsAAAAAAACAiYAAAAAAAIADgAAAAAAAgAKAAAAAAACAgAAAAAAAAIAKgAAAAAAAAAoAAIAAAACAgYAAgAAAAICAgAAAAAAAgAEAAIAAAAAACIAAgAAAAIA","f":{"keccak_f1600":0,"sha3_256":688}}' _
: '{"b":"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","f":{"keccak_f1600":0,"sha3_256":832},"r":[407,791,798]}' _
)
Local $tHash = DllStructCreate("byte[32]")
If IsBinary($sString) Then
Local $tBinary = DllStructCreate("byte[" & BinaryLen($sString) & "]")
DllStructSetData($tBinary, 1, $sString)
DllCallAddress("NONE", $mCode.FuncPtr["sha3_256"], _
"STRUCT*", $tHash, _
"STRUCT*", $tBinary, _
"ULONG", BinaryLen($sString))
Else
DllCallAddress("NONE", $mCode.FuncPtr["sha3_256"], _
"STRUCT*", $tHash, _
"STR", $sString, _
"ULONG", StringLen($sString))
EndIf
If @error Then Return SetError(1, @error, Null)
Return DllStructGetData($tHash, 1)
EndFuncApropos testen:
Grandios! Die Lösung um eben doch sin/cos etc. im C-Code zu verwenden ist ja mal clever!
Damit erweitert sich die Einsatzmöglichkeit des ganzen enorm! Danke für diesen Ansatz.
Ich möchte, dass dieser Code (oder ein funktionierender Code) „sha3_256” hasht.
Ich brauche ihn, um die Datei „SQLite.zip” von ihrer Website zu hashen.
Kann das jemand von Ihnen erledigen? 👼
Das geht zumindest nicht mit dem gezeigten Code-Schnipsel. Siehe Abschnitt "Limitations" der Readme zur JIT.au3:
Limitations
This UDF is designed for small, self-contained code snippets - not for full C projects.
- No #include support - the C standard library is not available. There is no linker; the code must be fully self-contained.
- No math.h functions - sin(), cos(), pow() etc. require libm which is not linked. Some GCC __builtin_* functions work as inline alternatives (see examples/example_builtins.au3).
- Internet required for compilation - use _JIT_LoadBinary to work offline after the first compile.
- Single translation unit - all code must be in one string, no multi-file compilation.
Es braucht also einen Code der keine #includes nutzt und spezielle Funktionen evtl. ebenso sparsam einsetzt (wie man das umgehen kann hat UEZ soeben gezeigt).
Die "neuere" ist nur auf github, nicht in der Download-Datei
Tatsache! Bin noch neu in dem Metier - hab Releases bisher nicht genutzt. Muss halt dran denken das immer mit zu aktualisieren.
Sollte nun oben sein.
Kleine Abfrage: Aktuell ist in $mReturn.ptr der Pointer zum Code-Anfang. In $mReturn.Funcs stehen dann die einzelnen Offsets der Funktionen. Das hat zur Folge, dass man bei DllCallAdress beides für den Pointer braucht. Also z.B. sowas: DllCallAddress("double", $mCode.ptr + $mCode.Funcs["doubleIt"], "DOUBLE", 21.0)
Wenn man in .Funcs jedoch stattdessen die absoluten Pointer auf die Funktionen stehen hätte, dann könnte man sich das addieren sparen.
Ich denke daran, statt .Funcs zwei Maps zu verwenden: .FuncOffsets und .FuncPtr . Dann wäre der DllCallAddress-Aufruf schlanker und weniger fehleranfällig.
Was meint ihr dazu?
Ok ich habe soeben eine Änderung ins Repository gepusht: Die Binary-Strings im ReusableString sind ab sofort Base64-kodiert statt Hex-kodiert. Das macht sie kürzer was vor allem beim Einfügen in den Quellcode besser ist.
Wie gesagt: Dazu muss man aber die neueste Version verwenden.
den bekommt man nach dem $mCode = _JIT_Compile($sSourceCode)mit $mCode.BinaryString
Das ist die "alte" Variante. Hier muss man sich aber selbst um die Offsets für die Funktionen kümmern.
Da es hier nur eine Funktion gibt ist das aber nicht schädlich (und auf die Art sogar einfacher und kürzer).
Aber allgemein rate ich nun dazu, stattdessen den String $mCode.ReusableString zu verwenden - dann liefert _JIT_LoadBinary() auch $mCode.Funcs.
_JIT_LoadBinary() versteht beide Varianten.
Ansonsten klappt bei mir Andys Version ebenso. Sieht wieder einmal äußerst schick aus 
Ach Mensch. natürlich. war noch der alte Stand den ich im Kopf hatte. ja klar muss natürlich nun die andere variable sein. Sorry wegen der Verwirrung
Ich hatte die UDF vor nicht all zu langer Zeit aktualisiert. Schau also mal ob du die aktuelle Version hast.
Hatte das so umgestellt, dass man direkt die Offsets der Funktionen mit als String erhält und die nicht extra erfassen muss.
$oHTTP.SetProxy(2, "localhost:3128")
kann doch nicht funktionieren, da $oHTTP doch lokal in den Funktionen definiert wird, oder?
Doch - ist ne globale. Genau so verwende ich es auch ab und an - daher bin ich mir äußerst sicher, dass das funktioniert (mit NTLM geht es aber glaube ich nicht).
Kompiliert ergibt das folgendes:
Global $sBinary = @AutoItX64 _
? '{"b":"RYXAD46DAAAAQVRVV1aJ1lOF0n5wSInLRInHMclFMcBMY9pmZi4PH4QAAAAAAGaQRInARI0UiTHSTI0Mgw8fAInNjQRSMdVEMdBBiewPtsDB5QdBweQQgeUA/wAAQYHkAAD/AEQJ4AnoDQAAAP9BiQSRSIPCAUk503XFg8EBQQHwOc91q1teX11BXMPD","f":{"XorTexture":0}}' _
: '{"b":"VVdWU4PsBItUJCCF0n5xi0QkHIXAfmmLRCQci3wkGDH2jRyFAAAAAIkcJC6NdCYAjSy2MdIujbQmAAAAAI12AInRjRxSMfEx64nID7bbweEHweAQgeEA/wAAJQAA/wAJ2AnIDQAAAP+JBJeDwgE5VCQcdcyDxgEDPCQ7dCQgdbCDxARbXl9dwgwA","f":{"XorTexture":0}}'
Global $mCode = _JIT_LoadBinary($sBinary)Kompilieren klappt aber dann passiert nicht viel bei mir.
Vielleicht kann man ein Proxy mitgeben...
Kann man:
#include "JIT.au3"
$oHTTP.SetProxy(2, "localhost:3128")andere als C++-Compiler via _JIT_Compile() von der godbolt-Website einzusetzen
Eigentlich gut möglich, jedoch müsste man sich dort das Thema der Relokationen nochmal genauer ansehen. Ich habe das ja durch eine manuelle Ersetzung realisiert. Ob die Bezeichnungen bei den anderen Compilern da gleich sind weiß ich nicht, da ich erstmal nur auf den GCC hin implementiert habe.
Ich fände es besser, den C-Code direkt "inline" anzusprechen, wesentlich einfacher zu schreiben und zu debuggen.
Dann bräuchte es aber eine Art Präprozessor der die au3-Datei entsprechend aufarbeitet.
Das könnte man durchaus als ein Zusatzfeature mit einbauen.
Ansonsten teile ich aber deine Grundproblem mit den Multi-Line-Strings in AutoIt: die sind einfach Mist.
Mal als Ergänzung: Ich hatte AutoIt allgemein längere Zeit liegen gelassen.
Aber tatsächlich hat der Einsatz von KI da den Spaß wieder entflammt bei mir.
Die Idee und technische Umsetzung bekomme ich bei den allermeisten Dingen hin.
Aber was wirklich abfu**t ist der ganze Scheiß drumherum: Ordentlich formatieren, kommentieren, beschreiben, Codeverwaltung, Beispiele erstellen etc.
Genau hier ist für mich KI bislang der absolute Game-Changer so dass ich mich jetzt wirklich nur auf den Teil konzentrieren kann der wirklich Spaß macht.
Wir waren damals ja an der "direkten" Übermittlung des assemblierten Codes an den Assembler hängengeblieben....
Genau das!
Ich konnte die Relokationen schlussendlich auflösen indem ich das ganze zweimal kompiliere (mit unterschiedlichen Parametern) und dort dann die Relocations entsprechend ersetzen kann.
Das war der Durchbruch.
Manchmal wünscht man sich, dass kritische Teile eines AutoIt-Skripts mit nativer Geschwindigkeit laufen könnten - Schleifen, numerische Algorithmen oder Bit-Operationen, für die AutoIt schlicht nicht gemacht ist. JIT.au3 ermöglicht es, C-Code als String zu schreiben, zur Laufzeit zu kompilieren und direkt aus AutoIt aufzurufen.
Keine Compiler-Installation nötig. Alles was man braucht ist diese UDF und eine Internetverbindung.
Die Kompilierung übernimmt die Compiler Explorer (Godbolt) API - der erzeugte Maschinencode wird in ausführbaren Speicher geladen und ist über DllCallAddress aufrufbar.
GitHub: https://github.com/Sylvan86/autoit-jit-udf
Download: Releases
#include "JIT.au3"
; C-Code schreiben - exportierte Funktionen mit CALLCONV kennzeichnen
Global $sCode = _
'CALLCONV double doubleIt(double x) {' & @LF & _
' return x * 2.0; ' & @LF & _
'}'
; Über die Godbolt-API kompilieren
Global $mCode = _JIT_Compile($sCode)
; Kompilierte Funktion aufrufen
Global $aResult = DllCallAddress("double", $mCode.FuncPtr["doubleIt"], "DOUBLE", 21.0)
ConsoleWrite("Ergebnis: " & $aResult[0] & @CRLF) ; → 42.0
; Speicher freigeben
_JIT_Free($mCode)Bitte geht respektvoll mit der Godbolt-API um.
Der Compiler Explorer ist ein freies Community-Projekt. Jeder Aufruf von _JIT_Compile sendet eine Anfrage an deren Server.
Nach der ersten erfolgreichen Kompilierung kann der Binary-String gespeichert und wiederverwendet werden - keine weiteren API-Aufrufe nötig und deutlich schnellerer Start:
; Erster Lauf: kompilieren und ReusableString notieren
Global $mCode = _JIT_Compile($sCode)
ConsoleWrite($mCode.ReusableString & @CRLF) ; → diesen String speichern
_JIT_Free($mCode)
; Alle weiteren Läufe: aus gespeichertem ReusableString laden (kein Internet nötig!)
Global $mCode = _JIT_LoadBinary('{"b":"8g9YwMM","f":{"doubleIt":0}}')
Global $aResult = DllCallAddress("double", $mCode.FuncPtr["doubleIt"], "DOUBLE", 21.0)Siehe examples/example_reuse.au3 im Repository für eine vollständige Anleitung.
| Funktion | Beschreibung |
| _JIT_Compile($sCode) | C-Code kompilieren und ausführbaren Speicher zurückgeben |
| _JIT_LoadBinary($sBinary) | Zuvor kompiliertes Binary laden (kein API-Aufruf) |
| _JIT_Free($mCode) | Ausführbaren Speicher freigeben |
| _JIT_SetServer(...) | Server, Compiler, Sprache und Proxy konfigurieren |
| _JIT_GetCompilers() | Verfügbare Compiler auflisten |
| _JIT_GetLanguages() | Verfügbare Sprachen auflisten |
| _JIT_DescribeOpcode($sOp) | Beschreibung eines Assembler-Opcodes abrufen |
Diese UDF ist für kleine, eigenständige Code-Snippets gedacht - nicht für vollständige C-Projekte.
Im Repository sind fünf Beispiele enthalten:
Dieses Projekt wäre ohne den Compiler Explorer (Godbolt) von Matt Godbolt und Mitwirkenden nicht möglich. Es ist ein großartiges Open-Source-Werkzeug für die Programmier-Community. Bitte nutzt die API verantwortungsvoll.