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


ends

stack segment

dw 128 dup(0)

ends

code segment

start:


mov ax, data

mov ds, ax

mov es, ax


mov ah, 1 ;read from user

int 21h

mov ah, 2 ; write on screen

mov dl,al

int 21h


mov ah, 1

int 21h


int 21h

ends


Output:

3. Develop and execute a program to read 10 chars from console

Code: include 'emu8086.inc'


data segment


var db ?

ends

stack segment

dw 128 dup(0)

ends

code segment

start:


mov ax, data

mov ds, ax

mov es, ax

mov cx,10


back:

mov ah, 1

int 21h

loop back

; output string at ds:dx


mov ah, 1

int 21h


int 21h

ends


Output:

4. Write a program to exchange two memory variables using MOV and XCHG instruction.

Can you do it with just XCHG?


data segment


var1 dw 1

var2 dw 2

ends

stack segment

dw 128 dup(0)

ends

code segment

start:


mov ax, data

mov ds, ax

mov es, ax


mov ax,var1

mov bx,var2

xchg ax,bx


mov ah, 1

int 21h


int 21h

ends


Output:

5. Write a program to find the sum of two BCD numbers stored in memory.

Code:


data segment


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:


mov ax, data

mov ds, ax

mov es, ax


mov ax,varb1 ;BCD No

add ax,varb2

mov varb3,ax

mov ax,varb1 ; hexadecimal equivalent

add ax,varb2

mov varb3,ax


mov ah, 1

int 21h


int 21h

ends


Output:

6. Write a program, which will read two decimal numbers, then multiply them together,

and finally print out the result (in decimal).


data segment


var db ?

ends

stack segment

dw 128 dup(0)

ends

code segment

start:


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


mov ah, 1

int 21h


int 21h

ends


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.


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.


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:


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


Output:

3. Write a program for reversing a given string. Code:

; session 8-3 reverse string


data segment

str1 db "-1234$"

str2 db ?

i db 0

ends

code segment

start:


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


Output:

4. Write a program, which converts string to its ASCII value and store in array. Code:

; session 8-4 convert string to ASCII


data segment

str1 dw 'F'

arr dw 4 dup(?)

i db 0

ends

code segment

start:


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


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:


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


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:

assebly lab print

Documents