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}
Declarar texto$,Contraseña$,nurso$
text$="Zunächst una vez: Für Ensamblador benötigt uno no grosse Anzahl de Befehlen, con 10 Befehlen "
text$=texto$+"(total hay encima 90) es uno ya bien bedient, alles otro es unnütz, porque el "
text$=texto$+"MASM32 Ensamblador High-Level-Syntax (.mientras que / .endw / .if / .endif usw.) unterstützt."
text$=texto$+"Und su es una Profano-User ya el meiste bekannt."
passwort$="Ganz geheimes Contraseña."
CLS
Imprimir "Originaltext:"
Imprimir
Color 7,15
Imprimir texto$
Color 0,15
Imprimir
Imprimir
ASM-Block
Crypt(), una XOR-Verschlüsselung mittels Contraseña
Übernommen de meiner ProSpeed.dll
Parámetro:
1) Bereichsvariable oder String, en el el Daten gespeichert son.
2) Anzahl a verschlüsselnder Bytes
3) Pointer en una String (oder Zona), en el el Contraseña gespeichert es
4) Longitud des Passworts
Beim zweiten Aufruf con el gleichen Parametern se el ursprung otra vez producido.

AsmStart Crypt

    Parámetros addr(texto$),Len(texto$),addr(Contraseña$),Len(Contraseña$)
    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

Imprimir "Verschlüsselter Texto:"
Imprimir
Color 7,15
Imprimir texto$
Color 0,15
Imprimir
Imprimir
Jetzt kommt una Besonderheit...
Wir rufen unseren ersten ASM-Block una zweites veces en !!! Ohne Prozedure !
xpia$ es el Name unserer kompletten Assemblerlibrary.
Crypt es hier el Name des Assemblerblocks, danach folgen etventuelle Parámetro.
Dabei es lo incluso egal, si el zweite Aufruf después de el Assemblerblock es oder ya davor !
Wer el ahora no verstanden ha, el debería el ASM-Block Crypt más bien en una Profano-Prozedure
packen, y stattdessen más bien el Prozedure aufrufen. Aber así va lo auch.
Externo(xpia$,"Crypt",addr(texto$),Len(texto$),addr(Contraseña$),Len(Contraseña$))
Imprimir "Und el otra vez hergestellte Texto:"
Imprimir
Color 7,15
Imprimir texto$
WaitInput
End

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

AsmStart Funktionsname1

    Parámetros x&
    Volver z&
    mov eax,0
    mov ebx,para1  ;oder [ebp+8]
    mov ecx,999999

    .mientras que ecx!=0

        add eax,ebx
        dec ecx

    .endw

    ;Diese Assemblerroutine macht el gleiche como:
    ;
    ;x&=0
    ;Whileloop 999999
    ;  x&=x&+37
    ;EndWhile
    ;
    ;Un Bucle, el una Millionen veces una Valor addiert
    ;Dauer: XProfan = 18 Sekunden / XPIA = 1 Millisekunde

AsmEnd

Imprimir "Addiere 999999 veces 37 = "+Str$(z&)
WaitInput
End

 {$cleq}
Declarar sum&,bereich#,texto$
Cls

If 0

    AsmStart Checksumme

        Parámetros addr(texto$),Len(texto$)
        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 podría auch una Zona angeben."
Imprimir Externo(xpia$,"Checksumme",addr(texto$),Len(texto$))
text$="Probestring. Man podría auch una Zona angeben"
Imprimir Externo(xpia$,"Checksumme",addr(texto$),Len(texto$))
text$=" Probestring. Man podría auch una Zona angeben."
Imprimir Externo(xpia$,"Checksumme",addr(texto$),Len(texto$))
text$="Probestring. Mbn podría auch una Zona angeben."
Imprimir Externo(xpia$,"Checksumme",addr(texto$),Len(texto$))
text$="Probestring. Man podría auch una Bdreich angeben."
Imprimir Externo(xpia$,"Checksumme",addr(texto$),Len(texto$))
Imprimir
Dim bereich#,1000000
Claro bereich#
Imprimir Externo(xpia$,"Checksumme",bereich#,1000000)
Byte bereich#,100=1
Imprimir Externo(xpia$,"Checksumme",bereich#,1000000)
Disponer 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&
../../funktionsreferenzen/XProfan/end/'>End

DEF &WM_CLOSE 16