Institute of Science and Technology

Department of
Electronics and Communication Engineering

LAB MANUAL

Course Title: Microprocessors & Assembly Language Lab

Course no: 530806 (New)
Course no: ECE-307 (Old)
 Prepared by:

Md. Mamun Ur Rashed

Student, Session 2018-19

Department of Electronics and Communication Engineering

E-mail: 7mamunurrashed@gmail.com

In Supervision of:

Mohammad Liton Hossain

Assistant Professor, Department of Electronics and Communication Engineering

E-mail: litu702@gmail.com
 National University of Bangladesh

Lab Report

Submitted by-
Name:
Department:
Class Roll:
Exam Roll:
Registration No.:
Session:
Course Name:
Course Code:

Department of Electronics and Communication Engineering

 List of Program

Program Page
Program Name
No. No.

01 An assembly language program to add two decimal number.

02 An assembly language program to display string.

03 An assembly language program to print 0-9.
04 An assembly language program to print 9-0.

05 An assembly language program to display 256 ASCII characters.

06 An assembly language program to input two numbers and add them.

An assembly language program to determine whether the number is

07
even or odd.
An assembly language program to convert string from lower case to
08
uppercase.
An assembly language program to convert string from upper case to
09
lower case.

10 An assembly language program to display a string in reverse order.

An assembly language program to accept a string from keyboard and

11
display the string in reverse order.
An assembly language program to add two digits if sum is greater
12
than 9.

13 An assembly language program to display two strings in new line.

14 An assembly language program to convert hexadecimal to binary.

An assembly language program to check if the input character is not a

15
number.
16 An assembly language program to print a string n time.

An assembly language program to find the smaller number between

17
two numbers.

18 An assembly language program using macro.

An assembly language program to find sum of the array using indirect

19
addressing.

20 An assembly language program to bubble sort an array.

Program No: 01
Program Name: An assembly language program to add two decimal number.
Source Code:
.MODEL SMALL
.STACK 100H
.DATA
.CODE
MAIN PROC
MOV AL,02D ;AL=2
ADD AL,03D ;AL=2+3
MOV BL,AL
MOV AH,02H ;SINGLE CHARACTER OUTPUT
MOV DL,BL
ADD DL,30H ;CONVERTING INTO DECIMAL VALUE
INT 21H ;INTERRUP CALL
MAIN ENDP
ENDP MAIN
Output:
Program No: 02
Program Name: An assembly language program to display string.
Source Code:
.MODEL SMALL
.STACK 100H
.DATA
MSG DB 'IST ADDMISSION ONGOING$' ;DB-DEFINE BYTE
;$-END OF STRING
.CODE
MAIN PROC
MOV AX,@DATA ;GET DATA SEGMENT
MOV DS,AX ;INITIALIZING DATA SEGEMENT
LEA DX,MSG ;LOAD EFFECTIVE ADDRESS OF MSG
MOV AH,9 ;OUTPUT FUNCTION FOR STRING
INT 21H
MOV AH,4CH ;TERMINATE PROGRAM AND RETURN TO DOS
INT 21H
MAIN ENDP
ENDP MAIN
Output:
Program No: 03
Program Name: An assembly language program to print 0-9.
Source Code:
.MODEL SMALL
.STACK 100H
.DATA
X DB 0D,1D,2D,3D,4D,5D,6D,7D,8D,9D
.CODE
MAIN PROC
MOV AX,@DATA ;GET DATA SEGMENT
MOV DS,AX ;INITIALIZE DS
LEA BX,X ;GET THE ARRAY OF DATA
MOV CX,10D ;INITIALIZE THE COUNTER
MOV AH,2H
D_LOOP: ;DEFINING LOOP
MOV DL,[BX]
ADD DL,30H
INT 21H
INC BX
LOOP D_LOOP ;CALL LOOP
MOV AH,4CH
INT 21H
MAIN ENDP
ENDP MAIN
Output:
Program No: 04
Program Name: An assembly language program to print 9-0.
Source Code:
.MODEL SMALL
.STACK 100H
.DATA
X DB 0D,1D,2D,3D,4D,5D,6D,7D,8D,9D
.CODE
MAIN PROC
MOV AX,@DATA ;GET DATA SEGMENT
MOV DS,AX ;INITIALIZE DS
LEA BX,X ;GET THE ARRAY OF DATA
ADD BX,10D
MOV CX,10D ;INITIALIZE THE COUNTER
MOV AH,2H
D_LOOP:
MOV DL,[BX-1]
ADD DL,30H
INT 21H
DEC BX
LOOP D_LOOP
MOV AH,4CH
INT 21H
MAIN ENDP
ENDP MAIN
Output:
Program No: 05
Program Name: An assembly language program to display 256 ASCII characters.
Source Code:
.MODEL SMALL
.STACK 100H
.DATA
PROMPT DB 'THE 256 ASCII CHARACTERS ARE : $\'
.CODE
MAIN PROC
MOV AX, @DATA ;INITIALIZE DS
MOV DS, AX
LEA DX, PROMPT ;LOAD AND PRINT PROMPT
MOV AH, 9
INT 21H
MOV CX, 256 ;INITIALIZE CX
MOV AH, 2 ;SET OUTPUT FUNCTION
MOV DL, 0 ;INITIALIZE DL WITH FIRST ASCII CHARACTER
@LOOP: ;LOOP LABEL
INT 21H ;PRINT ASCII CHARACTER
INC DL ;INCREMENT DL TO NEXT ASCII CHARACTER
DEC CX ;DECREMENT CX
JNZ @LOOP ;JUMP TO LABEL @LOOP IF CX IS 0
MOV AH, 4CH ;RETURN CONTROL TO DOS
INT 21H
MAIN ENDP
ENDP MAIN
Output:
Program No: 06
Program Name: An assembly language program to input two numbers and add them.
Source Code:
.MODEL SMALL
.STACK 100H
.DATA
MSG1 DB "ENTER THE FIRST NUMBER FROM 0 TO 5: $"
MSG2 DB 10,13,"ENTER THE SECOND NUMBER FROM 0 TO 4: $"
;10,13 MEANS NEW LINE AS SAME AS MOV DL,0AH AND MOV DL,0DH
.CODE
MAIN PROC
MOV AX,@DATA ;GET DATA SEGMENT
MOV DS,AX ;INITIALIZE DATA SEGMENT
MOV AH,9 ;OUTPUT FUNCTION FOR STRING
LEA DX,MSG1 ;LOAD EFFECTIVE ADDRESS FOR MSG1
INT 21H
MOV AH,01H ;INPUT FUNCTION
INT 21H
MOV BL,AL
INT 21H
MOV AH,9
LEA DX,MSG2
INT 21H
MOV AH,01
INT 21H
MOV CL,AL
ADD BL,CL
MOV AH,2
MOV DL,0AH ;NEWLINE
INT 21H
MOV DL, 0DH
 INT 21H
MOV AH,02
SUB BL,48
MOV DL,BL
INT 21H
MOV AH,4CH
INT 21H
MAIN ENDP
ENDP MAIN
Output:
Program No: 07
Program Name: An assembly language program to determine whether the number is even or odd.
Source Code:
.MODEL SMALL
.STACK 100H
.DATA
MSG1 DB 10,13,'ENTER A NUMBER:$'
MSG2 DB 10,13,'THIS IS AN EVEN NUMBER$'
MSG3 DB 10,13,'THIS IS AN ODD NUMBER$'
DISPLAY MACRO MSG ;DEFINING MACRO
MOV AH,9
LEA DX,MSG
INT 21H
ENDM ;END OF MACRO
.CODE
MAIN PROC
MOV AX,@DATA
MOV DS,AX
DISPLAY MSG1 ;CALL MACRO
MOV AH,1
INT 21H
MOV AH,0
MOV DL,2
DIV DL
CMP AH,0
JNE ODD
EVEN:
DISPLAY MSG2
JMP DONE
ODD:
DISPLAY MSG3
 DONE:
MOV AH,4CH
INT 21H
MAIN ENDP
ENDP MAIN
Output:
Program No: 08
Program Name: An assembly language program to convert string from lower case to uppercase.
Source Code:
.MODEL SMALL
.STACK 100H
.DATA
MSG1 DB 'PLEASE ENTER A LOWER CASE CHARACTER: $'
MSG2 DB 'THE UPPERCASE CHARACTER IS: $'
.CODE
MAIN PROC
MOV AX,@DATA ;GET DATA SEGMENT
MOV DS,AX ;INITIALIZE DATA SEGMENT
LEA DX,MSG1 ;GET FIRST MESSAGE
MOV AH,9 ;DISPLAY STRING FUNCTION
INT 21H
MOV AH,1 ;INPUT FUNCTION
INT 21H
SUB AL,20H ;CONVERT TO UPPERCASE
MOV BL,AL ;STORE THE CONVERTED VALUE
MOV AH,2
MOV DL,0DH ;CARRIAGE RETURN
INT 21H
MOV DL,0AH ;NEW LINE
INT 21H
LEA DX,MSG2 ;GET SECOND MESSAGE
MOV AH,9
INT 21H
MOV AH,2 ;SINGLE-CHARACTER OUTPUT FUNCTION
MOV DL,BL ;RETRIEVE CHARACTER AND DISPLAY IT
INT 21H
MOV AH,4CH ;DOS EXIT FUNCTION
 INT 21H
MAIN ENDP
ENDP MAIN
Output:
Program No: 09
Program Name: An assembly language program to convert string from upper case to lower case.
Source Code:
.MODEL SMALL
.STACK 100H
.DATA
MSG1 DB 'PLEASE ENTER AN UPPER CASE CHARACTER: $'
MSG2 DB 'THE LOWERCASE CHARACTER IS: $'
.CODE
MAIN PROC
MOV AX,@DATA ;GET DATA SEGMENT
MOV DS,AX ;INITIALIZE DATA SEGMENT
LEA DX,MSG1 ;GET FIRST MESSAGE
MOV AH,9 ;DISPLAY STRING FUNCTION
INT 21H
MOV AH,1 ;INPUT FUNCTION
INT 21H
ADD AL,20H ;CONVERT TO LOWERCASE
MOV BL,AL ;STORE THE CONVERTED VALUE
MOV AH,2
MOV DL,0DH ;CARRIAGE RETURN
INT 21H
MOV DL,0AH ;NEW LINE
INT 21H
LEA DX,MSG2 ;GET SECOND MESSAGE
MOV AH,9
INT 21H
MOV AH,2 ;SINGLE-CHARACTER OUTPUT FUNCTION
MOV DL,BL ;RETRIEVE CHARACTER AND DISPLAY IT
INT 21H
MOV AH,4CH ;DOS EXIT FUNCTION
 INT 21H
MAIN ENDP
ENDP MAIN
Output:
Program No: 10
Program Name: An assembly language program to display a string in reverse order.
Source Code:
.MODEL SMALL
.STACK 100H
.DATA
X DB 'IST$'
.CODE
MAIN PROC
MOV AX,@DATA ;GET DATA SEGMENT
MOV DS,AX ;INITIALIZE DS
LEA BX,X ;GET THE ARRAY OF DATA
ADD BX,02D
MOV CX,03D ;INITIALIZE THE COUNTER
MOV AH,2H
D_LOOP:
MOV DL,[BX]
INT 21H
DEC BX
LOOP D_LOOP
MOV AH,4CH
INT 21H
MAIN ENDP
ENDP MAIN
Output:
Program No: 11
Program Name: An assembly language program to accept a string from keyboard and display the
string in reverse order.
Source Code:
.MODEL SMALL
.STACK 100H
.DATA
PROMPT_1 DB 'ENTER THE STRING : $\'
PROMPT_2 DB 0DH,0AH,'THE STRING IN REVERSE ORDER IS : $\'
.CODE
MAIN PROC
MOV AX, @DATA ;INITIALIZE DS
MOV DS, AX
LEA DX, PROMPT_1 ;LOAD AND DISPLAY PROMPT_1
MOV AH, 9
INT 21H ;XOR CX, CX
MOV CX,0 ;CLEAR CX
MOV AH, 1 ;SET INPUT FUNCTION
@INPUT: ;JUMP LABEL
INT 21H ;READ A DIGIT
CMP AL, 0DH ;COMPARE DIGIT WITH CARRIAGE RETURN
JE @END ;JUMP TO LABEL @END IF CARRIAGE RETURN
PUSH AX ;PUSH THE INPUT CHAR TO STACK
INC CX ;INCREMENT CX
JMP @INPUT ;JUMP TO LABEL @INPUT
@END: ;JUMP LABEL
LEA DX, PROMPT_2 ;LOAD AND DISPLAY PROMPT_2
MOV AH, 9
INT 21H
MOV AH, 2 ;SET OUTPUT FUNCTION
@OUTPUT: ;JUMP LABEL
 POP DX ;POP A VALUE FROM STACK TO DX
INT 21H ;DISPLAY DIGIT
LOOP @OUTPUT ;JUMP TO LABEL @OUTPUT
MOV AH, 4CH ;RETURN CONTROL TO DOS
INT 21H
MAIN ENDP
END MAIN
Output:
Program No: 12
Program Name: An assembly language program to add two digits if sum is greater than 9.
Source Code:
.MODEL SMALL
.STACK 100H
.DATA
MSG1 DB "ENTER THE FIRST NUMBER: $"
MSG2 DB 10,13,"ENTER THE SECOND NUMBER: $"
MSG3 DB 10,13,"THE SUM IS:$"
.CODE
MAIN PROC
MOV AX,@DATA ;GET DATA SEGMENT
MOV DS,AX ;INITIALIZE DATA SEGMENT
MOV AH,9 ;OUTPUT FUNCTION FOR STRING
LEA DX,MSG1 ;LOAD EFFECTIVE ADDRESS FOR MSG1
INT 21H
MOV AH,01H ;INPUT FUNCTION
INT 21H
MOV BL,AL
MOV AH,9
LEA DX,MSG2
INT 21H
MOV AH,01
INT 21H
ADD AL,BL
MOV AH,0 ;TO REMOVE UNWANTED VALUES FROM AH
AAA ;ADJUST AFTER ADDITION
MOV BX,AX
ADD BL,48 ;GET THE ASCII VALUE OF THE LOWER BYTE OF THE RESULT
ADD BH,48 ;GET THE ASCII VALUE OF THE UPPER BYTE OF THE RESULT
MOV AH,9
 LEA DX,MSG3
INT 21H
MOV AH,02
MOV DL,BH ;PRINT THE UPPER BYTE OF THE RESULT
INT 21H
MOV AH,02
MOV DL,BL ;PRINT THE LOWER BYTE OF THE RESULT
INT 21H
MOV AH,4CH
INT 21H
MAIN ENDP
ENDP MAIN
Output:
Program No: 13
Program Name: An assembly language program to display two strings in new line.
Source Code:
.MODEL SMALL
.STACK 100H
.DATA
MSG DB 'HELLO!$'
MSG1 DB 10,13,'HELLO,IST!$'
.CODE
MAIN PROC
MOV AX,@DATA
MOV DS,AX
LEA DX,MSG
MOV AH,9
INT 21H
LEA DX,MSG1
MOV AH,9
INT 21H
MOV AH,4CH
INT 21H
MAIN ENDP
ENDP MAIN
Output:
Program No: 14
Program Name: An assembly language program to convert hexadecimal to binary.
Source Code:
.MODEL SMALL
.STACK 100H
.DATA
PROMPT_1 DB 'ENTER THE HEXADECIMAL NUMBER ( MAX 4-DIGIT ) : $\'
PROMPT_2 DB 0DH,0AH,'THE EQUIVALENT 16-BIT BINARY NUMBER IS : $\'
ILLEGAL DB 0DH,0AH,'ILLEGAL HEX NUMBER. TRY AGAIN : $\'
COUNT DB ?
.CODE
MAIN PROC
MOV AX, @DATA ; INITIALIZE DS
MOV DS, AX
LEA DX, PROMPT_1 ; LOAD AND DISPLAY THE STRING PROMPT_1
MOV AH,9
INT 21H
JMP @START ; JUMP TO LABEL @START_2
@START_1: ; JUMP LABEL
LEA DX, ILLEGAL ; LOAD AND DISPLAY THE STRING ILLEGAL
MOV AH, 9
INT 21H
@START:
XOR BX, BX ; CLEAR BX
MOV COUNT, 30H ; INITIALIZE LOOP COUNTER
@START_2: ; JUMP LABEL
MOV AH, 1 ; SET INPUT FUNCTION
INT 21H ; READ A CHARACTER
CMP AL, 0DH ; COMPARE AL WITH CR
JNE @SKIP ; JUMP TO LABEL @SKIP IF AL!=CR
CMP COUNT, 30H ; COMPARE COUNT WITH 0
 JBE @START_1 ; JUMP TO LABEL @START_1 IF COUNT<=0
JMP @END ; JUMP TO LABEL @END
@SKIP: ; JUMP LABEL
CMP AL, "A" ; COMPARE AL WITH \"A\"
JB @DECIMAL ; JUMP TO LABEL @DECIMAL IF AL<A
CMP AL, "F" ; COMPARE AL WITH \"F\"
JA @START_1 ; JUMP TO LABEL @START_1 IF AL>F
ADD AL, 09H ; ADD 9 TO AL
JMP @OK ; JUMP TO LABEL @OK
@DECIMAL: ; JUMP LABEL
CMP AL, 30H ; COMPARE AL WITH 0
JB @START_1 ; JUMP TO LABEL @START_1 IF AL<0
CMP AL, 39H ; COMPARE AL WITH 9
JA @START_1 ; JUMP TO LABEL @START_1 IF AL>9
@OK: ; JUMP LABEL
INC COUNT ; INCREMENT THE COUNT VARIABLE
AND AL, 0FH ; CONVERT THE ASCII INTO BINARY CODE
MOV CL, 4 ; SET CL=4
SHL AL, CL ; SHIFT AL TOWARDS LEFT BY 4 POSITIONS
MOV CX, 4 ; SET CX=4
@LOOP_1: ; LOOP LABEL
SHL AL, 1 ; SHIFT AL TOWARDS LEFT BY 1 POSITION
RCL BX, 1 ; ROTATE BX TOWARDS LEFT BY 1 POSITION
; THROUGH CARRY
LOOP @LOOP_1 ; JUMP TO LABEL @LOOP_1 IF CX!=0
CMP COUNT, 34H ; COMPARE COUNT WITH 4
JE @END ; JUMP TO LABEL @END IF COUNT=4
JMP @START_2 ; JUMP TO LABEL @START_2
@END: ; JUMP LABEL
LEA DX, PROMPT_2 ; LOAD AND DISPLAY THE STRING PROMPT_2
MOV AH, 9
 INT 21H
MOV CX, 16 ; SET CX=16
MOV AH, 2 ; SET OUTPUT FUNCTION
@LOOP_2: ; LOOP LABEL
SHL BX, 1 ; SHIFT BX TOWARDS LEFT BY 1 POSITION
JC @ONE ; JUMP TO LABEL @ONE IF CF=1
MOV DL, 30H ; SET DL=0
JMP @DISPLAY ; JUMP TO LABEL @DISPLAY
@ONE: ; JUMP LABEL
MOV DL, 31H ; SET DL=1
@DISPLAY: ; JUMP LABEL
INT 21H ; DISPLAY A CHARACTER
LOOP @LOOP_2 ; JUMP TO LABEL @LOOP_2 IF CX!=0
MOV AH, 4CH ; RETURN CONTROL TO DOS
INT 21H
MAIN ENDP
END MAIN
Output:
Program No: 15
Program Name: An assembly language program to check if the input character is not a number.
Source Code:
.MODEL SMALL
.STACK 100H
.DATA
MSG DB 10,13,'THIS IS NOT A NUMBER$'
.CODE
MAIN PROC
MOV AH,01
INT 21H
CMP AL,30H
JL EXIT
CMP AL,39H
JA EXIT
JMP DISPLAY
EXIT:
MOV AX,@DATA
MOV DS,AX
LEA DX,MSG
MOV AH,9
INT 21H
MOV AH, 4CH
INT 21H
DISPLAY:
MOV AH,2
MOV DL,AL
INT 21H
MAIN ENDP
ENDP MAIN
Output:
Program No: 16
Program Name: An assembly language program to print a string n time.
Source Code:
.MODEL SMALL
.STACK 100H
.DATA
MSG DB 'HOW MANY TIMES WOULD U LIKE TO PRINT: $'
MSG1 DB 10,13,'HELLO!$'
.CODE
MAIN PROC
MOV AX,@DATA
MOV DS,AX
LEA DX,MSG
MOV AH,9
INT 21H
MOV AH,01
INT 21H
MOV BL,AL
MOV AH,0
AAA
MOV CX,AX
LEA DX,MSG1
TOP:
MOV AH,9
INT 21H
LOOP TOP
MOV AH,4CH
INT 21H
MAIN ENDP
ENDP MAIN
Output:
Program No: 17
Program Name: An assembly language program to find the smaller number between two numbers.
Source Code:
.MODEL SMALL
.STACK 100H
.DATA
PROMPT_1 DB 'ENTER THE FIRST CHARACTER : $\'
PROMPT_2 DB 'ENTER THE SECOND CHARACTER : $\'
PROMPT_3 DB 'THE SMALLEST CHARACTER IS : $\'
.CODE
MAIN PROC
MOV AX, @DATA ; INITIALIZE DS
MOV DS, AX
LEA DX, PROMPT_1 ; LOAD AND PRINT PROMPT_1
MOV AH, 9
INT 21H
MOV AH, 1 ; READ A CHARACTER
INT 21H
MOV BL, AL ; SAVE THE INPUT CHARACTER INTO BL
MOV AH, 2 ; CARRIAGE RETURN
MOV DL, 0DH
INT 21H
MOV DL, 0AH ; LINE FEED
INT 21H
LEA DX, PROMPT_2 ; LOAD AND PRINT PROMPT_2
MOV AH, 9
INT 21H
MOV AH, 1 ; READ A CHARACTER
INT 21H
MOV BH, AL ; SAVE THE INPUT CHARACTER INTO BH
MOV AH, 2 ; CARRIAGE RETURN
 MOV DL, 0DH
INT 21H
MOV DL, 0AH ; LINE FEED
INT 21H
LEA DX, PROMPT_3 ; LOAD AND PRINT PROMPT_3
MOV AH, 9
INT 21H
CMP BL, BH ; COMPARE THE BL AND BH
JNBE @ELSE ; JUMP TO LABEL @ELSE IF BL>BH
MOV DL, BL ; MOVE FIRST CHARACTER INTO DL
JMP @DISPLAY ; JUMP TO LABEL @DISPLAY
@ELSE: ; JUMP LABEL
MOV DL, BH ; MOVE SECOND CHARACTER INTO DL
@DISPLAY: ; JUMP LABEL
MOV AH, 2 ; PRINT THE CHARACTER
INT 21H
MOV AH, 4CH ; RETURN CONTROL TO DOS
INT 21H
MAIN ENDP
END MAIN
Output:
Program No: 18
Program Name: An assembly language program using macro.
Source Code:
.MODEL SMALL
.STACK 100H
.DATA
MSG1 DB 'THIS PROGRAM IS DONE BY USING MACRO$'
DISPLAY MACRO MSG1 ;DEFINING MACRO
PUSH AX
PUSH DX
LEA DX,MSG1
MOV AH, 09H
INT 21H
POP DX
POP AX
ENDM
.CODE
MAIN PROC
MOV AX, @DATA
MOV DS, AX
DISPLAY MSG1
MOV AH, 4CH
INT 21H
MAIN ENDP
END MAIN
Output:
Program No: 19
Program Name: An assembly language program to find sum of the array using indirect addressing.
Source Code:
.MODEL SMALL
.STACK 100H
.DATA
PROMPT DB 'THE ARRAY ELEMENTS ARE : $\'
RESULT DB 0DH,0AH,'THE SUM OF THE ARRAY IS = $\'
ARRAY DB 10,20,30,40,50,60,70,80,90,100
.CODE
MAIN PROC
MOV AX, @DATA ; INITIALIZE DS
MOV DS, AX
MOV BX, 10 ; SET BX=10
LEA DX, PROMPT ; LOAD AND DISPLAY THE STRING PROMPT
MOV AH, 9
INT 21H
MOV CX, BX ; SET CX=BX
LEA SI, ARRAY ; SET SI=OFFSET ADDRESS OF ARRAY
@LOOP: ; LOOP LABEL
XOR AH, AH ; CLEAR AH
MOV AL, [SI] ; SET AX=[SI]
CALL OUTDEC ; CALL THE PROCEDURE OUTDEC
INC SI ; SET SI=SI+1
MOV AH, 2 ; SET OUTPUT FUNCTION
MOV DL, 20H ; SET DL=20H
INT 21H ; PRINT A CHARACTER
LOOP @LOOP ; JUMP TO LABEL @LOOP WHILE CX!=0
LEA DX, RESULT ; LOAD AND DISPLAY THE STRING RESULT
MOV AH, 9
INT 21H
 LEA SI, ARRAY ; SET SI=OFFSET ADDRESS OF ARRAY
CALL SUM ; CALL THE PROCEDURE SUM
CALL OUTDEC ; CALL THE PROCEDURE OUTDEC
MOV AH, 4CH ; RETURN CONTROL TO DOS
INT 21H
MAIN ENDP

;------------------------- PROCEDURE DEFINITIONS ------------------------;

;--------------------------------- SUM ----------------------------------;

SUM PROC
; THIS PROCEDURE WILL CALCULATE THE SUM OF AN ARRAY
; INPUT : SI=OFFSET ADDRESS OF THE ARRAY
; : BX=SIZE OF THE ARRAY
; OUTPUT : AX=SUM OF THE ARRAY
PUSH CX ; PUSH CX ONTO THE STACK
PUSH DX ; PUSH DX ONTO THE STACK
XOR AX, AX ; CLEAR AX
XOR DX, DX ; CLEAR DX
MOV CX, BX ; SET CX=BX
@SUM: ; LOOP LABEL
MOV DL, [SI] ; SET DL=[SI]
ADD AX, DX ; SET AX=AX+DX
INC SI ; SET SI=SI+1
LOOP @SUM ; JUMP TO LABEL @SUM WHILE CX!=0
POP DX ; POP A VALUE FROM STACK INTO DX
POP CX ; POP A VALUE FROM STACK INTO CX
RET ; RETURN CONTROL TO THE CALLING PROCEDURE
SUM ENDP
;-------------------------------- OUTDEC --------------------------------;

OUTDEC PROC
; THIS PROCEDURE WILL DISPLAY A DECIMAL NUMBER
; INPUT : AX
; OUTPUT : NONE
PUSH BX ; PUSH BX ONTO THE STACK
PUSH CX ; PUSH CX ONTO THE STACK
PUSH DX ; PUSH DX ONTO THE STACK
CMP AX, 0 ; COMPARE AX WITH 0
JGE @START ; JUMP TO LABEL @START IF AX>=0
PUSH AX ; PUSH AX ONTO THE STACK
MOV AH, 2 ; SET OUTPUT FUNCTION
MOV DL, ' ' ; SET DL=\'-\'
INT 21H ; PRINT THE CHARACTER
POP AX ; POP A VALUE FROM STACK INTO AX
NEG AX ; TAKE 2\'S COMPLEMENT OF AX
@START: ; JUMP LABEL
XOR CX, CX ; CLEAR CX
MOV BX, 10 ; SET BX=10
@OUTPUT: ; LOOP LABEL
XOR DX, DX ; CLEAR DX
DIV BX ; DIVIDE AX BY BX
PUSH DX ; PUSH DX ONTO THE STACK
INC CX ; INCREMENT CX
OR AX, AX ; TAKE OR OF AX WITH AX
JNE @OUTPUT ; JUMP TO LABEL @OUTPUT IF ZF=0
MOV AH, 2 ; SET OUTPUT FUNCTION
@DISPLAY: ; LOOP LABEL
POP DX ; POP A VALUE FROM STACK TO DX
OR DL, 30H ; CONVERT DECIMAL TO ASCII CODE
 INT 21H ; PRINT A CHARACTER
LOOP @DISPLAY ; JUMP TO LABEL @DISPLAY IF CX!=0
POP DX ; POP A VALUE FROM STACK INTO DX
POP CX ; POP A VALUE FROM STACK INTO CX
POP BX ; POP A VALUE FROM STACK INTO BX
RET ; RETURN CONTROL TO THE CALLING PROCEDURE
OUTDEC ENDP
ENDP MAIN
Output:
Program No: 20
Program Name: An assembly language program to bubble sort an array.
Source Code:
.MODEL SMALL
.STACK 100H
.DATA
PROMPT_1 DB 'THE CONTENTS OF THE ARRAY BEFORE SORTING : $\'
PROMPT_2 DB 0DH,0AH,'THE CONTENTS OF THE ARRAY AFTER SORTING : $\'
ARRAY DB 5,3,9,0,2,6,1,7,8,4
.CODE
MAIN PROC
MOV AX, @DATA ; INITIALIZE DS
MOV DS, AX
MOV BX, 10 ; SET BX=10
LEA DX, PROMPT_1 ; LOAD AND DISPLAY THE STRING PROMPT_1
MOV AH, 9
INT 21H
LEA SI, ARRAY ; SET SI=OFFSET ADDRESS OF ARRAY
CALL PRINT_ARRAY ; CALL THE PROCEDURE PRINT_ARRAY
LEA SI, ARRAY ; SET SI=OFFSET ADDRESS OF THE ARRAY
CALL BUBBLE_SORT ; CALL THE PROCEDURE BUBBLE_SORT
LEA DX, PROMPT_2 ; LOAD AND DISPLAY THE STRING PROMPT_2
MOV AH, 9
INT 21H
LEA SI, ARRAY ; SET SI=OFFSET ADDRESS OF ARRAY
CALL PRINT_ARRAY ; CALL THE PROCEDURE PRINT_ARRAY
MOV AH, 4CH ; RETURN CONTROL TO DOS
INT 21H
MAIN ENDP

;------------------------- PROCEDURE DEFINITIONS ------------------------;

;----------------------------- PRINT_ARRAY ------------------------------;

PRINT_ARRAY PROC
; THIS PROCEDURE WILL PRINT THE ELEMENTS OF A GIVEN ARRAY
; INPUT : SI=OFFSET ADDRESS OF THE ARRAY
; : BX=SIZE OF THE ARRAY
; OUTPUT : NONE
PUSH AX ; PUSH AX ONTO THE STACK
PUSH CX ; PUSH CX ONTO THE STACK
PUSH DX ; PUSH DX ONTO THE STACK
MOV CX, BX ; SET CX=BX
@PRINT_ARRAY: ; LOOP LABEL
XOR AH, AH ; CLEAR AH
MOV AL, [SI] ; SET AL=[SI]
CALL OUTDEC ; CALL THE PROCEDURE OUTDEC
MOV AH, 2 ; SET OUTPUT FUNCTION
MOV DL, 20H ; SET DL=20H
INT 21H ; PRINT A CHARACTER
INC SI ; SET SI=SI+1
LOOP @PRINT_ARRAY ; JUMP TO LABEL @PRINT_ARRAY WHILE CX!=0
POP DX ; POP A VALUE FROM STACK INTO DX
POP CX ; POP A VALUE FROM STACK INTO CX
POP AX ; POP A VALUE FROM STACK INTO AX
RET ; RETURN CONTROL TO THE CALLING PROCEDURE
PRINT_ARRAY ENDP

;---------------------------- BUBBLE_SORT -------------------------------;

BUBBLE_SORT PROC
; THIS PROCEDURE WILL SORT THE ARRAY IN ASCENDING ORDER
; INPUT : SI=OFFSET ADDRESS OF THE ARRAY
; : BX=ARRAY SIZE
; OUTPUT : NONE
PUSH AX ; PUSH AX ONTO THE STACK
PUSH BX ; PUSH BX ONTO THE STACK
PUSH CX ; PUSH CX ONTO THE STACK
PUSH DX ; PUSH DX ONTO THE STACK
PUSH DI ; PUSH DI ONTO THE STACK
MOV AX, SI ; SET AX=SI
MOV CX, BX ; SET CX=BX
DEC CX ; SET CX=CX-1
@OUTER_LOOP: ; LOOP LABEL
MOV BX, CX ; SET BX=CX
MOV SI, AX ; SET SI=AX
MOV DI, AX ; SET DI=AX
INC DI ; SET DI=DI+1
@INNER_LOOP: ; LOOP LABEL
MOV DL, [SI] ; SET DL=[SI]
CMP DL, [DI] ; COMPARE DL WITH [DI]
JNG @SKIP_EXCHANGE ; JUMP TO LABEL @SKIP_EXCHANGE IF DL<[DI]
XCHG DL, [DI] ; SET DL=[DI], [DI]=DL
MOV [SI], DL ; SET [SI]=DL
@SKIP_EXCHANGE: ; JUMP LABEL
INC SI ; SET SI=SI+1
INC DI ; SET DI=DI+1
DEC BX ; SET BX=BX-1
JNZ @INNER_LOOP ; JUMP TO LABEL @INNER_LOOP IF BX!=0
LOOP @OUTER_LOOP ; JUMP TO LABEL @OUTER_LOOP WHILE CX!=0
POP DI ; POP A VALUE FROM STACK INTO DI
POP DX ; POP A VALUE FROM STACK INTO DX
POP CX ; POP A VALUE FROM STACK INTO CX
 POP BX ; POP A VALUE FROM STACK INTO BX
POP AX ; POP A VALUE FROM STACK INTO AX
RET ; RETURN CONTROL TO THE CALLING PROCEDURE
BUBBLE_SORT ENDP

;-------------------------------- OUTDEC --------------------------------;

OUTDEC PROC
; THIS PROCEDURE WILL DISPLAY A DECIMAL NUMBER
; INPUT : AX
; OUTPUT : NONE
PUSH BX ; PUSH BX ONTO THE STACK
PUSH CX ; PUSH CX ONTO THE STACK
PUSH DX ; PUSH DX ONTO THE STACK
XOR CX, CX ; CLEAR CX
MOV BX, 10 ; SET BX=10
@OUTPUT: ; LOOP LABEL
XOR DX, DX ; CLEAR DX
DIV BX ; DIVIDE AX BY BX
PUSH DX ; PUSH DX ONTO THE STACK
INC CX ; INCREMENT CX
OR AX, AX ; TAKE OR OF AX WITH AX
JNE @OUTPUT ; JUMP TO LABEL @OUTPUT IF ZF=0
MOV AH, 2 ; SET OUTPUT FUNCTION
@DISPLAY: ; LOOP LABEL
POP DX ; POP A VALUE FROM STACK TO DX
OR DL, 30H ; CONVERT DECIMAL TO ASCII CODE
INT 21H ; PRINT A CHARACTER
LOOP @DISPLAY ; JUMP TO LABEL @DISPLAY IF CX!=0
POP DX ; POP A VALUE FROM STACK INTO DX
POP CX ; POP A VALUE FROM STACK INTO CX
 POP BX ; POP A VALUE FROM STACK INTO BX
RET ; RETURN CONTROL TO THE CALLING PROCEDURE
OUTDEC ENDP
ENDP MAIN
Output: