Assemblercodes für das neue X4

RGH · 25. März 2017, 00:18

Ein erste Minimal-Assembler-Programm zum Addieren zweier Zahlen:

Quellcode

CLS
ASM "MeineFunktion", 2
mov eax,par1
mov ebx,par2
add eax,ebx
ENDASM
Var Long Ergebnis = MeineFunktion(38764, 879879878)
Print Ergebnis
Print "Fertig!"
WaitInput

Alles anzeigen

Die Zahl hinter dem Funktionsnamen gibt die Anzahl der Parameter an. Diese ist wichtig, damit nach dem Aufruf korrekt "aufgeräumt" wird. Im Debug-Modus, der derzeit im Interpreter noch fix eingestellt ist, wird ein Assemblerlisting für jede ASM-Funktion ausgegeben. Der Dateiname ist der Funktionsname mit der Endung "lst". Dieses Listing sieht hioer so aus:

Quellcode

MeineFunktion - 2
0000 55 PUSH ebp
0001 89E5 MOV ebp,esp
0003 8B4508 MOV eax,par1
0006 8B5D0C MOV ebx,par2
0009 01D8 ADD eax,ebx
000B 89EC MOV esp,ebp
000D 5D POP ebp
000E C20800 RET 8
5589E58B45088B5D0C01D889EC5DC20800

Alles anzeigen

Das zwingend notwendige "PUSH EBP" und "MOV EBP,ESP" am Anfang, sowie das "MOV ESP,EBP" und "POP EBP" und das "RET x" fügt XProfan selbsttätig hinzu. Vom ESP-Register (Stack) sollte man auf alle Fälle im Code die Finger lassen!

Par1 steht für [ebp + 8] (die Speicherstelle an der der erste Parameter abgelegt wird), Par2 für [ebp + 12], etc. Da wir uns in der 32-Bit-Welt befinden hat jeder Parameter eben 4 Byte! Der Wert in EAX ist der Rückgabewert der Funktion.

Der ASM-Befehl assembliert den nachfolgenden Code bis ENDASM und fügt die Funktion der Liste der importierten Funktionen bei, so wie es auch ImportDLL und ImportFunc machen. Anschließend steht die Funktion dem Programm zur Verfügung.

Gruß
Roland

RGH · 25. März 2017, 00:27

Und hier ein etwas komplexeres Beispiel mit Sprüngen und Strings direkt aus dem XProfan-Quellcode (Verschlüsselungsroutine, basierend auf einem Assemblercode von Frank Abbing):

Quellcode

window 1000,1000
declare string text, pw
ASM "crypt", 2
// Crypt proc
PUSH EBX
PUSH ESI
PUSH EDI
PUSH EBP
// setze AnsiString-Pointer
MOV EDX, Par1 // s
MOV ECX, [edx-4] // len(s)
MOV EBX, Par2 // pw
MOV ESI, [ebx-4] // len(pw)
MOV EDI,0
@@jaguar:
mov al,[edx]
xor al,[ebx+edi]
mov [edx],al
inc edx
inc edi
cmp esi,edi
jne @@kniez
mov edi,0
@@kniez:
sub ecx,1
jne @@jaguar
XOR EAX, EAX
POP EBP
POP EDI
POP ESI
POP EBX
ENDASM
text = "Mein Text"
pw = "Pass22"
Var Long Ergebnis = Crypt(text, pw)
Print Ergebnis
Print text
Crypt(text, pw)
Print text
WaitInput

Alles anzeigen

Die vier PUSH un POP am Anfnag/Ende kann man auch weglassen. Beim Delphi-Inline-Assembler sind sie empfehlenswert, da Delphi die Register auch zur Parameterübergabe nutzt. Die "@@" bei den Labels kann man auch weglassen. Ich habe den Teil eben einfach aus meinem Delphicode kopiert und lediglich "Par1" und "Par2" eingesetzt.

Gruß
Roland

RGH · 25. März 2017, 00:38

Und auch die Windows-API kann genutzt werden. Drei unterschiedliche Beispiele mit gleichem Ergebnis:

Quellcode

CLS
Declare handle hDLL, Funk, String Text
hDLL = UseDLL("USER32.DLL") ' Handle von USER32 ermitteln
funk = ~GetProcAddress(hDLL, "MessageBoxA") ' Adresse der Funkton ermitteln
ASM "MsgBox", 5 ' Ein Parameter Adresse + 4 Parameter für die Messagebox
// Parameter einlesen
MOV ECX, Par1
MOV EAX, Par2
MOV EDX, Par3
MOV ESI, Par4
MOV EBX, Par5
// Messagebox-Parameter auf den Stack
PUSH EBX
PUSH ESI
PUSH EDX
PUSH EAX
// Funktion aufrufen
CALL ECX
ENDASM
Print MsgBox(funk, %hWnd, "Das ist die Botschaft!", "Titel", 51)
waitinput

Alles anzeigen

Es geht auch mit weniger verschwenderischem Registerverbrauch:

Quellcode

$H windows.ph ' WindowsHeaderdatei nutzen
CLS
Declare handle hDLL, Funk, String Text
hDLL = UseDLL("USER32.DLL") ' Handle von USER32 ermitteln
funk = ~GetProcAddress(hDLL, "MessageBoxA") ' Adresse der Funkton ermitteln
ASM "MsgBox", 5 ' Ein Parameter Adresse + 4 Parameter für die Messagebox
// Parameter einlesen
MOV EAX, Par5
PUSH EAX
MOV EAX, Par4
PUSH EAX
MOV EAX, Par3
PUSH EAX
MOV EAX, Par2
PUSH EAX
MOV EAX, Par1
// Funktion aufrufen
CALL EAX
ENDASM
Print Funk
Print MsgBox(funk, %hWnd, "Das ist die Botschaft!", "Titel", 51)
waitinput

Alles anzeigen

Und ein erstes Makro "FCALL" erlaubt den direkten Aufruf aller mit ImportFunc, ImportDLL und ASM importierten Funktionen:

Quellcode

$H windows.ph ' WindowsHeaderdatei nutzen
CLS
Declare handle hDLL, String Text
hDLL = UseDLL("USER32.DLL") ' Handle von USER32 ermitteln
ImportFunc(hDLL, "MessageBoxA", "")
ASM "MsgBox", 4 ' 4 Parameter für die Messagebox
// Parameter einlesen
MOV EAX, Par4
PUSH EAX
MOV EAX, Par3
PUSH EAX
MOV EAX, Par2
PUSH EAX
MOV EAX, Par1
PUSH EAX
// Funktion aufrufen
FCALL MessageBoxA
ENDASM
Print MsgBox(%hWnd, "Das ist die Botschaft!", "Titel", 51)
waitinput

Alles anzeigen

Beim Assemblieren wird aus FCALL dann "MOV EAX, Funktionsadresse" und "CALL EAX", wie auch im erzeugten Listing zu sehen ist. Das EAX-Register bietet sich hier an, weil es ja ehr von der Funktion verändert wird und das Ergebnis aufnimmt.
Ach ja: Bei der innerhalb Windows gültigen Aufrufkonvention STDCALL ist immer die Funktion für das Aufräumen des Stacks zuständig. Das heißt, die auf den Stapel geschobenen Parameter werden von der Funktion wieder von diesem entfernt. Für den Stapel gilt "Last In - First Out", daher wird der erste Parameter zuletzt auf den Stapel gelegt.

Gruß
Roland

RGH · 26. März 2017, 01:55

Und hier etwas für die Mathematiker unter uns:

Quellcode

// Quelle des Assemblerlistings:
// https://helloacm.com/fib-number-inline-assembly-delphi/
CLS
Declare int zahl
ASM "Fibonacci", 1
PUSH EBX
MOV EAX,Par1
TEST EAX, EAX
JZ @M
MOV ECX, EAX
XOR EAX, EAX
MOV EDX, 1
@L:
MOV EBX, EDX
ADD EDX, EAX
MOV EAX, EBX
LOOP @L
@M:
POP EBX
ENDASM
For zahl,1,30
Print Fibonacci(zahl)
EndFor
WaitInput
End

Alles anzeigen

Gruß
Roland

H.Brill · 26. März 2017, 09:25

Da mir an ASM-Wissen noch etliches fehlt :
Vielleicht kann Roland oder wer anderes mir weiterhelfen.
Ich will mir ein Spezialfunktion (Enum) bauen. Da ein
Assembler auch ein Array als linearen Speicherbereich
ansieht, könnte man diese Funktion sowohl für Arrays
als auch für Bereiche nutzen.
Das hier funktioniert noch nicht :

Quellcode

Declare Int A[20]
Declare Memory Bereich
Dim Bereich, 100
Long Bereich,0 = 1,2,3,4,5
CLS
ASM "Enum", 3
PUSH EBX
PUSH ESI
PUSH EDI
PUSH EBP
MOV ESI,PAR1
MOV EDI,PAR2
MOV EBX,PAR3
XOR ECX,ECX
MOV EDX,1
@B:
ADD ESI,4 ' offset + 4 Bytes
MOV ESI,EDX
MUL ESI,ECX
MUL ESI,EBX
INC EDX
INC ECX
CMP ECX,EDI
JNE @B
ENDASM
Enum(A[], 20, 1)
Enum(Bereich, 20, 1)
WhileLoop 0,19
Print "Array : "; A[&LOOP], "Bereich : "; Long(Bereich, &LOOP * 4)
EndWhile
Print
WaitKey
Dispose Bereich
End

Alles anzeigen

Der zweite Parameter ist die Anzahl der Elemente (z.B. Größe des Arrays).

Enum(A[], 20, 1) sollte ein Array forlaufend numeriert füllen,
also
A[0] = 1
A[1] = 2
A[2] = 3
.....
A[19] = 20
Enum(A[], 20, 10) sollte ein Array in 10er Schritten füllen,
also
A[0] = 10
A[1] = 20
A[2] = 30
.....
A[19] = 200

Wäre dann auch für Bereiche interessant.
Long Bereich, 0 = 1,2,3,4,5
geht ja sowieso. Aber bei z.B. Tausenden von Einträgen wäre es doch, auch mit
einer Schleife, langsamer. Da könnte man doch schön die Schnelligkeit von ASM
ausnutzen.

Volkmar · 26. März 2017, 11:03

Könnte zum Beispiel so aussehen

Quellcode

Declare Int A[20]
Declare Memory Bereich
Dim Bereich, 100
Long Bereich,0 = 1,2,3,4,5
CLS
ASM "Enum", 3
PUSH EBX
PUSH ECX
PUSH ESI
MOV ESI,PAR1 // Zieladresse
MOV ECX,PAR2 // Größe
MOV EBX,PAR3 // Startwert
@schleife:
MOV [ESI],EBX // Wert in Speicher
ADD ESI, 4 // Nächste Adresse
INC EBX // Nächster Wert
DEC ECX // Wertzähler
JNZ @schleife // Wertzahl > 0 bleibt in Schleife
// gepuschte Register in umgekehrter Reihenfolge wird holen
POP ESI
POP ECX
POP EBX
ENDASM
Enum(Addr(A[0]), 20, 1)
Enum(Bereich, 20, 1)
WhileLoop 0,19
Print "Array : "; A[&LOOP], "Bereich : "; Long(Bereich, &LOOP * 4)
EndWhile
Print
WaitKey
Dispose Bereich
End

Alles anzeigen

Gruß Volkmar

Volkmar · 26. März 2017, 11:51

Geht natürlich auch mit "echter" Schleife, das ist dann noch eine Zeile kürzer

Quellcode

Declare Int A[20]
Declare Memory Bereich
Dim Bereich, 100
Long Bereich,0 = 1,2,3,4,5
CLS
ASM "Enum", 3
PUSH EBX
PUSH ECX
PUSH ESI
MOV ESI,PAR1 // Zieladresse
MOV ECX,PAR2 // Größe
MOV EBX,PAR3 // Startwert
@schleife:
MOV [ESI],EBX // Wert in Speicher
ADD ESI, 4 // Nächste Adresse
INC EBX
LOOPNZ @schleife
// gepuschte Register in umgekehrter Reihenfolge wird holen
POP ESI
POP ECX
POP EBX
ENDASM
Enum(Addr(A[0]), 20, 1)
Enum(Bereich, 20, 1)
WhileLoop 0,19
Print "Array : "; A[&LOOP], "Bereich : "; Long(Bereich, &LOOP * 4)
EndWhile
Print
WaitKey
Dispose Bereich
End

Alles anzeigen

Gruß Volkmar

H.Brill · 26. März 2017, 12:00

Klappt fast so, wie ich es mir wünsche.
Bloß mit dem 3. Parameter wollte ich es anders :
Bei
Enum(Addr[0], 20, 10)
sollte nicht bei 10 angefangen werden
-> A[0] = 10, A[1] = 11 usw.
Es sollten eigentlich 10er Schritte werden.
also A[0] = 10, A[1] = 20, A[2] = 30

Also ist EBX kein Startwert, sondern ein STEP.
Also müßte ich irgendwo noch mit EBX multiplizieren.

Ansonsten super gemacht, auch mit den Kommentaren dahinter.
Dann lernt man das auch schneller.

Volkmar · 26. März 2017, 12:06

Dann habe ich falsch gedacht. Geht aber auch mit einer einfachen Addidition

Quellcode

Declare Int A[20]
Declare Memory Bereich
Dim Bereich, 100
Long Bereich,0 = 1,2,3,4,5
CLS
ASM "Enum", 3
PUSH EAX
PUSH EBX
PUSH ECX
PUSH ESI
MOV ESI,PAR1 // Zieladresse
MOV ECX,PAR2 // Größe
MOV EBX,PAR3 // Schritt
MOV EAX, 1 // Startwert immer 1
@schleife:
MOV [ESI],EAX // Wert in Speicher
ADD ESI, 4 // Nächste Adresse
ADD EAX, EBX
LOOPNZ @schleife
// gepuschte Register in umgekehrter Reihenfolge wird holen
POP ESI
POP ECX
POP EBX
POP EAX
ENDASM
Enum(Addr(A[0]), 20, 7)
Enum(Bereich, 20, 7)
WhileLoop 0,19
Print "Array : "; A[&LOOP], "Bereich : "; Long(Bereich, &LOOP * 4)
EndWhile
Print
WaitKey
Dispose Bereich
End

Alles anzeigen

Gruß Volkmar

H.Brill · 26. März 2017, 13:02

Noch nicht ganz.
Hier haste bei A[0] = 1 und bei A[1] = 11
und nicht, wie gewollt bei A[0] = 10 und A[1] = 20

Das ganze soll ja so funktionieren, daß beim 3.Parameter
bei Enum(A[0], 20, 1) ganz normal aufnummeriert wird
und halt eben bei > 1 * Para3

So sieht es mit XProfan aus :

Quellcode

Declare Int A[20], B[20]
Enum(A[], 20, 1)
Enum(B[], 20, 10)
WhileLoop 0, 19
Print "Array 1 : "; A[&LOOP], " Array 2 : "; B[&Loop]
EndWhile
Waitkey
Proc Enum
Parameters Int Z[], Anzahl, Step
WhileLoop 1, Anzahl
Z[&LOOP - 1] = &LOOP * Step
EndWhile
EndProc
End

Alles anzeigen

Volkmar · 26. März 2017, 13:09

OK, dann eben Zeile 15 in meinem letzten Code ändern:
MOV EAX, EBX

Gruß Volkmar

H.Brill · 26. März 2017, 13:39

Danke, jetzt ist es richtig.

PS:

Habs jetzt mal mit einem Array mit 500000 Elementen probiert.
Geht blitzschnell. Bei meinem XProfan-Proc dauert das ellenlang.

Das sind solche Sachen und darum war die ASM-Funktion eine
sehr gute Idee.

H.Brill · 26. März 2017, 15:16

Für alle, die noch gerne mit den älteren Versionen bzw.
Interpreter arbeiten :
Dank Rolands .lst - Datei, die bei der ASM-Funktion anfällt,
kann man sehr schön auch für ältere Profanversionen den
Bytecode-String in einen Bereich schreiben.

Quellcode

Declare Int A[20], Memory Bereich
Dim Bereich, 100
Cls
EnumArray(A[], 20, 10)
EnumBereich(Bereich, 20, 1)
WhileLoop 0, 19
Print "Array : "; A[&LOOP], " Bereich : "; Long(Bereich, &LOOP * 4)
EndWhile
Waitkey
Proc EnumArray
Parameters Int Z[], Anzahl, Step
Declare Memory ASMBereich, Int anz, String b
b = "55,89,E5,50,53,51,56,8B,75,08,8B,4D,0C,8B,5D,10,89,D8,89,06,81,C6,04,00,00,00,\
01,D8,E0,F4,5E,59,5B,58,89,EC,5D,C2,0C,00,"
anz = Len(b, ",")
Dim ASMBereich, anz
Byte ASMBereich, 0 = $55,$89,$E5,$50,$53,$51,$56,$8B,$75,$08,$8B,$4D,$0C,$8B,$5D,$10,$89,$D8,$89,$06,$81,$C6,$04,$00,$00,$00,\
$01,$D8,$E0,$F4,$5E,$59,$5B,$58,$89,$EC,$5D,$C2,$0C,$00
CALL(ASMBereich, Addr(Z[0]), Anzahl, Step)
Dispose ASMBereich
EndProc
Proc EnumBereich
Parameters Memory Z, Anzahl, Step
Declare Memory ASMBereich, Int anz, String b
b = "55,89,E5,50,53,51,56,8B,75,08,8B,4D,0C,8B,5D,10,89,D8,89,06,81,C6,04,00,00,00,\
01,D8,E0,F4,5E,59,5B,58,89,EC,5D,C2,0C,00,"
anz = Len(b, ",")
Dim ASMBereich, anz
Byte ASMBereich, 0 = $55,$89,$E5,$50,$53,$51,$56,$8B,$75,$08,$8B,$4D,$0C,$8B,$5D,$10,$89,$D8,$89,$06,$81,$C6,$04,$00,$00,$00,\
$01,$D8,$E0,$F4,$5E,$59,$5B,$58,$89,$EC,$5D,$C2,$0C,$00
CALL(ASMBereich, Z, Anzahl, Step)
Dispose ASMBereich
EndProc
Dispose Bereich
End

Alles anzeigen

So haben dann alle was davon.
Da war zwar etwas Handarbeit angesagt, aber so groß werden die Asmlistings ja auch nicht.
Verbesserungen an obigem Code sind erwünscht. Vielleicht sollte man auch ein Tool dazu
schreiben, das die Handarbeit erledigt.

Volkmar · 26. März 2017, 16:25

So in etwa? Der Code wird in die Zwischenablage gestellt und kann dann in den Quelltext reinkopiert werden. Das Dispose von ASMBereich muß dann selbst an passender Stelle eingefügt werden, wenn die Funktion nicht mehr gebraucht wird. Dateiname und Pfad zur LST-Datei in der ersten Zeile entsprechend anpassen (oder Dateidialog einbauen ;-)

) Wenn mehrere ASM-Codes im gleichen Programm verwendet werden, dann noch die Namen der Bereiche nach dem Einfügen manuell ändern!

Quellcode

Var String Eingabe = "C:\\XProfanX4alpha\\Enum.LST"
Declare String Zeile
Declare Int Anzahl, Teil, TeilPos
Declare String Ausgabe
CLS
Assign #1, Eingabe
Reset #1
Case %IOResult : Fehler "Öffnen"
WhileNot EOF(#1)
Input #1, Zeile
Case %IOResult : "Lesen"
EndWhile
Close #1
Teil = Len(Zeile)
TeilPos = 0
While TeilPos < Teil
Ausgabe = Ausgabe + Mid$(Zeile, TeilPos + 1, 2) + ","
Inc TeilPos, 2
Inc Anzahl
If Anzahl = 16
Ausgabe = Ausgabe + "\\\n"
Anzahl = 0
EndIf
EndWhile
Ausgabe = Del$(Ausgabe, Len(Ausgabe), 1)
Ausgabe = "Declare Mem ASMBereich\nDIM ASMBereich, " + Str$(Teil \ 2) + "\nByte ASMBereich, 0 = " + Ausgabe
ClearClip
PutClip Ausgabe
Print Ausgabe
Print
Print "wurde in die Zwischenablage kopiert"
WaitInput
End
Proc Fehler
Parameters String Meldung
Meldung = "Fehler beim " + Meldung + " von " + Eingabe + "\nProgramm wird abgebrochen"
MessageBox(Meldung, "Fehler", 16)
End
EndProc

Alles anzeigen

Das Ergebnis sollte dann so aussehen

Quelltext schrieb:

Declare Mem ASMBereich
DIM ASMBereich, 40
Byte ASMBereich, 0 = 55,89,E5,50,53,51,56,8B,75,08,8B,4D,0C,8B,5D,10,\
89,D8,89,06,81,C6,04,00,00,00,01,D8,E0,F4,5E,59,\
5B,58,89,EC,5D,C2,0C,00

Code nicht verwenden, da fehlen die $ vor den Hex-Werten. Korrigierte Fassung in #16

. Dank für den Hinweis an H.Brill.

Gruß Volkmar

H.Brill · 26. März 2017, 17:47

Man muß nur aufpassen :
z.B. das E5 oder 8B ging bei mir als Bytezuweisung nicht.
Deshalb hatte ich bei jedem Byte ein $ davor gesetzt.

Was noch besser wäre :
Da Roland ja sowieso den Bytecodestring in der .lst
zusammensetzt, wäre es ja für ihn kein Problem bzw.
keine größere Arbeit, gleich ein $ vor jedes Byte und ein
Komma hinter jedes Byte zu setzen. Mit einem Set-Befehl
oder Compilerschalter könnte man evtl. auch bestimmen,
wie man es mag : Klassisch, wie bisher oder spezifisch, wie
oben geschrieben.
Wenn er dann noch die Anzahl der Bytes in .lst schreibt,
kann man den Bereich auch gleich darauf dim'en, ohne
mit Len() zu zählen.

Ist ja nur gedacht, frühere Profanversionen zu bedienen
bzw. Könnte man sich auch Resourcen von Bytefolgen anlegen,
die bei Start des Interpreters / Programms geladen werden.
Ich denke, sowas wäre mit einer STRINGTABLE und RCDATA
leicht machbar.

Volkmar · 26. März 2017, 17:54

Hast Du natürlich Recht, da habe ich wieder mal gepennt. Das $ muß schon vor jedem Wert stehen, sind ja grundsätzlich HEX-Werte.

Quellcode

Var String Eingabe = "C:\\XProfanX4alpha\\Enum.LST"
Declare String Zeile
Declare Int Anzahl, Teil, TeilPos
Declare String Ausgabe
CLS
Assign #1, Eingabe
Reset #1
Case %IOResult : Fehler "Öffnen"
WhileNot EOF(#1)
Input #1, Zeile
Case %IOResult : "Lesen"
EndWhile
Close #1
Teil = Len(Zeile)
TeilPos = 0
While TeilPos < Teil
Ausgabe = Ausgabe + "$" + Mid$(Zeile, TeilPos + 1, 2) + ","
Inc TeilPos, 2
Inc Anzahl
If Anzahl = 16
Ausgabe = Ausgabe + "\\\n"
Anzahl = 0
EndIf
EndWhile
Ausgabe = Del$(Ausgabe, Len(Ausgabe), 1)
Ausgabe = "Declare Mem ASMBereich\nDIM ASMBereich, " + Str$(Teil \ 2) + "\nByte ASMBereich, 0 = " + Ausgabe
ClearClip
PutClip Ausgabe
Print Ausgabe
Print
Print "wurde in die Zwischenablage kopiert"
WaitInput
End
Proc Fehler
Parameters String Meldung
Meldung = "Fehler beim " + Meldung + " von " + Eingabe + "\nProgramm wird abgebrochen"
MessageBox(Meldung, "Fehler", 16)
End
EndProc

Alles anzeigen

Gruß Volkmar

H.Brill · 26. März 2017, 18:43

Warten wir mal ab, was an ASM-Codes zusammenkommt.

Als Zwischenlösung, wenn man halt eine .exe haben will
oder eben für frühere Versionen ist es interessant.

Ansonsten kann man mit deiner Lösung im Augenblick
auch gut leben.

Also ran an die Vollspeed-Lösungen für XPROFAN !!!!!!!! :top:

PS:
Eine ASM-Routine als Ersatz für Translate$ steht bei mir
als nächstes auf dem Plan. Die ist nämlich bei großen
Datenmengen auch recht langsam.
Aber da warte ich noch was, in der Hoffnung, daß Roland
noch ein paar ASM-Stringroutinen (MOVXX o.ä.)
implementiert.

Volkmar · 26. März 2017, 19:23

Ich denke auch, da müssen wir kein großes Projekt draus machen. Wers öfter für ältere Versionen nutzen will, kann sich noch einen Dateidialog einbauen. Ansonsten kommt da ja was Ordenliches im X4 :top:

Gruß Volkmar

RGH · 27. März 2017, 20:57

Als etwas größeres Beispiel mit Strings: die abgwandelte MsgBox:

Quellcode

$H windows.ph ' WindowsHeaderdatei nutzen
CLS
Declare handle hDLL, String Text
hDLL = UseDLL("USER32.DLL") ' Handle von USER32 ermitteln
ImportFunc(hDLL, "MessageBoxA", "")
ASM "MsgBox", 1 ' Ein Parameter Adresse + 4 Parameter für die Messagebox
JMP Start
Typ:
DD 51
Titel:
DS "Titel Total!\z"
Text:
DS "Das ist auch ein Hinweis!\z"
Start:
// Parameter einlesen
MOV EAX, [Typ]
PUSH EAX
MOV EAX, Titel
PUSH EAX
MOV EAX, Text
PUSH EAX
MOV EAX, Par1
PUSH EAX
// Funktion aufrufen
FCALL MessageBoxA
ENDASM
Print MsgBox(%hWnd)
waitinput

Alles anzeigen

Man beachte:
Bei Typ steht der Wert an der durch das Label "Typ:" angegebenen Adresse. Die Funktion erwartet den direkten Wert, deshalb wird hier der Wert, der an dieser Adresse steht nach EAX geholt: Das Label steht in eckigen Klammern.
Bei den Texten, steht der Text jeweils an der durch das Label angegebenen Adresse. Da die Funktion hier die Adressen der Strings erwartet, werden diese direkt nach EAX kopiert, also steht das Label hier ohne eckige Klammern.

Ach ja: Die Strings sollten natürlich mit einem Null-Byte ("\z") aufhören, sonst wird es seltsam. Und für den Typ wird ein DD-Speicherplatz (4 Byte = 32 Bit) benötigt, da MOVE EAX, [Label] einen 32-Bit-Wert von der angegebenen Adresse holt. (Bei z.B. MOV AL,[Label] hätte auch DB für ein Byte genügt.)

Gruß
Roland