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
Fin

 {$cleq}
Déclarer text$,passwort$,nurso$
text$="Zunächst einmal: Pour Assembler nécessaire on aucun grosse Anzahl de Befehlen, avec 10 Befehlen "
text$=text$+"(en tout gibt es sur 90) ist on déjà bien bedient, alles autre ist unnütz, weil qui "
text$=text$+"MASM32 Assembler High-Level-Syntax (.tandis que / .endw / .si / .endif usw.) soutenu."
text$=text$+"Und en ist einem Profan-User déjà cela meiste bekannt."
passwort$="Ganz geheimes Mot de passe."
CLS
Imprimer "Originaltext:"
Imprimer
Color 7,15
Imprimer text$
Color 0,15
Imprimer
Imprimer
ASM-Block
Crypt(), une XOR-Verschlüsselung mittels Mot de passe
Übernommen aus meiner ProSpeed.dll
paramètre:
1) Bereichsvariable ou bien String, dans qui qui données gespeichert sommes.
2) Anzahl trop verschlüsselnder Bytes
3) Pointer sur une String (ou bien Bereich), dans dem cela Mot de passe gespeichert ist
4) Longueur des Passworts
Beim zweiten Aufruf avec den gleichen Parametern wird qui ursprung wieder hergestellt.

AsmStart Crypt

    Paramètres 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

Imprimer "Verschlüsselter Text:"
Imprimer
Color 7,15
Imprimer text$
Color 0,15
Imprimer
Imprimer
maintenant venez une Besonderheit...
Wir appeler unseren ersten ASM-Block un zweites la fois sur !!! sans Prozedure !
xpia$ ist qui nom unserer kompletten Assemblerlibrary.
Crypt ist ici qui nom des Assemblerblocks, après folgen etventuelle paramètre.
Dabei ist es sogar égal, si qui zweite Aufruf pour dem Assemblerblock erfolgt ou bien déjà devant !
qui cela maintenant pas verstanden hat, qui sollte den ASM-Block Crypt lieber dans une Profan-Prozedure
saisir, et stattdessen lieber qui Prozedure appel. mais so allez es aussi.
Externe(xpia$,"Crypt",addr(text$),Len(text$),addr(passwort$),Len(passwort$))
Imprimer "Und qui wieder hergestellte Text:"
Imprimer
Color 7,15
Imprimer text$
WaitInput
Fin

 {$cleq}
Déclarer x&,y&,z&
Cls
x&=37

AsmStart Funktionsname1

    Paramètres x&
    Retour z&
    mov eax,0
    mov ebx,para1  ;ou bien [ebp+8]
    mov ecx,999999

    .tandis que ecx!=0

        add eax,ebx
        dec ecx

    .endw

    ;cet Assemblerroutine pouvoir cela gleiche comment:
    ;
    ;x&=0
    ;Whileloop 999999
    ;  x&=x&+37
    ;Endwhile
    ;
    ;une Boucle, qui une Millionen la fois une Wert addiert
    ;la durée: XProfan = 18 Sekunden / XPIA = 1 Millisekunde

AsmEnd

Imprimer "Addiere 999999 la fois 37 = "+Str$(z&)
WaitInput
Fin

 {$cleq}
Déclarer sum&,bereich#,text$
Cls

Si 0

    AsmStart Checksumme

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

        .si 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. on pourrait aussi une Bereich angeben."
Imprimer Externe(xpia$,"Checksumme",addr(text$),Len(text$))
text$="Probestring. on pourrait aussi une Bereich angeben"
Imprimer Externe(xpia$,"Checksumme",addr(text$),Len(text$))
text$=" Probestring. on pourrait aussi une Bereich angeben."
Imprimer Externe(xpia$,"Checksumme",addr(text$),Len(text$))
text$="Probestring. Mbn pourrait aussi une Bereich angeben."
Imprimer Externe(xpia$,"Checksumme",addr(text$),Len(text$))
text$="Probestring. on pourrait aussi une Bdreich angeben."
Imprimer Externe(xpia$,"Checksumme",addr(text$),Len(text$))
Imprimer
Faible bereich#,1000000
Claire bereich#
Imprimer Externe(xpia$,"Checksumme",bereich#,1000000)
Byte bereich#,100=1
Imprimer Externe(xpia$,"Checksumme",bereich#,1000000)
Dispose bereich#
WaitInput
Fin

 {$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/'>Fin

DEF &WM_CLOSE 16