Assebly Lab Print
-
Upload
pratikdarbhe -
Category
Documents
-
view
118 -
download
5
Transcript of Assebly Lab Print
Sessions 3
1. Write a program to add two numbers present in two consecutive memory locations and
store the result in next memory location.
Code: ; multi-segment executable file template.
data segment
; add your data here!
Number1 dw 1
Number2 dw 2
Number3 dw ?
ends
stack segment
dw 128 dup(0)
ends
code segment
start:
; set segment registers:
mov ax, data
mov ds, ax
mov es, ax
; add your code here
mov ax,Number1
add ax,Number2
mov Number3,ax
; wait for any key....
mov ah, 1
int 21h
mov ax, 4c00h ; exit to operating system.
int 21h
ends
end start ; set entry point and stop the assembler.
Output:
2. Develop program to read a character from console and echo it. Code:
; multi-segment executable file template.
data segment
; add your data here!
ends
stack segment
dw 128 dup(0)
ends
code segment
start:
; set segment registers:
mov ax, data
mov ds, ax
mov es, ax
; add your code here
mov ah, 1 ;read from user
int 21h
mov ah, 2 ; write on screen
mov dl,al
int 21h
; wait for any key....
mov ah, 1
int 21h
mov ax, 4c00h ; exit to operating system.
int 21h
ends
end start ; set entry point and stop the assembler.
Output:
3. Develop and execute a program to read 10 chars from console
Code: include 'emu8086.inc'
; multi-segment executable file template.
data segment
; add your data here!
var db ?
ends
stack segment
dw 128 dup(0)
ends
code segment
start:
; set segment registers:
mov ax, data
mov ds, ax
mov es, ax
mov cx,10
; add your code here
back:
mov ah, 1
int 21h
loop back
; output string at ds:dx
; wait for any key....
mov ah, 1
int 21h
mov ax, 4c00h ; exit to operating system.
int 21h
ends
end start ; set entry point and stop the assembler.
Output:
4. Write a program to exchange two memory variables using MOV and XCHG instruction.
Can you do it with just XCHG?
Code: ; multi-segment executable file template.
data segment
; add your data here!
var1 dw 1
var2 dw 2
ends
stack segment
dw 128 dup(0)
ends
code segment
start:
; set segment registers:
mov ax, data
mov ds, ax
mov es, ax
; add your code here
mov ax,var1
mov bx,var2
xchg ax,bx
; wait for any key....
mov ah, 1
int 21h
mov ax, 4c00h ; exit to operating system.
int 21h
ends
end start ; set entry point and stop the assembler.
Output:
5. Write a program to find the sum of two BCD numbers stored in memory.
Code:
; multi-segment executable file template.
data segment
; add your data here!
varb1 dw 00010001b
varb2 dw 00010000b
varb3 dw ?
varh1 dw 11h
varh2 dw 10h
varh3 dw ?
ends
stack segment
dw 128 dup(0)
ends
code segment
start:
; set segment registers:
mov ax, data
mov ds, ax
mov es, ax
; add your code here
mov ax,varb1 ;BCD No
add ax,varb2
mov varb3,ax
mov ax,varb1 ; hexadecimal equivalent
add ax,varb2
mov varb3,ax
; wait for any key....
mov ah, 1
int 21h
mov ax, 4c00h ; exit to operating system.
int 21h
ends
end start ; set entry point and stop the assembler.
Output:
6. Write a program, which will read two decimal numbers, then multiply them together,
and finally print out the result (in decimal).
Code: ; multi-segment executable file template.
data segment
; add your data here!
var db ?
ends
stack segment
dw 128 dup(0)
ends
code segment
start:
; set segment registers:
mov ax, data
mov ds, ax
mov es, ax
mov ah, 1 ;read first number
int 21h
mov bl,al
sub bl,48
mov ah, 1 ;read second number
int 21h
sub al,48
mul bl
mov var,al
; mov ah, 2 ; write on screen
; mov dl,al
; int 21h
; wait for any key....
mov ah, 1
int 21h
mov ax, 4c00h ; exit to operating system.
int 21h
ends
end start ; set entry point and stop the assembler.
Output:
1. Write a program to find the factorial of decimal number given by user. Code:
; this example gets the number from the user,
; and calculates factorial for it.
; supported input from 0 to 8 inclusive!
name "fact"
; this macro prints a char in AL and advances
; the current cursor position:
putc macro char
push ax
mov al, char
mov ah, 0eh
int 10h
pop ax
endm
org 100h
jmp start
result dw ?
start:
; get first number:
mov dx, offset msg1
mov ah, 9
int 21h
jmp n1
msg1 db 0Dh,0Ah, 'enter the number: $'
n1:
call scan_num
; factorial of 0 = 1:
mov ax, 1
cmp cx, 0
je print_result
; move the number to bx:
; cx will be a counter:
mov bx, cx
mov ax, 1
mov bx, 1
calc_it:
mul bx
cmp dx, 0
jne overflow
inc bx
loop calc_it
mov result, ax
print_result:
; print result in ax:
mov dx, offset msg2
mov ah, 9
int 21h
jmp n2
msg2 db 0Dh,0Ah, 'factorial: $'
n2:
mov ax, result
call print_num_uns
jmp exit
overflow:
mov dx, offset msg3
mov ah, 9
int 21h
jmp n3
msg3 db 0Dh,0Ah, 'the result is too big!', 0Dh,0Ah, 'use values
from 0 to 8.$'
n3:
jmp start
exit:
; wait for any key press:
mov ah, 0
int 16h
ret
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; these functions are copied from emu8086.inc ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; gets the multi-digit SIGNED number from the keyboard,
; and stores the result in CX register:
SCAN_NUM PROC NEAR
PUSH DX
PUSH AX
PUSH SI
MOV CX, 0
; reset flag:
MOV CS:make_minus, 0
next_digit:
; get char from keyboard
; into AL:
MOV AH, 00h
INT 16h
; and print it:
MOV AH, 0Eh
INT 10h
; check for MINUS:
CMP AL, '-'
JE set_minus
; check for ENTER key:
CMP AL, 0Dh ; carriage return?
JNE not_cr
JMP stop_input
not_cr:
CMP AL, 8 ; 'BACKSPACE' pressed?
JNE backspace_checked
MOV DX, 0 ; remove last digit by
MOV AX, CX ; division:
DIV CS:ten ; AX = DX:AX / 10 (DX-
rem).
MOV CX, AX
PUTC ' ' ; clear position.
PUTC 8 ; backspace again.
JMP next_digit
backspace_checked:
; allow only digits:
CMP AL, '0'
JAE ok_AE_0
JMP remove_not_digit
ok_AE_0:
CMP AL, '9'
JBE ok_digit
remove_not_digit:
PUTC 8 ; backspace.
PUTC ' ' ; clear last entered not digit.
PUTC 8 ; backspace again.
JMP next_digit ; wait for next input.
ok_digit:
; multiply CX by 10 (first time the result is zero)
PUSH AX
MOV AX, CX
MUL CS:ten ; DX:AX = AX*10
MOV CX, AX
POP AX
; check if the number is too big
; (result should be 16 bits)
CMP DX, 0
JNE too_big
; convert from ASCII code:
SUB AL, 30h
; add AL to CX:
MOV AH, 0
MOV DX, CX ; backup, in case the result will be
too big.
ADD CX, AX
JC too_big2 ; jump if the number is too big.
JMP next_digit
set_minus:
MOV CS:make_minus, 1
JMP next_digit
too_big2:
MOV CX, DX ; restore the backuped value before
add.
MOV DX, 0 ; DX was zero before backup!
too_big:
MOV AX, CX
DIV CS:ten ; reverse last DX:AX = AX*10, make AX =
DX:AX / 10
MOV CX, AX
PUTC 8 ; backspace.
PUTC ' ' ; clear last entered digit.
PUTC 8 ; backspace again.
JMP next_digit ; wait for Enter/Backspace.
stop_input:
; check flag:
CMP CS:make_minus, 0
JE not_minus
NEG CX
not_minus:
POP SI
POP AX
POP DX
RET
make_minus DB ? ; used as a flag.
SCAN_NUM ENDP
; this procedure prints number in AX,
; used with PRINT_NUM_UNS to print signed numbers:
PRINT_NUM PROC NEAR
PUSH DX
PUSH AX
CMP AX, 0
JNZ not_zero
PUTC '0'
JMP printed
not_zero:
; the check SIGN of AX,
; make absolute if it's negative:
CMP AX, 0
JNS positive
NEG AX
PUTC '-'
positive:
CALL PRINT_NUM_UNS
printed:
POP AX
POP DX
RET
PRINT_NUM ENDP
; this procedure prints out an unsigned
; number in AX (not just a single digit)
; allowed values are from 0 to 65535 (FFFF)
PRINT_NUM_UNS PROC NEAR
PUSH AX
PUSH BX
PUSH CX
PUSH DX
; flag to prevent printing zeros before number:
MOV CX, 1
; (result of "/ 10000" is always less or equal to 9).
MOV BX, 10000 ; 2710h - divider.
; AX is zero?
CMP AX, 0
JZ print_zero
begin_print:
; check divider (if zero go to end_print):
CMP BX,0
JZ end_print
; avoid printing zeros before number:
CMP CX, 0
JE calc
; if AX<BX then result of DIV will be zero:
CMP AX, BX
JB skip
calc:
MOV CX, 0 ; set flag.
MOV DX, 0
DIV BX ; AX = DX:AX / BX (DX=remainder).
; print last digit
; AH is always ZERO, so it's ignored
ADD AL, 30h ; convert to ASCII code.
PUTC AL
MOV AX, DX ; get remainder from last div.
skip:
; calculate BX=BX/10
PUSH AX
MOV DX, 0
MOV AX, BX
DIV CS:ten ; AX = DX:AX / 10 (DX=remainder).
MOV BX, AX
POP AX
JMP begin_print
print_zero:
PUTC '0'
end_print:
POP DX
POP CX
POP BX
POP AX
RET
PRINT_NUM_UNS ENDP
ten DW 10 ; used as multiplier/divider by
SCAN_NUM & PRINT_NUM_UNS.
Output:
1. Write a program, which takes two inputs as strings and display the Concatenated string.
Code: ;session 8-1 concatenation of two strings
data segment
str1 db "computer$"
str2 db "science$"
ends
code segment
start:
; set segment registers:
mov ax, data
mov ds, ax
lea si,str2
; inputig the char in al
lea si,str1
back1:
cmp [si],'$'
je last1:
inc si
jmp back1
last1:
lea di,str2
back2:
cmp [di],'$'
je last2:
mov ax,[di]
mov [si],ax
inc si
inc di
jmp back2
last2:
; output the string stored the offset in DX
lea dx, str1
mov ah,9
int 21h
mov ax, 4c00h
int 21h
ends
end start ; set entry point and stop the assembler.
Output:
3. Write a program for reversing a given string. Code:
; session 8-3 reverse string
; multi-segment executable file template.
data segment
str1 db "-1234$"
str2 db ?
i db 0
ends
code segment
start:
; set segment registers:
mov ax, data
mov ds, ax
; lower to upper
lea di,str1
back1:
cmp [di],'$'
je last1:
inc di
jmp back1
last1:
dec di
lea si,str2
; reverse string
back2:
cmp [di],'-'
je last2:
mov ax,[di]
mov [si],ax
dec di
inc si
jmp back2
last2:
mov [si],'$'
lea dx,str2
mov ah,9
int 21h
mov ax, 4c00h
int 21h
ends
end start ; set entry point and stop the assembler.
Output:
4. Write a program, which converts string to its ASCII value and store in array. Code:
; session 8-4 convert string to ASCII
; multi-segment executable file template.
data segment
str1 dw 'F'
arr dw 4 dup(?)
i db 0
ends
code segment
start:
; set segment registers:
mov ax, data
mov ds, ax
; Convert to ascii
mov cx,5
lea di,str1
lea si,arr
back:
mov ax,[di]
Add ax,0
aaa
mov [si],ax
inc di
inc si
loop back
mov ax, 4c00h
int 21h
ends
end start ; set entry point and stop the assembler.
Output:
5. Write a program to find if two strings are equal length: and if the strings are found to be
of equivalent length then are they the same, if not the same then which string is
lexicographically greater. Code:
;session 8-5 string length comparision
data segment
str1 db "cmputer$"
str2 db "computer$"
msg1 db "not equal$"
msg2 db "equal$"
i1 db 0
i2 db 0
ends
code segment
start:
; set segment registers:
mov ax, data
mov ds, ax
lea si,str2
; inputig the char in al
lea si,str1
back1:
cmp [si],'$'
je last1:
inc si
inc i1
jmp back1
last1:
lea si,str2
back2:
cmp [si],'$'
je last2:
inc si
inc i2
jmp back2
last2:
mov al,i1
cmp al,i2
je last3
lea dx, msg1
mov ah,9
int 21h
jmp last4
last3:
lea dx, msg2
mov ah,9
int 21h
last4:
mov ax, 4c00h
int 21h
ends
end start ; set entry point and stop the assembler.
Output:
6. Write a program to determine a given string is a palindrome. If 'Yes' output the message
“The given string is a palindrome”. If 'No' output the message “No, it is not a
palindrome”. Code:
; this sample checks if string is a palindrome or not.
; palindrome is a text that can be read backwards
; and give the same meaning as if it was read forward.
; for example: "abba" is polindrome.
; note: this program is case sensitive, "abba" is not "abba".
name "pali"
org 100h
jmp start
m1:
s db 'able was ere ere saw elba'
s_size = $ - m1
db 0Dh,0Ah,'$'
start:
; first let's print it:
mov ah, 9
mov dx, offset s
int 21h
lea di, s
mov si, di
add si, s_size
dec si ; point to last char!
mov cx, s_size
cmp cx, 1
je is_palindrome ; single char is always palindrome!
shr cx, 1 ; divide by 2!
next_char:
mov al, [di]
mov bl, [si]
cmp al, bl
jne not_palindrome
inc di
dec si
loop next_char
is_palindrome:
; the string is "palindrome!"
mov ah, 9
mov dx, offset msg1
int 21h
jmp stop
not_palindrome:
; the string is "not palindrome!"
mov ah, 9
mov dx, offset msg2
int 21h
stop:
; wait for any key press:
mov ah, 0
int 16h
ret
msg1 db " this is palindrome!$"
msg2 db " this is not a palindrome!$"
Output: