Hi Grimoire,
You seem to be using esp and ebp correctly, so I don't know what I can tell you about that. If you have questions, ask again... but I don't think that's a problem.
Your routine to convert ascii to decimal starts out well, but then I get confused...
; ...
sumar:
push ebp ; save caller's ebp
mov ebp, esp ; create a "stack frame"
sub esp, 8 ; make a buffer on the stack
; this just repeats "suma"
; I don't know why, but it does no harm
mov eax, 4
mov ebx, 1
lea ecx, [ebp + 8]
mov edx, 4
int 0x80
; read some ascii into our buffer
mov eax, 3
mov ebx, 1 ; should be 0 - stdin?
lea ecx, [ebp - 8]
mov edx, 5
int 0x80
xor eax, eax
strtodec:
mov al, byte[ebp - 8] ; get a character
cmp al, 10 ; linefeed - not really "NULL"
je con
sub al, 48 ; convert a character to a number
; this is fine unless the pesky user types
; something other than '0' to '9'
; you might want to check that we have
; a "valid" character at this point, but okay...
mov byte[buf2], al ; store the number in another buffer
inc byte[ebp - 8]
inc byte[buf2]
Here's where I get confused. Suppose I typed "123". You get the character '1', convert it to the number 1, and store it in buf2. Then you increment the character '1' to '2', and increment the number 1 to 2. I think you want to move to the next character in the buffer. That would be at "[ebp - 7]", but I think you're better off to put the address of "[ebp - 8]" into a register, and increment that. Then, once we've got another valid character - but probably not before - we want to multiply the "result so far" by 10, and add in the next character (converted to a number, of course!). So the "result so far" is 12. Then when we get the '3', we convert it to 3, multiply the "result so far" by 10 again, and add in the 3. At this point we find the linefeed (also 10, by chance) so we're done and the result is 123.
The obvious way to "multiply by 10" is to use the "mul" instruction. This multiplies eax by the operand you provide - either a register or memory - and puts the result in edx:eax. No choice of the registers eax and edx!
The "imul" instruction is more complicated. With one operand, it is the same as "mul", only it handles signed numbers (could be negative). With three operands, it multiplies the second by the third, and puts the result in the first. This is a 32-bit x 32-bit = 32- bit operation, unlike "mul" and the one-operand "imul" which do 32 x 32 = 64. The two-operand form is just a special case of the three-operand form, in which the first and second operands are the same. Also, the third operand (or second) can be an immediate (signed byte), which we can't do with "mul".
imul ebx, 10
will work, and may be just what you want.
When it comes to "add in the next digit", there may be a complication. We can't:
add ebx, al
no matter how much we'd like to! We need to have the "next digit" in a 32-bit register, even though it would fit in a byte. It isn't a "problem", but we need to make sure that the upper bits are zero.
Besides "mul" and "imul" there's a "trick" using lea:
lea ebx, [ebx + ebx * 4] ; ebx = ebx * 5
lea ebx, [ebx * 2] ; multiplied by ten!
We can add in the "next digit" while we're at it:
lea ebx, [ebx + ebx * 4]
lea ebx, [eax + ebx * 2]
We can even do the "convert character to number" part:
lea ebx, [ebx * 5] ; we can write it this way, too
lea ebx, [eax + ebx * 2 - '0']
(I think writing it as '0' rather than 48 makes it clearer what the "purpose" of the number is - either will work). One disadvantage to this method is that there's no way to check for overflow using "lea". It's what I'm currently using, mostly because I think it's "cute". It was shown to me by Herbert Kleebauer, and was supposedly originally generated by a C compiler! Clever, those compilers (their authors, actually)!
So you can probably get that part working, one way or another. Then you go on to:
; ...
con:
; this is going to print the decimal, not ascii
; probably not useful!
mov eax, 4
mov ebx, 1
lea ecx, [buf2]
mov edx, 5
int 0x80
mov esp, ebp ; undo the "stack frame"
pop ebp ; resore caller's ebp
ret 8
The "ret 8" is not correct! That will "remove" two parameter's from the stack, but we only pushed one! You could do "ret 4" here - that would make it a "stdcall" calling convention. Windows APIs use this, and if you were using Windows you'd be wise to do it the same way. Linux more commonly uses the "cdecl" calling convention, in which the caller removes the parameters. You might want to stick with that (either will work) End your subroutine with just "ret", and where you call it:
push dword [buf1]
call sumar
add esp, 4 ; "remove" the parameter
;...
You could also "pop" a dummy register. Since you just sys_exit after this, it doesn't matter if you clobber the stack, but it isn't "right"!
I mentioned:
mov eax, 3 ; sys_write
mov ebx, 1 ; read from stdout?
I once caught Randy Hyde doing this, and pointed it out to him. He explained that with both Dos and Unix, you can use either stdin or stdout with a read or write, and it'll do the right thing. I don't know why this works, but it does. He agreed that the code would be clearer if he used stdin (0) to read from. You might want to do the same (couple places). Not a big deal!
When you've got your number(s) and done a calculation, you need to convert back to ascii before you can display the result. It won't work putting the number in ecx, nor putting the address of a buffer containing the number in ecx. You'll need to add that 48 (or '0') back in... for each digit. There should be a post nearby called something like "integer in, integer out" that has an example, if you need it. That post will also point out that you can "just call scanf" and "just call printf" to do this.
I could attempt a working version of your code, but I'm not sure why you're passing "suma" to your subroutine. You probably have doing something further in mind...
Best,
Frank
