$\%$macro print $2$

mov rax, $1$ ;SYS$\_$write

mov rdi, $1$ ;standard output device

mov rsi, $\%1$ ;output string address

mov rdx$,\%2$ ;number of character

syscall ;calling system services

$\%$endmacro

$\%$macro scan $2$

mov rax, $0$ ;SYS$\_$read

mov rdi, $0$ ;standard input device

mov rsi, $\%1$ ;input buffer address

mov rdx$,\%2$ ;number of character

syscall ;calling system services

$\%$endmacro

section $.$bss

buffer resb $10$ ; Input buffer for the arithmetic expression

result resb $1$ ; Result of the calculation

ascii resb $10$ ; Buffer for the ASCII representation of the result

section $.$data

LF equ $10$

NULL equ $0$

input$\_$msg db "Enter arithmetic expression $($e$.$g$.,$ a$+$b$*$c$-$d$/$e$)$: $",0$

input$\_$msg$\_$len equ $ $-$ input$\_$msg

result$\_$msg db "Result: $",0$

result$\_$msg$\_$len equ $ $-$ result$\_$msg

section $.$text

global $\_$start

$\_$start:

; Prompt user for input

print input$\_$msg$,$ input$\_$msg$\_$len

; Read input arithmetic expression

scan buffer, $10$

; Calculate the result

mov rdi, buffer ; Pass the input buffer address

call calculate

; Convert result to string

mov rdi, result ; Pass the address of the result

mov rsi, ascii ; Pass the address of the buffer for ASCII representation

call toString

; Display the result

print result$\_$msg$,$ result$\_$msg$\_$len

print ascii, $10$ ; Print the ASCII representation of the result with newline

; Terminate the program

mov rax, $60$

xor rdi, rdi

syscall

calculate:

; Save the original value of rcx

push rcx

; Initialize variables

mov rcx$,0$ ; Loop counter

mov byte$[$result$],0$ ; Initialize result to $0$

calc$\_$loop:

; Read the current character from input buffer

mov al$,$ byte$[$rdi $+$ rcx$]$

; Check if the character is a digit

cmp al$,\text{'}0\text{'}$

jb done$\_$calc ; If not a digit, exit loop

cmp al$,\text{'}9\text{'}$

ja done$\_$calc ; If not a digit, exit loop

; Convert ASCII digit to integer

sub al$,\text{'}0\text{'}$

; Update result based on the operation

; You can add more operations here

; For example: $+,-,*,/$

; Assume that the input format is always digit $-$ operator $-$ digit

; Example: a$+$b$*$c$-$d$/$e

; Perform left$-$to$-$right evaluation without considering operator precedence

; Check if there's an operator after the digit

cmp byte$[$rdi $+$ rcx $+1],\text{'}+\text{'}$

je add$\_$operation

cmp byte$[$rdi $+$ rcx $+1],\text{'}-\text{'}$

je subtract$\_$operation

cmp byte$[$rdi $+$ rcx $+1],\text{'}*\text{'}$

je multiply$\_$operation

cmp byte$[$rdi $+$ rcx $+1],\text{'}/\text{'}$

je divide$\_$operation

; If no operator found, move to the next character

inc rcx

jmp calc$\_$loop

add$\_$operation:

; Read the next digit

mov al$,$ byte$[$rdi $+$ rcx $+2]$

sub al$,\text{'}0\text{'}$

; Add the next digit to the result

add byte$[$result$],$ al

; Move to the next operator

add rcx$,3$

jmp calc$\_$loop

subtract$\_$operation:

; Read the next digit

mov al$,$ byte$[$rdi $+$ rcx $+2]$

sub al$,\text{'}0\text{'}$

; Subtract the next digit from the result

sub byte$[$result$],$ al

; Move to the next operator

add rcx$,3$

jmp calc$\_$loop

multiply$\_$operation:

; Read the next digit

mov al$,$ byte$[$rdi $+$ rcx $+2]$

sub al$,\text{'}0\text{'}$

; Multiply the result by the next digit

mul byte$[$result$]$

mov byte$[$result$],$ al

; Move to the next operator

add rcx$,3$

jmp calc$\_$loop

divide$\_$operation:

; Read the next digit

mov al$,$ byte$[$rdi $+$ rcx $+2]$

sub al$,\text{'}0\text{'}$

; Check if the next digit is zero to avoid division by zero

cmp al$,0$

je done$\_$calc

; Divide the result by the next digit

mov ah$,0$

mov bl$,$ byte$[$result$]$

div bl

mov byte$[$result$],$ al

; Move to the next operator

add rcx$,3$

jmp calc$\_$loop

done$\_$calc:

; Restore the original value of rcx

pop rcx

ret

; Integer to String function

toString:

; Part A $-$ Successive division

movzx eax, byte$[$rdi$]$ ; Get integer

mov rcx$,0$ ; digitCount $=0$

mov ebx, $10$ ; Set for dividing by $10$

divideLoop:

mov edx, $0$

div ebx ; Divide number by $10$

push dx ; Push remainder

inc rcx ; Increment digitCount

cmp eax, $0$ ; If quotient $!=0$

jne divideLoop ; Goto divideLoop

; Part B $-$ Convert remainders and store

mov rbx$,$ rsi ; Get addr of ascii

mov rdi, $0$ ; rdi $=0$

popLoop:

pop rax ; Pop intDigit

add al$,"0"$