XPSE

print "Hallo" ^
waitinpute>

 {$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$,Password$,nurso$
text$="Zunächst once: for Assembler needed one no grosse amount of command, with 10 command "
text$=text $+"(altogether there over 90) is one that's all right bedient, everything else is unnütz, because the "
text$=text $+"MASM32 Assembler High-Level-Syntax (.while / .endw / .if / .endif etc.) supported."
text$=text $+"Und of it is one Profan-User already the meiste famous."
passwort$="Ganz geheimes Password."
CLS
Print "Originaltext:"
Print
Color 7,15
Print Text$
Color 0,15
Print
Print
ASM-block
Crypt(), a XOR-Verschlüsselung through Password
Übernommen from of my ProSpeed.dll
Parameter:
1) Memory-Variable or String, in the The data stored are.
2) amount To verschlüsselnder Bytes
3) Pointer on a String (or area), in the the Password stored is
4) length the Passworts
at that second appeal with whom equal Parameters becomes the origin again manufactured.

AsmStart Crypt

    Parameters addr(text $),Len(text $),addr(Password$),Len(Password$)
    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   plunge
    mov   edi,0
    plunge:
    sub   ecx,1
    jne   schleife

AsmEnd

Print "Verschlüsselter Text:"
Print
Color 7,15
Print Text$
Color 0,15
Print
Print
now comes a Besonderheit...
we call our first ASM-block one second time on !!! without Prozedure !
xpia$ is the name ours kompletten Assemblerlibrary.
Crypt is here the name the Assemblerblocks, thereafter follow etventuelle Parameters.
thereby is it even alike, whether the second appeal to the Assemblerblock results or already before it !
who the now not understood has, the ought to whom ASM-block Crypt rather in a Profan-Prozedure
pack, and instead rather The Prozedure . Call but so goes it too.
External(xpia$,"Crypt",addr(text $),Len(text $),addr(Password$),Len(Password$))
Print "Und the again manufactured 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  ;or [ebp+8]
    mov ecx,999999

    .while ecx!=0

        add eax,ebx
        dec ecx

    .endw

    ;These Assemblerroutine power the same How:
    ;
    ;x&=0
    ;Whileloop 999999
    ;  x&=x&+37
    ;EndWhile
    ;
    ;an Loop, The a millions time a worth add
    ;duration: XProfan = 18 sec / XPIA = 1 Millisekunde

AsmEnd

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

 {$cleq}
Declare sum&,area#,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. one could too a area indicate."
Print External(xpia$,"Checksumme",addr(text $),Len(text $))
text$="Probestring. one could too a area angeben"
Print External(xpia$,"Checksumme",addr(text $),Len(text $))
text$=" Probestring. one could too a area indicate."
Print External(xpia$,"Checksumme",addr(text $),Len(text $))
text$="Probestring. Mbn could too a area indicate."
Print External(xpia$,"Checksumme",addr(text $),Len(text $))
text$="Probestring. one could too a Bdreich indicate."
Print External(xpia$,"Checksumme",addr(text $),Len(text $))
Print
Dim area#,1000000
Clear area#
Print External(xpia$,"Checksumme",area#,1000000)
byte area#,100=1
Print External(xpia$,"Checksumme",area#,1000000)
Dispose area#
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&
../../Function-References/XProfan/end/'>End

DEF &WM_CLOSE 16