main:
jmp start ; jump over data declaration
msg: db "1-Add",0dh,0ah,"2-Multiply",0dh,0ah,"3-Subtract",0dh,0ah,"4-Divide", 0Dh,0Ah, '$'
msg2: db 0dh,0ah,"Enter First No: $"
msg3: db 0dh,0ah,"Enter Second No: $"
msg4: db 0dh,0ah,"Choice Error $"
msg5: db 0dh,0ah,"Result : $"
msg6: db 0dh,0ah ,'thank you for using the simple calculator! press any key to exit... ', 0Dh,0Ah, '$'
start: mov ah,9
mov dx, msg ; ;first we will display hte first message from which he can choose the operation using int 21h
int 21h
mov ah,0
int 16h ;then we will use int 16h to read a key press, to know the operation he choosed
cmp al,31h ;the keypress will be stored in al so, we will comapre to 1 addition ..........
je Addition
cmp al,32h
je Multiply
cmp al,33h
je Subtract
cmp al,34h
je Divide
mov ah,09h
mov dx, msg4
int 21h
mov ah,0
int 16h
jmp start
Addition: mov ah,9 ;then let us handle the case of addition operation
mov dx,msg ;first we will display this message enter first no also using int 21h
int 21h
mov cx,0 ;we will call InputNo to handle our input as we will take each number seprately
call InputNo ;first we will move to cx 0 because we will increment on it later in InputNo
push dx
mov ah,9
mov dx,msg3
int 21h
mov cx,0
call InputNo
pop bx
add dx,bx
push dx
mov ah,9
mov dx,msg5
int 21h
mov cx,10000
pop dx
call View
jmp exit
InputNo: mov ah,0
int 16h ;then we will use int 16h to read a key press
mov dx,0
mov bx,1
cmp al,0dh ;the keypress will be stored in al so, we will comapre to 0d which represent the enter key, to know wheter he finished entering the number or not
je FormNo ;if it's the enter key then this mean we already have our number stored in the stack, so we will return it back using FormNo
sub ax,30h ;we will subtract 30 from the the value of ax to convert the value of key press from ascii to decimal
call ViewNo ;then call ViewNo to view the key we pressed on the screen
mov ah,0 ;we will mov 0 to ah before we push ax to the stack bec we only need the value in al
push ax ;push the contents of ax to the stack
inc cx ;we will add 1 to cx as this represent the counter for the number of digit
jmp InputNo ;then we will jump back to input number to either take another number or press enter
;we took each number separatly so we need to form our number and store in one bit for example if our number 235
FormNo: pop ax; Take the last input from the stack
push dx
mul bx;Here we are multiplying the value of ax with the value of bx
pop dx;After multiplication we will remove it from stack
add dx,ax;After removing from stack add the value of dx with the value of ax
mov ax,bx;Then set the value of bx in ax
mov bx,10
push dx;push the dx value again in stack before multiplying to resist any kind of accidental effect
mul bx;Multiply bx value by 10
pop dx;pop the dx after multiplying
mov bx,ax;Result of the multiplication is still stored in ax so we need to move it in bx
dec cx;After moving the value we will decrement the digit counter value
cmp cx,0;Check if the cx counter is 0
jne FormNo;If the cx counter is not 0 that means we have multiple digit input and we need to run format number function again
ret;If the cx counter is 0 that means all of our digits are fully formatted and stored in bx we just need to return the function
View: mov ax,dx
mov dx,0
div cx
call ViewNo
mov bx,dx
mov dx,0
mov ax,cx
mov cx,10
div cx
mov dx,bx
mov cx,ax
cmp ax,0
jne View
ret
ViewNo: push ax ;we will push ax and dx to the stack because we will change there values while viewing then we will pop them back from
push dx ;the stack we will do these so, we don't affect their contents
mov dx,ax ;we will mov the value to dx as interrupt 21h expect that the output is stored in it
add dl,30h ;add 30 to its value to convert it back to ascii
mov ah,2
int 21h
pop dx
pop ax
ret
exit: mov dx,msg6
mov ah, 9
int 21h
mov ah, 0
int 16h
ret
Multiply: mov ah,9
mov dx,msg2
int 21h
mov cx,0
call InputNo
push dx
mov ah,9
mov dx,msg3
int 21h
mov cx,0
call InputNo
pop bx
mov ax,dx
mul bx
mov dx,ax
push dx
mov ah,9
mov dx,msg5
int 21h
mov cx,10000
pop dx
call View
jmp exit
Subtract: mov ah,9
mov dx,msg2
int 21h
mov cx,0
call InputNo
push dx
mov ah,9
mov dx,msg3
int 21h
mov cx,0
call InputNo
pop bx
sub bx,dx
mov dx,bx
push dx
mov ah,9
mov dx,msg5
int 21h
mov cx,10000
pop dx
call View
jmp exit
Divide: mov ah,9
mov dx,msg2
int 21h
mov cx,0
call InputNo
push dx
mov ah,9
mov dx,msg3
int 21h
mov cx,0
call InputNo
pop bx
mov ax,bx
mov cx,dx
mov dx,0
mov bx,0
div cx
mov bx,dx
mov dx,ax
push bx
push dx
mov ah,9
mov dx,msg5
int 21h
mov cx,10000
pop dx
call View
pop bx
cmp bx,0
je exit
jmp exit Write, Run & Share Assembly code online using OneCompiler's Assembly online compiler for free. It's one of the robust, feature-rich online compilers for Assembly language. Getting started with the OneCompiler's Assembly compiler is simple and pretty fast. The editor shows sample boilerplate code when you choose language as Assembly and start coding.
Assembly language(asm) is a low-level programming language, where the language instructions will be more similar to machine code instructions.
Every assembler may have it's own assembly language designed for a specific computers or an operating system.
Assembly language requires less execution time and memory. It is more helful for direct hardware manipulation, real-time critical applications. It is used in device drivers, low-level embedded systems etc.
Assembly language usually consists of three sections,
Data section
To initialize variables and constants, buffer size these values doesn't change at runtime.
bss section
To declare variables
text section
_start specifies the starting of this section where the actually code is written.
There are various define directives to allocate space for variables for both initialized and uninitialized data.
variable-name define-directive initial-value
| Define Directive | Description | Allocated Space |
|---|---|---|
| DB | Define Byte | 1 byte |
| DW | Define Word | 2 bytes |
| DD | Define Doubleword | 4 bytes |
| DQ | Define Quadword | 8 bytes |
| DT | Define Ten Bytes | 10 bytes |
| Define Directive | Description |
|---|---|
| RESB | Reserve a Byte |
| RESW | Reserve a Word |
| RESD | Reserve a Doubleword |
| RESQ | Reserve a Quadword |
| REST | Reserve a Ten Bytes |
Constants can be defined using
CONSTANT_NAME EQU regular-exp or value
%assign constant_name value
%define constant_name value
Loops are used to iterate a set of statements for a specific number of times.
mov ECX,n
L1:
;<loop body>
loop L1
where n specifies the no of times loops should iterate.
Procedure is a sub-routine which contains set of statements. Usually procedures are written when multiple calls are required to same set of statements which increases re-usuability and modularity.
procedure_name:
;procedure body
ret