String Instructions

In assembly there are some very useful instructions for dealing with strings. Here is a list of the instructions and the syntax for using them:

MOV* Move String: moves byte, word or double word at DS:SI to ES:DI

movsb 	; move byte
movsw 	; move word
movsd 	; move double word
CMPS* Compare string: compares byte, word or double word at DS:SI to ES:DI
cmpsb 	; compare byte
cmpsw 	; compare word
cmpsd 	; compare double word
Note: This instruction is normally used with the REP prefix.

SCAS* Search string: search for AL, AX, or EAX in string at ES:DI

scasb 	; search for AL
scasw 	; search for AX
scasd 	; search for EAX
Note: This instruction is usually used with the REPZ or REPNZ prefix.

REP Prefix for string instruction repeats instruction CX times

rep StringInstruction
STOS* Move byte, word or double word from AL, AX or EAX to ES:DI
stosb 	; move AL into ES:DI
stosw 	; move AX into ES:DI
stosd 	; move EAX into ES:DI
LODS* Move byte, word or double word from DS:SI to AL, AX or EAX
lodsb 	; move ES:DI into AL
lodsw 	; move ES:DI into AX
lodsd 	; move ES:DI into EAX
The next example demonstrates how to use these instructions.
Listing 11: STRINGS.ASM

.model small

mov ax,@data 		; ax points to of data segment
mov ds,ax 		; put it into ds
mov es,ax 		; put it in es too
mov ah,9 		; function 9 - display string
mov dx,OFFSET Message1 	; ds:dx points to message
int 21h 		; call dos function

cld 			; clear direction flag
mov si,OFFSET String1 	; make ds:si point to String1
mov di,OFFSET String2 	; make es:di point to String2
mov cx,18 		; length of strings
rep movsb 		; copy string1 into string2

mov ah,9 		; function 9 - display string
mov dx,OFFSET Message2 	; ds:dx points to message
int 21h 		; call dos function

mov dx,OFFSET String1 	; display String1
int 21h 		; call DOS service

mov dx,OFFSET Message3 	; ds:dx points to message
int 21h 		; call dos function

mov dx,OFFSET String2 	; display String2
int 21h 		; call DOS service

mov si,OFFSET Diff1 	; make ds:si point to Diff1 
mov di,OFFSET Diff2 	; make es:di point to Diff2 
mov cx,39 		; length of strings
repz cmpsb 		; compare strings
jnz Not_Equal 		; jump if they are not the same

mov ah,9 		; function 9 - display string
mov dx,OFFSET Message4 	; ds:dx points to message
int 21h 		; call dos function

jmp Next_Operation

mov ah,9 		; function 9 - display string
mov dx,OFFSET Message5  ; ds:dx points to message
int 21h 		; call dos function

mov di,OFFSET SearchString 	; make es:di point to string
mov cx,36 		; length of string
mov al,'H' 		; character to search for
repne scasb 		; find first match
jnz Not_Found

mov ah,9 		; function 9 - display string
mov dx,OFFSET Message6 	; ds:dx points to message
int 21h 		; call dos function
jmp Lodsb_Example

mov ah,9 		; function 9 - display string
mov dx,OFFSET Message7 	; ds:dx points to message
int 21h 		; call dos function

mov ah,9 		; function 9 - display string
mov dx,OFFSET NewLine 	; ds:dx points to message
int 21h 		; call dos function

mov cx,17 		; length of string
mov si,OFFSET Message 	; DS:SI - address of string
xor bh,bh 		; video page - 0
mov ah,0Eh 		; function 0Eh - write character

lodsb 			; AL = next character in string
int 10h 		; call BIOS service
loop NextChar

mov ax,4C00h 		; return to DOS
int 21h 

CR equ 13
LF equ 10
NewLine db CR,LF,"$"

String1  db "This is a string!$"
String2  db 18 dup(0)
Diff1    db "This string is nearly the same as Diff2$"
Diff2    db "This string is nearly the same as Diff1$"
Equal1   db "The strings are equal$"
Equal2   db "The strings are not equal$"
Message  db "This is a message"
SearchString db "1293ijdkfjiu938uHello983fjkfjsi98934$"

Message1 db "Using String instructions example program.$"
Message2 db CR,LF,"String1 is now: $"
Message3 db CR,LF,"String2 is now: $"
Message4 db CR,LF,"Strings are equal!$"
Message5 db CR,LF,"Strings are not equal!$"
Message6 db CR,LF,"Character was found.$"
Message7 db CR,LF,"Character was not found.$"


How to find out the DOS Version

In many programs it is necessary to find out what the DOS version is. This could be because you are using a DOS function that needs the revision to be over a certain level.

Firstly this method simply finds out what the version is.

mov ah,30h 	; function 30h - get MS-DOS version
int 21h 	; call DOS function
This function returns the major version number in AL and the minor version number in AH. For example if it was version 4.01, AL would be 4 and AH would be 01. The problem is that if on DOS 5 and higher

SETVER can change the version that is returned. The way to get round this is to use this method.

mov ah,33h ; function 33h - actual DOS version mov al,06h ; subfunction 06h int 21h ; call interrupt 21h
This will only work on DOS version 5 and above so you need to check using the former method. This will return the actual version of DOS even if SETVER has changed the version. This returns the major version in BL and the minor version in BH.

Multiple Pushes and Pops

You can push and pop more than one register on a line in TASM and A86. This makes your code easier to understand.
push ax bx cx dx 	; save registers
pop dx cx bx ax 	; restore registers
When TASM (or A86) compiles these lines it translates it into separate pushes an pops. This way just saves you time typing and makes it easier to understand.

Note: To make these lines compile in A86 you need to put commas (,) in between the registers.

The PUSHA/PUSHAD and POPA/POPAD Instructions

PUSHA is a useful instruction that pushes all general purpose registers onto the stack. It accomplishes the same as the following:
temp = SP
push ax
push cx
push dx
push bx
push temp
push bp
push si
push di
The main advantage is that it is less typing, a smaller instruction and it is a lot faster. POPA does the reverse and pops these registers off the stack. PUSHAD and POPAD do the same but with the 32-bit registers ESP, EAX, ECX, EDX, EBX, EBP, ESI and EDI.

Using Shifts for faster Multiplication and Division

Using MUL's and DIV's is very slow and should be only used when speed is not needed. For faster multiplication and division you can shift numbers left or right one or more binary positions. Each shift is to a power of 2. This is the same as the << and >> operators in C.

There are four different ways of shifting numbers either left or right one binary position.

SHL Unsigned multiple by two
SHR Unsigned divide by two
SAR Signed divide by two
SAL same as SHL

The syntax for all four is the same:

SHL operand1,operand2
Note: The 8086 cannot have the value of opperand2 other than 1. The 286/386 cannot have operand2 higher than 31.


Using Loop is a better way of making a loop then using JMP's. You place the amount of times you want it to loop in the CX register and every time it reaches the loop statement it decrements CX (CX-1) and then does a short jump to the label indicated. A short jump means that it can only 128 bytes before or 127 bytes after the LOOP instruction.


mov cx,100 	; 100 times to loop
Loop Label: 	; decrement CX and loop to Label
This is exactly the same as the following piece of code without using loop:
mov cx,100 	; 100 times to loop

dec cx 		; CX = CX-1
jnz Label 	; continue until done
Which do you think is easier to understand? Using DEC/JNZ is faster on 486's and above and it is useful as you don't have to use CX.

This works because JNZ will jump if the zero flag has not been set. Setting CX to 0 will set this flag.

How to use a debugger

This is a good time to use a debugger to find out what your program is actually doing. I am going to demonstrate how to use Turbo Debugger to check what the program is actually doing. First we need a program which we can look at.
Listing 12: DEBUG.ASM

; example program to demonstrate how to use a debugger

.model tiny 
org 100h

push ax 	; save value of ax
push bx 	; save value of bx
push cx 	; save value of cx

mov ax,10 	; first parameter is 10 
mov bx,20 	; second parameter is 20
mov cx,3 	; third parameter is 3

Call ChangeNumbers 	

pop cx 		; restore cx
pop bx 		; restore bx
pop ax 		; restore dx

mov ax,4C00h 	; exit to dos
int 21h 

ChangeNumbers PROC 

add ax,bx 	; adds number in bx to ax
mul cx 		; multiply ax by cx
mov dx,ax 	; return answer in dx
ChangeNumbers ENDP 

end start
Now compile it to a .COM file and then type:
td name of file
Turbo Debugger then loads. You can see the instructions that make up your program.

For example the first few lines of this program is shown as:

cs:0000 50 	push ax
cs:0001 53 	push bx
cs:0002 51 	push cx
Some useful keys for Turbo Debugger:
F5 	Size Window
F7 	Next Instruction
F9 	Run
ALT F4 	Step Backwards
The numbers that are moved into the registers are different that the ones that in the source code because they are represented in their hex form (base 16) as this is the easiest base to convert to and from binary and that it is easier to understand than binary also.

At the left of this display there is a box showing the contents of the registers. At this time all the main registers are empty. Now press F7 this means that the first line of the program is run. As the first line pushed the AX register into the stack, you can see that the stack pointer (SP) has changed. Press F7 until the line which contains mov ax,000A is highlighted. Now press it again.

Now if you look at the box which contains the contents of the registers you can see that AX contains A. Press it again and BX now contains 14, press it again and CX contains 3. Now if you press F7 again you can see that AX now contains 1E which is A+14. Press it again and now AX contains 5A, 1E multiplied by 3. Press F7 again and you will see that DX now also contains 5A. Press it three more times and you can see that CX, BX and AX are all set back to their original values of zero.