XProfan

Italia

funkheld

Hallo, guten Tag, ich habe ein Problem.
Warum kommt unten das Ergenis 6 raus?
Wenn ich die Whilelloop rausnehme kommt richtig 9 raus.

Danke.
Gruss

Kompilieren Markieren Separieren

 {$CLEQ}
Cls
Print addi(4,5)
WaitInput
End

nproc Addi(long x,y){

    long z
    mov ebx,y
    mov eax,x
    add eax,y

    whileloop 5

        add eax,ebx

    endwhile

    mov z,eax
    Return z

}

XProfan 11

18.04.2012 ▲

Vollständiges Zitat

Absatzweise Citazione Zeilenweise Citazione

Du musst davon ausgehen, dass Windows-APIs wie auch XPSE-Funktionen
wie auch Kontrollstrukturen die ASM-Registerwerte ändern weil sie mit ihnen arbeiten.

Möchte man mit diesen Werten arbeiten dann sollte man sie z.B. mit push und pop
sichern/ wiederherstellen. Bei manchen APIs ist dies sogar explizit notwenwie z.B.
bei LineDDA oder manch anderen ENUM-Procs.

Würdest Deine Schleife also nach cmp bzw. test und jmp bzw. jle oder jl umstellen -
also ohne While, dann würden auch die Registerwerte nicht beeinflusst oder nutze
eben push und pop.

Übrigens... je nach dem was einem liegt...

Du kannst naturalmente:

Kompilieren Markieren Separieren

nproc Addi(long x,y){ ... }

schreiben aber genauso auch:

Kompilieren Markieren Separieren

nproc Addi

    parameters x&,y&
    ...

endproc

Das gilt per procs wie per nprocs.

XProfan X2
Vista (TM) Home Premium, SP2, Core(TM)2 Duo P8600 @ 2.40GHz

18.04.2012 ▲

Vollständiges Zitat

Absatzweise Citazione Zeilenweise Citazione

funkheld

Hmm.., mit push und pop ändert sich das Ergebnis nicht.

Gruss

Kompilieren Markieren Separieren

nproc Addi(long x,y){

    long z
    push eax
    push ebx
    push ecx
    push edx
    push edi
    push esi
    mov ebx,y
    mov eax,x
    add eax,y

    whileloop 5

        add eax,ebx

    wend

    mov z,eax
    pop esi
    pop edi
    pop edx
    pop ecx
    pop ebx
    pop eax
    Return z

}

XProfan 11

18.04.2012 ▲

Vollständiges Zitat

Absatzweise Citazione Zeilenweise Citazione

Das WhileLoop und Wend nutzt ebenso mindestens eax und ebx,

wenn dann müsstest dein add eax,ebx abkapseln aber Du kannst wiederum
auch nicht davon ausgehen dass das while den ebx Wert unverändert in die Schleife
durchlässt.

In diesem Fall eignet sich das Mischen mit ASM nicht. Das wiederum ist wohl bei allen
"ehrlichen" nativen Programmiersprachen der Fall und eben auch so bei Windows-APIs
um ein Di più an Geschwindigkeit zu erreichen bzw. um nicht unnötig Registerwerte zu sichern.

Du könntest aber Deine Schleife (also das while wend) auch komplett nach asm
umsetzen (wie oben geschrieben) mit cmp bzw. test(-asm)-Anweisungen.

Wenn Du schreibst was genau Du erreichen möchtest dann kann ich Dir den
ASM dazu auch aufschreiben.

XProfan X2
Vista (TM) Home Premium, SP2, Core(TM)2 Duo P8600 @ 2.40GHz

18.04.2012 ▲

Vollständiges Zitat

Absatzweise Citazione Zeilenweise Citazione

Noch ein kleiner TIP:

Kompilieren Markieren Separieren

mov z,eax
Return z

kannst Du komplett fallen lassen da der Rückgabewert
der in EAX abgelegte Wert ist. So auch bei Windows-APIs.

XProfan X2
Vista (TM) Home Premium, SP2, Core(TM)2 Duo P8600 @ 2.40GHz

18.04.2012 ▲

Vollständiges Zitat

Absatzweise Citazione Zeilenweise Citazione

funkheld

Jup, danke.
eax habe ich rausgelassen, jetzt funktioniert es.

Aber dieses funktioniert nicht mit der typischen MASM oder JWASM-SChleife:

Kompilieren Markieren Separieren

nproc Addi1(long y){

    long z
    mov eax,0

    .while ecx<=y

        inc ebx
        add eax,5

    .endw

    mov z,eax
    Return z

}

Der XPIA kennt diese typische Schleife wieder.

Gruss

18.04.2012 ▲

Vollständiges Zitat

Absatzweise Citazione Zeilenweise Citazione

funkheld

cmp bzw. test und jmp bzw. jle oder jl

Wenn du mal bitte eine ASM-Demo machen könntest per XPSE, welches eine if-Schleife, eine Whileloop-Schleife und eine While-Schleife darstellt, damit potuto ich dann viel mit anfangen.

Danke.

Gruss

18.04.2012 ▲

Vollständiges Zitat

Absatzweise Citazione Zeilenweise Citazione

Morgen,

wie hier ( [...]

) bereits geschrieben kannst Du if, while, whileloop einfach direkt verwenden
ohne die deutlich schmächtigere High-Level-Syntax (HLS) von jwasm.

Ein paar plakativ-gestaltete ASM-Beispiele per if, while und Zählschleife ohne HLS
könnten so aussehen:

Kompilieren Markieren Separieren

 {$cleq}

nProc test.ifgleich

    parameters v&,w&
    mov eax,1
    mov ebx,v&
    mov ecx,w&
    cmp ebx,ecx
    je uebersprung
    mov eax,0
    uebersprung:

endproc

nProc test.ifkleiner

    parameters v&,w&
    mov eax,1
    mov ebx,v&
    mov ecx,w&
    cmp ebx,ecx
    jl uebersprung
    mov eax,0
    uebersprung:

endproc

nProc test.whileZaehle

    parameters v&
    mov ebx,v&
    xor ecx,ecx
    anfang:
    add ecx,1
    'schleifenkörper, ecx ist hier 1 bis 10
    cmp ecx,ebx
    jge uebersprung
    jmp anfang
    uebersprung:
    mov eax,ecx

endproc

cls
print test.ifgleich(9,10)
print test.ifgleich(10,10)
print test.ifkleiner(9,10)
print test.ifkleiner(10,10)
print test.whileZaehle(10)
waitInput
end

und gibt aus:

0
1
1
0
10

wobei eben dies hier ja selbes Ergebis liefert:

Kompilieren Markieren Separieren

 {$cleq}

nProc test.ifgleich

    parameters v&,w&

    if v&=w&

        return 1

    else

        return 0

    endif

endproc

nProc test.ifkleiner

    parameters v&,w&

    if v&<w&

        return 1

    else

        return 0

    endif

endproc

nProc test.whileZaehle

    parameters v&

    whileloop v&

        'schleifenkörper

    wend

    sub eax,1'<-- nicht wichtig, nur kosmetisch damit 10 zurück gegeben wird

endproc

cls
print test.ifgleich(9,10)
print test.ifgleich(10,10)
print test.ifkleiner(9,10)
print test.ifkleiner(10,10)
print test.whileZaehle(10)
waitInput
end

und dies hier eine optimiertere Variante davon ist:

Kompilieren Markieren Separieren

 {$cleq}

nProc test.ifgleich

    parameters v&,w&
    case v&=w& : return 1
    return 0

endproc

nProc test.ifkleiner

    parameters v&,w&
    case v&<w& : return 1
    return 0

endproc

nProc test.whileZaehle

    parameters v&

    whileloop v&

        'schleifenkörper

    wend

    sub eax,1'<-- nicht wichtig, nur kosmetisch damit 10 zurück gegeben wird

endproc

cls
print test.ifgleich(9,10)
print test.ifgleich(10,10)
print test.ifkleiner(9,10)
print test.ifkleiner(10,10)
print test.whileZaehle(10)
waitInput
end

und es noch kürzer geht:

Kompilieren Markieren Separieren

 {$cleq}

nProc test.ifgleich

    parameters v&,w&
    return v&=w&

endproc

nProc test.ifkleiner

    parameters v&,w&
    return v&<w&

endproc

nProc test.whileZaehle

    parameters v&

    whileloop v&

        'schleifenkörper

    wend

    sub eax,1'<-- nicht wichtig, nur kosmetisch damit 10 zurück gegeben wird

endproc

cls
print test.ifgleich(9,10)
print test.ifgleich(10,10)
print test.ifkleiner(9,10)
print test.ifkleiner(10,10)
print test.whileZaehle(10)
waitInput
end

und es auch noch "cooler" geht:

Kompilieren Markieren Separieren

 {$cleq}

nProc test.ifgleich(long v,w){ return v&==w& }

nProc test.ifkleiner(long v,w){ return v&<w& }

nProc test.whileZaehle(long v){

    whileloop v {

        'schleifenkörper

    }

    sub eax,1'<-- nicht wichtig, nur kosmetisch damit 10 zurück gegeben wird

}

cls
print test.ifgleich(9,10)
print test.ifgleich(10,10)
print test.ifkleiner(9,10)
print test.ifkleiner(10,10)
print test.whileZaehle(10)
waitInput
end