XPSE

print "Hallo" ^
waitinput

 {$batch copy "xx x.exe" "c:xx x.exe"}

 $I debugprint.inc

In diesem Democode befinden sich zwei Assemblerblöcke.
Eine versteckt sich in einer Profan-Prozedure und lädt eine Datei via API. Das ginge auch mittels Profan,
aber das hier ist ja ein Democode.
Der andere Assemblerblock zählt nach, wie oft die einzelnen Buchstaben (A-Z, bzw. a-z) in einer
Textdatei vorkommen.
 {$cleq}
Declare x&,y&,z&,text$,text#,tabelle#,bytes&
Prozedure mit Assemblerblock.
ReadFile dateiname$, Speicher wohin die Datei geladen werden soll, Offset im Speicher, Grösse der Datei

Proc ReadFile

    Parameters a1$,a2&,a3&,a4&
    ASM Block

    AsmStart ReadFileFast

        Parameters addr(a1$),a2&,a3&,a4&
        Return a3&
        jmp @F              ;Datenblock überspringen. @F/@@: ist eine Sondervariable genau für diesen Zweck. Kann in
        ;einem Block auch mehrmals verwendet werden.
        readed    dd  0
        handle    dd  0
        @@:
        invoke CreateFile,para1,GENERIC_READ,0,0,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,0
        mov   handle,eax

        .if eax>0

            mov   eax,para2
            add   eax,para3
            invoke ReadFile,handle,eax,para4,addr readed,0
            invoke CloseHandle,handle
            mov   eax,readed

        .endif

    AsmEnd

    ASM Block Ende
    Return a3&

EndProc

Window 0,0-%maxx,%maxy
CLS
text$=@LoadFile$("Lade eine Textdatei","*.TXT")
x&=@FileSize(text$)

If x&>0

    Print text$
    Print Str$(x&)+" Bytes geladen."
    Print
    Print "Anzahl Buchstaben, die im Text gefunden wurden:"
    Dim text#,x&+1
    ReadFile text$,text#,0,x&
    x&=@&(0)
    bytes&=x&

    If x&

        Dim tabelle#,108  26 x 4 + 4
        Clear tabelle#
        ASM Block

        AsmStart Count

            Parameters text#,tabelle#,x&
            invoke CharUpperBuff,para1,para3
            mov ecx,para3
            mov ebx,para1
            mov edx,para2

            .repeat

                mov eax,0
                mov al,[ebx]
                inc ebx                         ;ebx um 1 erhöhen

                .if (al>=65) && (al<=90)

                    sub eax,65
                    shl eax,2                     ;logisches Verschieben der Bits nach links. Bewirkt: eax * 4. Schneller als "mul"
                    add eax,edx
                    mov edi,1
                    add [eax],edi

                .endif

                dec ecx

            .until ecx==0

        AsmEnd

        ASM Block Ende
        Decimals 2
        y&=0

        Whileloop 26

            x&=Long(tabelle#,y&*4)
            Print Chr$(y&+97)+" oder "+Chr$(y&+65)+" = "+Str$(x&)+" x."
            y&=y&+1

        EndWhile

        Dispose tabelle#

    EndIf

    Dispose text#

EndIf

WaitInput
End

 {$cleq}
Declare text$,passwort$,nurso$
text$="Zunächst einmal: Für Assembler benötigt man keine grosse Anzahl von Befehlen, mit 10 Befehlen "
text$=text$+"(insgesamt gibt es über 90) ist man schon gut bedient, alles andere ist unnütz, weil der "
text$=text$+"MASM32 Assembler High-Level-Syntax (.while / .endw / .if / .endif usw.) unterstützt."
text$=text$+"Und davon ist einem Profan-User schon das meiste bekannt."
passwort$="Ganz geheimes Passwort."
CLS
Print "Originaltext:"
Print
Color 7,15
Print text$
Color 0,15
Print
Print
ASM-Block
Crypt(), eine XOR-Verschlüsselung mittels Passwort
Übernommen aus meiner ProSpeed.dll
Parameter:
1) Bereichsvariable oder String, in der die Daten gespeichert sind.
2) Anzahl zu verschlüsselnder Bytes
3) Pointer auf einen String (oder Bereich), in dem das Passwort gespeichert ist
4) Länge des Passworts
Beim zweiten Aufruf mit den gleichen Parametern wird der ursprung wieder hergestellt.

AsmStart Crypt

    Parameters addr(text$),Len(text$),addr(passwort$),Len(passwort$)
    mov   ecx,para2
    mov   edx,para1
    mov   ebx,para3
    mov   esi,para4
    mov   edi,0
    schleife:
    mov   al,[edx]
    xor   al,[ebx+edi]
    mov   [edx],al
    inc   edx
    inc   edi
    cmp   esi,edi
    jne   sprung
    mov   edi,0
    sprung:
    sub   ecx,1
    jne   schleife

AsmEnd

Print "Verschlüsselter Text:"
Print
Color 7,15
Print text$
Color 0,15
Print
Print
Jetzt kommt eine Besonderheit...
Wir rufen unseren ersten ASM-Block ein zweites mal auf !!! Ohne Prozedure !
xpia$ ist der Name unserer kompletten Assemblerlibrary.
Crypt ist hier der Name des Assemblerblocks, danach folgen etventuelle Parameter.
Dabei ist es sogar egal, ob der zweite Aufruf nach dem Assemblerblock erfolgt oder schon davor !
Wer das jetzt nicht verstanden hat, der sollte den ASM-Block Crypt lieber in eine Profan-Prozedure
packen, und stattdessen lieber die Prozedure aufrufen. Aber so geht es auch.
External(xpia$,"Crypt",addr(text$),Len(text$),addr(passwort$),Len(passwort$))
Print "Und der wieder hergestellte Text:"
Print
Color 7,15
Print text$
WaitInput
End

 {$cleq}
Declare x&,y&,z&
Cls
x&=37

AsmStart Funktionsname1

    Parameters x&
    Return z&
    mov eax,0
    mov ebx,para1  ;oder [ebp+8]
    mov ecx,999999

    .while ecx!=0

        add eax,ebx
        dec ecx

    .endw

    ;Diese Assemblerroutine macht das gleiche wie:
    ;
    ;x&=0
    ;Whileloop 999999
    ;  x&=x&+37
    ;EndWhile
    ;
    ;Eine Schleife, die eine Millionen mal einen Wert addiert
    ;Dauer: XProfan = 18 Sekunden / XPIA = 1 Millisekunde

AsmEnd

Print "Addiere 999999 mal 37 = "+Str$(z&)
WaitInput
End

 {$cleq}
Declare sum&,bereich#,text$
Cls

If 0

    AsmStart Checksumme

        Parameters addr(text$),Len(text$)
        mov ebx,para1
        mov esi,para2
        xor ecx,ecx
        xor edx,edx
        xor eax,eax

        .if esi>=0

            schleife:
            mov al,[ebx]
            add edx,eax
            add edx,ecx
            rol edx,8
            inc ecx
            inc ebx
            cmp ecx,esi
            jne schleife

        .endif

        mov eax,edx

    AsmEnd

EndIf

text$="Probestring. Man könnte auch einen Bereich angeben."
Print External(xpia$,"Checksumme",addr(text$),Len(text$))
text$="Probestring. Man könnte auch einen Bereich angeben"
Print External(xpia$,"Checksumme",addr(text$),Len(text$))
text$=" Probestring. Man könnte auch einen Bereich angeben."
Print External(xpia$,"Checksumme",addr(text$),Len(text$))
text$="Probestring. Mbn könnte auch einen Bereich angeben."
Print External(xpia$,"Checksumme",addr(text$),Len(text$))
text$="Probestring. Man könnte auch einen Bdreich angeben."
Print External(xpia$,"Checksumme",addr(text$),Len(text$))
Print
Dim bereich#,1000000
Clear bereich#
Print External(xpia$,"Checksumme",bereich#,1000000)
Byte bereich#,100=1
Print External(xpia$,"Checksumme",bereich#,1000000)
Dispose bereich#
WaitInput
End

 {$cleq}
Declare dh&,text$,x&,y&,z&
 {$replace 1:"_Schleifen_enh"}
Def Schleife(1) !^1^,"Schleife"
dh&=usedll(xpia$)
CLS
Print xpia$
ASM-Block

If 0

    AsmStart Schleife

        Parameters x&
        mov ecx,para1   ;Unser Parameter, also 100 Millionen
        schleife:
        dec ecx         ;ecx=ecx-1
        jnz schleife    ;verzweige, wenn das zuletzt benutze Register (also ECX) nicht 0 ist
        mov eax,ebx

    AsmEnd

Endif

Warten, bis alle Laufwerke aus sind.
Noch aktive Laufwerke verfälschen den Geschwindigkeitstest.
Print
Print "3 Sekunden warten, bis alle Laufwerksaktivitäten versiegt sind."
Print
Sleep 3000
Assemblerschleife, 100 Millionen mal durchlaufen:
Wir benutzen unser generierte Dll im geladenen Zustand, weil allein
Profans Aufruf von "External" 16 Millisekunden für jede Ausführung benötigt...
x&=100000000
Print "Assemblerschleife wird jetzt "+Str$(x&)+" mal durchlaufen."
y&=&GetTickCount
Schleife(x&)
y&=&GetTickCount-y&
Print "Fertig in "+Str$(y&)+" Millisekunden."
Print
Profanschleife, 100 Millionen mal durchlaufen:
x&=100000000
Print "Profanschleife wird jetzt "+Str$(x&)+" mal durchlaufen."
y&=&GetTickCount

Whileloop x&

EndWhile

y&=&GetTickCount-y&
Print "Fertig in "+Str$(y&)+" Millisekunden."
WaitInput
freedll dh&
End

DEF &WM_CLOSE 16