looping onto the second equation

Question

I'm making a small calculator in nasm 86x that reads two lines of equations in the form

3 + 2

6 / 2

which should calculate and output

5

3

its user input, but only 2 digits and it will read what operator to use and then go to wherever I called that operator, and do the equation. I just don't know how to loop it so it reads the next line as well. I tried to just hardcode it, but its difficult with the div operator, as I clear the upper register as I don't care about complicated numbers.

segment .data 

    NO: db 'Invalid input', 10
    nolen: equ $-NO
    
    segment .bss
    ;defining all variables
       space resb 1
       num1 resb 1
       num2 resb 1
       ;second equation
       num3 resb 1
       num4 resb 1
       char resb 1
       char2 resb 1
    ;newline for enter char, maybe
    newlin resb 1
    ;result
       res resb 1   
  
    section .text
       global _start    ;must be declared for using gcc
        
    _start:             ;tell linker entry point
        
     mov cx, 2
     
    ;reading space
       mov eax, 3
       mov ebx, 0  
       mov ecx, space 
       mov edx, 1
       int 0x80  

    ;reading num 1
       mov eax, 3
       mov ebx, 0  
       mov ecx, num1 
       mov edx, 1
       int 0x80  
    
    ;reading space
       mov eax, 3
       mov ebx, 0  
       mov ecx, space 
       mov edx, 1
       int 0x80  

       
    ;reading char
        mov eax, 3
        mov ebx, 0
        mov ecx, char
        mov edx, 1
        int 0x80
            
    ;reading space
       mov eax, 3
       mov ebx, 0  
       mov ecx, space
       mov edx, 1
       int 0x80  


    ;reading num 2
       mov eax, 3
       mov ebx, 0
       mov ecx, num2 
       mov edx, 1
       int 0x80   
                   
    ;reading space
       mov eax, 3
       mov ebx, 0  
       mov ecx, space
       mov edx, 1
       int 0x80  
                          
    ;reading next line
       mov eax, 3
       mov ebx, 0  
       mov ecx, newlin
       mov edx, 1
       int 0x80


    
       ; moving the first number to eax register and second number to ebx
       ; and subtracting ascii '0' to convert it into a decimal number
       ;moving variables in lower halfs
       
       
       mov AX, [char]
       ;compare char to plus sign
       cmp AX, byte '+'
       ;jump to plus function
       je plus
       cmp AX, byte '-'
       ;jump to minus
       je minus
       cmp AX, byte '*'
       ;jump to multiplication
       je multi
       cmp AX, byte '/'
       ;jump to division
       je divi
       jmp Nope
       cmp AX, 2
       je _start

       Nope:
       mov eax, 4
       mov ebx, 1
       mov ecx, NO
       mov edx, nolen
       int 0x80
       jmp exit
       
       plus:
       mov al, [num1]
       mov bl, [num2]
       add al, bl
       sub al, '0'
       mov [res], al
       
       
       ; print the sum 
       mov eax, 4       
       mov ebx, 1
       mov ecx, res        
       mov edx, 1
       cmp ecx, 2
       je _start
       int 0x80
       jmp exit
      
       
       minus:
       mov al, [num1]
       mov bl, [num2]
       sub al, bl
       add al, '0'
       mov [res], al
       ;print the sub 
       mov eax, 4       
       mov ebx, 1
       mov ecx, res         
       mov edx, 1 
       cmp ecx, 2
       je _start
       int 0x80
       jmp exit
       
       multi:
       mov al, [num1]
       mov bl, [num2]
       sub al, '0'
       sub bl, '0'
       ;multiply them
       mul bl
       ;sub bl, '0'
       add al, '0'
       mov [res], al
       ;add al, '0'
       ; print the sum 
       mov eax, 4       
       mov ebx, 1
       mov ecx, res         
       mov edx, 1
       cmp ecx, 2
       je _start
       int 0x80
       jmp exit
       
       divi:
       mov al, [num1]
       mov bl, [num2]
       mov dx, 0
       mov ah, 0
       sub al, '0'
       sub bl, '0'
       div bl
       add ax, '0'
       mov [res], al
       ; print the divide output
       mov eax, 4       
       mov ebx, 1
       mov ecx, res         
       mov edx, 1
       cmp ecx, 2
       je _start
       int 0x80
       jmp exit
      

    exit:    
       mov eax, 1
       mov ebx, 0
       int 0x80

I was reading my textbook and it says to use the cmp ecx, 2 and je _start but I guess I am not using it correctly. I at least got it to semi work its just that last line I am unable to get. Right now it always correctly outputs the first value, just prints nothing for the other.

user_3144770 · Answer

It's about register preservation

mov  cx, 2

;reading space
mov  eax, 3
mov  ebx, 0  
mov  ecx, space 
mov  edx, 1
int  0x80

With the mov cx, 2 instruction you are setting up a loop counter so your code can run twice. That's fine, but just a few instructions later, you destroy this counter with the mov ecx, space instruction that loads a buffer address. Don't forget that CX is just the low 16 bits of the ECX register.
A solution is to store the counter on the stack.

  mov  ecx, 2        ; Use ECX instead of CX in 32-bit code!
  push ecx           ; (1) Preserving the counter

  ;reading space
  mov  eax, 3
  mov  ebx, 0  
  mov  ecx, space 
  mov  edx, 1
  int  0x80
  ...

It's about how and where you loop back

As an example, look at the plus code:

; print the sum
mov  eax, 4   
mov  ebx, 1
mov  ecx, res
mov  edx, 1
cmp  ecx, 2     <-- Extra code to loop back 
je   _start     <--
int  0x80
jmp  exit

Firstly, you should have placed the extra code below the int 0x80 instruction, so the print function can do its job first.
Secondly, the ECX register does not contain your loop counter because of the mov ecx, res instruction just a few lines higher up!
Thirdly, working with a counter means that the code needs to manipulate it. Most often this boils down to decrementing it.

A quick solution:

  ; print the sum 
  mov  eax, 4       
  mov  ebx, 1
  mov  ecx, res        
  mov  edx, 1
  int  0x80

  pop  ecx           ; (1) Restoring the counter
  dec  ecx           ; Decrementing the counter
  jnz  _start        ; Looping back if the counter is not yet zero
  jmp  exit          ; Exit program if the counter has become zero

Now you could apply this to each of the 4 code blocks plus, minus, multi, and divi, or you could write it somewhat more intelligently:

plus:
  ...                ; Calculating and printing go here
  jmp  MORE
minus:
  ...                ; Calculating and printing go here
  jmp  MORE
multi:
  ...                ; Calculating and printing go here
  jmp  MORE
divi:
  ...                ; Calculating and printing go here
  jmp  MORE

MORE:
  pop  ecx           ; (1) Restoring the counter
  dec  ecx           ; Decrementing the counter
  jnz  _start        ; Looping back if the counter is not yet zero
exit:                ; Exit program if the counter has become zero
  mov  eax, 1
  mov  ebx, 0
  int  0x80

It's about where you loop back to

The _start label is where the program begins executing. This cannot be the target for looping back, because if we did, we would be reinitializing the counter forever and the program could never terminate.
The line where we preserve our counter is the correct target for looping back:

  mov  ecx, 2        ; Use ECX instead of CX in 32-bit code!
AGAIN: <----------------------------------------------------------------\
  push ecx           ; (1) Preserving the counter                        |
                                                                         |
  ...                                                                    |
                                                                         |
MORE:                                                                    |
  pop  ecx           ; (1) Restoring the counter                         |
  dec  ecx           ; Decrementing the counter                          |
  jnz  AGAIN         ; Looping back if the counter is not yet zero -----/
exit:                ; Exit program if the counter has become zero
  mov  eax, 1
  mov  ebx, 0
  int  0x80

Something to keep paying attention to

mov  AX, [char]
;compare char to plus sign
cmp  AX, byte '+'
;jump to plus function
je   plus

The char variable is a byte. Never read it like it was a word. If nasty things can happen, they will happen...

  mov  al, [char]
  cmp  al, '+'
  je   plus
  cmp  al, '-'
  je   minus
  cmp  al, '*'
  je   multi
  cmp  al, '/'
  je   divi
Nope:
  mov  eax, 4
  mov  ebx, 1
  mov  ecx, NO
  mov  edx, nolen
  int  0x80
  jmp  exit

There's gotta be one final remark

jmp Nope
cmp AX, 2           <- These lines will NEVER execute
je _start           <-
Nope: