Übungsprogramm klappt nicht richtig

hey
ich wollte bisschen Üben und ein Programm schreiben, welches 5 Werte entweder addiert oder subtrahiert. Irvine32.inc stellt mir paar funktionen zum console input-output zur verfügung, wundert euch deswegen nicht (WriteString ReadHex etc.). Jedenfalls klappt alles soweit, aber wenn ich z. b. 5 mal 10 eingebe dann gibt es 80 als Ergebnis aus. Woran liegt das? Ihr könnt mir auch andere Sachen sagen die ich schlecht gemacht habe oder sagen was man besser machen könnte! Danke

TITLE Calculator (Calculator.asm)

INCLUDE Irvine32.inc

.data
addOrSubQ BYTE "Welcome! Do you want to add or subtract values? (1 = add, 2 = sub)", 0
promptMessage BYTE "Pls tell me 5 values!", 0
resultMessage BYTE "Here is the result: ", 0
againOrNotQ BYTE "Do you want to calculate again? (1 = yes, 2 = no)", 0

.data?
values DD 5 DUP(?)
addOrSubA DD ?
result DD ?
againOrNotA DD ?

.code
main PROC

	mov eax, 10
	call SetTextColor ; chance color
start::
	call addOrSub
	call promptForValues
	call calculateResult
back::
	call printResult
	call againOrNot
	call WaitMsg
	exit

main ENDP

; gives back the result (1 Or 2) to eaxreg
addOrSub PROC
	mov edx, OFFSET addOrSubQ
	call WriteString
	call crlf
	call ReadHex ; read input
	mov addOrSubA, eax
	ret
addOrSub ENDP

promptForValues PROC
	mov edx, OFFSET promptMessage
	call WriteString
	call crlf
	call ReadHex
	mov values, eax
	call ReadHex
	mov [values + 4], eax
	call ReadHex
	mov [values + 8], eax
	call ReadHex
	mov [values + 12], eax
	call ReadHex
	mov [values + 16], eax
	call crlf
	ret
promptForValues ENDP

calculateResult PROC
	cmp addOrSubA, 1
	JE addValues
	cmp addOrSubA, 2
	JE subValues
	ret
calculateResult ENDP

addValues::
	mov eax, values
	add eax, [values + 4]
	add eax, [values + 8]
	add eax, [values + 12]
	add eax, [values + 16]
	mov result, eax
	jmp back
subValues::
	mov eax, values
	sub eax, [values + 4]
	sub eax, [values + 8]
	sub eax, [values + 12]
	sub eax, [values + 16]
	mov result, eax
	jmp back

printResult PROC
	mov edx, OFFSET resultMessage
	call WriteString
	mov eax, result
	call WriteInt
	call crlf
	ret
printResult ENDP

againOrNot PROC
	mov edx, OFFSET againOrNotQ
	call WriteString
	call crlf
	call ReadHex
	mov againOrNotA, eax
	cmp againOrNotA, 1
	JE start
	ret
againOrNot ENDP
END main

Nobuo T

Zur eigentlichen Frage:
Du liest dem Prozedurnamen "ReadHex" zufolge offenbar hexadezimale Zahlen (Basis 16, Ziffern 0-F) ein.
"WriteInt" scheint jedoch Zahlen dezimal (Basis 10, Ziffern 0-9) auszugeben.
Nun ist 10 hexadezimal gleich 16 dezimal. Dh. 5*10=50 hexadezimal ist 5*16=80 dezimal. Um Verwirrung vorzubeugen waere es also zweckdienlich, Zahlen mit der selben basis einzulesen und auszugeben.

Noch allgemein:
In Assembler ist es idR. keine gute Idee, Prozeduren zur reinen Strukturierung zu benutzen. Das laeuft irgendwo dem Sinn und Zweck von Assembler zum Schreiben effizienter Programme entgegen.
Um den Code und das Prinzip der Prozedur uebersichtlich zu halten sollte man es auch vermeiden, zwischen Prozeduren mit normalen Sprungbefehlen zu wechseln.
So laesst du zB. auch mit jedem Sprung von "againOrNot" zum Label "start" die Ruecksprungadresse auf dem Stack liegen, was bei mehreren Wiederholungen zwangslaeufig irgendwann zu einem Stack-Ueberlauf fuehren wird.
Ich wuerde also vorschlagen, bis auf die Prozeduren aus der .inc-Datei saemtliche Prozeduren aus deinem Code zu entfernen und deren Funktionalitaet direkt hin zu coden.

vielen Dank Nobou T! Jetzt verwende ich ReadDec.
Und danke auch für die Tipps!

jetzt habe ich noch ein größeres Problem.
Ich soll mit ADC ( das ja das carry mitaddiert) 2 64 bit ints addieren und das Ergebnis zeigen.

TITLE Chapter7Exercise (Chapter7Exercise.asm)

INCLUDE Irvine32.inc

.data
op1 QWORD 18446744073709551615
op2 QWORD 18446744073709551615
result BYTE "The result is: ", 0

.data?
sum DWORD 3 DUP(?)

.code
main PROC

	mov esi, offset op1
	mov edi, offset op2
	mov ebx, offset sum
	mov ecx, 2 ; number of dword

	clc ; clear carry

L1:  mov eax, [esi]
	adc eax, [edi]
	pushfd
	mov [ebx], eax
	add esi, 4
	add edi, 4
	add ebx, 4
	popfd
	loop L1

	adc WORD PTR[ebx], 0
	popad

	mov edx, offset result
	call WriteString
	call crlf

	mov eax, [sum + 8]
	call WriteInt

	mov eax, [sum + 4]
	call WriteInt

	mov eax, sum
	call WriteInt

	mov eax, 2000
	call Delay
	exit

main ENDP
END main

Leider steig ich da nicht mehr durch. Außerdem ist in sum kein richtiges Ergebnis. Könnte sich das bitte jemand anschauen?

habs jetzt nochmal mit einer anderen Version probiert. Es wird aber auch nicht das richtige ergebnis ausgegeben.

TITLE Chapter7Exercise (Chapter7Exercise.asm)

INCLUDE Irvine32.inc

.data
op1 QWORD 18446744073709551615
op2 QWORD 18446744073709551615
result BYTE "The result is: ", 0

.data?
sum DWORD 3 DUP(?)

.code
main PROC

	mov eax, DWORD PTR op1 ; low word of op1
	mov ebx, DWORD PTR [op1+4] ; high word of op1

	mov ecx, DWORD PTR op2 ; low word of op2
	mov edx, DWORD PTR [op2+4] ; high word of op2
	clc ; clear carry to be safe

	mov sum, eax ; low word op1
	adc sum, ebx ; high word op2

	add sum, ecx ; low op2
	adc sum, edx ; high op2

	mov edx, offset result
	call WriteString

	mov eax, sum
	call WriteDec

	mov eax, sum[4]
	call WriteDec

	mov eax, sum[8]
	call WriteDec ; sollte jetzt so aussehen als wäre es 1 zahl, da es   nacheinander geschrieben wird.

	mov eax, 5000
	call Delay ; sleep
	exit

main ENDP
END main

Nobuo T

Das Prinzip ist, dass du nacheinander das 1. dword des 1. op mit dem des 2. op (beim 1. brauchst du auch noch kein adc, da der Uebertrag sicher 0 ist - so sparst du dir auch das clc) addierst und im 1. dword des Ergebnisses speicherst. Dann das 2. dword des 1. op mit dem des 2. op und den Uebertrag aus der 1. Addition dazu im 2. dword des Ergebnisses. Zuletzt brauchst du nur noch den Uebertrag der letzten Addition (also das Carry-Flag CF) an das Ergebnis anhaengen. Geht zB. indem du auf das dritte (ein Byte wuerde hier reichen) ein adc mit 0 machst.

Das sieht im Prinzip im 1. Code auch ganz gut umgesetzt aus und das Ergebnis sollte so weit ich das mit diesem Schnipsel beurteilen kann auch stimmen. Bleibt fuer diesen Code eigentlich nur anzumerken, dass das "popad" in z. 34 dort IMHO nichts zu suchen hat und dass man so kurze Schleifen (weniger als 4 Durchlaeufe) besser direkt ausrollen sollte (wie du es in deinem?, dem 2. Code versucht hast).

Beim 2. Code kommst du jedoch irgendwie mit den einzelnen Summanden total durcheinander und addierst auch immer nur wirr auf das 1. dword der Summe drauf. Da kann nichts sinnvolles bei herauskommen.
Weiter kannst du einen integer nicht sinnvoll als Dezimalzahl ausgeben, indem du ihn auf diese Weise Stueck fuer Stueck hintereinander konvertierst. Das geht wohl nur mit Zahlensystemen, deren Basis eine Potenz von 2 ist. Also zB. hexadezimal wie im 1. Code.

Beispiel:
Ein word aus 2 Bytes (01 01) wird derart byteweise konvertiert.
Ergebnis dezimal:
jeweils 1 -> 11 -> falsch. sollte 257 sein.
Ergebnis hexadezimal:
jeweils 01 -> 0101 -> stimmt.

Beachte beim Ueberpruefen des Ergebnisses des 1. Codes auch, dass die beiden Summanden aus irgendeinem Grund dezimal angegeben sind.

danke! Hab es verstanden.