汇编代码.txt

一个汇编语言学习的代码,包括学习,研究

      mov dl,13
      int 21h
      mov dl,10
      int 21h

      mov dl,bh      ;顺序输出al(bh),bl,cl中的内容
      int 21h
      mov dl,bl
      int 21h
      mov dl,cl
      int 21h

      mov ah,4ch     ;控制权交还DOS
      int 21h
code ends
end main
 5.4 设变量int1和int2的定义如下：
int1 db '935797238'
int2 db '843758912'
编写程序把int1和int2中以字符串形式存放的两个长整数相加，结果仍然以同样的形式放回变量int1中。

data segment
int1 db '935797238','$'
int2 db '843758912','$'
crlf db 13,10,'$'
data ends

code segment
assume cs:code,ds:data
main: mov ax,data
　　　mov ds,ax

　　　mov ah,9　　　;输出长整数int1
　　　lea dx,int1
　　　int 21h
　　　lea dx,crlf　 ;回车换行
　　　int 21h
　　　lea dx,int2　 ;输出长整数int2
　　　int 21h
　　　lea dx,crlf　 ;回车换行
　　　int 21h

　　　lea si,int1+8　　;将si指向int1的最低位
　　　lea di,int2+8　　;将di指向int2的最低位
　　　mov bl,0　　　　 ;bl用于记载对应位相加位的进位,初始值为0
　　　mov cx,9
lab1: mov al,[di]　　　;取int2中的对应位
　　　sub al,30h　　　 ;将字符转换为序号
　　　add [si],al　　　;加到int1的对应位上
　　　add [si],bl　　　;再加前一次的进位bl,相加后可能字符大于'9',做如下处理：

　　　mov bl,0　　　　 ;预置进位bl为0
　　　cmp byte ptr [si],'9'　　　;如果int1中对应位大于'9',则减10后,并重新对进位bl赋值为1.
　　　jbe lab2
　　　sub byte ptr [si],10
　　　mov bl,1
lab2: dec si　　　　　 ;指针后移并循环
　　　dec di
　　　loop lab1 

　　　cmp bl,0　　　　 ;求得结果后,先处理进位bl,若为1输出,为0不输出.
　　　jz lab3
　　　mov ah,2
　　　mov dl,bl
　　　add dl,30h
　　　int 21h

lab3: mov ah,9　　　　 ;输出int1
　　　lea dx,int1
　　　int 21h

　　　mov ah,4ch
　　　int 21h
code ends
end main

5.5 编写完整程序，从键盘读入一个符号串，把各符号颠倒顺序后输出．
data segment
buf db 80,81 dup(0)
data ends

code segment
assume cs:code,ds:data
main: mov ax,data
　　　mov ds,ax

　　　mov ah,10　　　　　　;输入字符串到buf
　　　lea dx,buf
　　　int 21h

　　　mov bl,[buf+1]　　　 ;求字符串长度保存到bx中
　　　mov bh,0
　　　lea si,[buf+2]　　　 ;将si指向串首,di指向串尾
　　　lea di,[buf+bx+1]

lab1: cmp si,di　　　　　　;循环,如果si<di,交换si和di指向的字符,si>=di则退出循环
　　　jge lab2
　　　mov cl,[si]
　　　xchg [di],cl
　　　mov [si],cl
　　　inc si
　　　dec di
　　　jmp lab1

lab2: mov ah,9　　　　　　;输出结果
　　　lea dx,[buf+1]
　　　mov byte ptr [buf+1],10
　　　mov byte ptr [buf+bx+2],'$'
　　　int 21h

　　　mov ah,4ch
　　　int 21h
code ends
end main

5.6 设变量k中存放了由100个有符号整数组成的数组，编写程序段找出其中最大的一个，放到AX中．（注意：编程时只用于10个数）

data segment
k dw 123,425,0,-38,56,-76,19,28,25,-4
data ends

code segment
assume cs:code,ds:data
main: mov ax,data
　　　mov ds,ax

　　　mov ax,[k]　　　　;将第一个数放到ax中
　　　mov bx,0　　　　　;bx作为地址增量
　　　mov cx,10　　　　 ;循环10次
lab1: cmp ax,[k+bx]　　 ;若整数>ax,则ax重新赋值
　　　jg lab2
　　　mov ax,[k+bx]
lab2: add bx,2
　　　loop lab1

　　　stc　　　　　　　 ;调用write子程序输出ax中的整数
　　　call write

　　　mov ah,4ch
　　　int 21h
　　　include write.asm
code ends
end main

5.7 对5.6题中的变量k，编写程序段找出其中第几个数是0，把结果放在DI中，若整个数组中没有0，则在DI中放-1表示．
data segment
k dw 123,425,0,-38,56,-76,19,28,25,-4
data ends

code segment
assume cs:code,ds:data
main: mov ax,data
　　　mov ds,ax

　　　mov bx,0
　　　mov cx,10
lab1: cmp word ptr [k+bx],0
　　　je lab2
　　　add bx,2
　　　loop lab1

lab2: cmp cx,0
　　　jne lab3
　　　mov di,-1
　　　jmp lab4
lab3: add bx,2
　　　shr bx,1
　　　mov di,bx

lab4: stc
　　　mov ax,di
　　　call write

　　　mov ah,4ch
　　　int 21h
include write.asm
code ends
end main

5.8 从键盘读入两个英文单词，按字典顺序输出．（略）
5.9 把输入的一个符号串中的空格删掉，存入另一个变量中，然后输出处理后的结果．

data segment
buf1 db 80,81 dup(0)
buf2 db 80,81 dup(0)
cr db 13,10,'$'
data ends

code segment
assume cs:code,ds:data
main: mov ax,data
　　　mov ds,ax

　　　mov ah,10
　　　lea dx,buf1
　　　int 21h

　　　mov cl,[buf1+1]
　　　mov ch,0
　　　lea si,buf1+2
　　　lea di,buf2

lab1: cmp byte ptr [si],' '
　　　je lab2
　　　mov bl,[si]
　　　mov [di],bl
　　　inc di
lab2: inc si
　　　loop lab1

　　　mov byte ptr [di],'$'
　　　mov ah,9
　　　lea dx,cr
　　　int 21h
　　　lea dx,[buf2]
　　　int 21h

　　　mov ah,4ch
　　　int 21h
code ends
end main

5.11 编写一个向用户提供字符的ASCII的程序，对用户输入的一个字符，以十六进制显示相应的ASCII值，要求输入和输出的形式如下：
THE ASCII CODE OF A IS 41H
其中的下划线表示用户输入的字符。当用户输入回车键时，程序结果。

data segment
buf1 db 'The Ascii Code of $'
buf2 db ' Is $'
cr db 13,10,'$'
data ends

code segment
assume cs:code,ds:data
main: mov ax,data
　　　mov ds,ax

lab1: mov ah,9
　　　lea dx,buf1
　　　int 21h

　　　mov ah,1
　　　int 21h
　　　cmp al,13
　　　je lab5
　　　mov bl,al
　　　mov ah,9
　　　lea dx,buf2
　　　int 21h

　　　mov si,1　　　;si为计数器
lab2: mov al,bl
　　　mov bl,10h　　;准备乘数bl=16
　　　mul bl　　　　;相乘的积在ax中
　　　mov bl,al　　 ;低位al暂存到bl中，后续程序输出高位ah

　　　mov dl,ah　　 ;利用dl计算,再进行输出
　　　cmp dl,9　　　;乘以16后，高位可能小于等于9，或大于9
　　　ja lab3
　　　add dl,30h　　;小于9加30h转成数字字符的ascii码
　　　jmp lab4
lab3: sub dl,10　　 ;大于9转成字母的ascii码
　　　add dl,'A'
lab4: mov ah,2　　　;输出字符
　　　int 21h

　　　inc si　　　　;计数器加1
　　　cmp si,2
　　　jbe lab2　　　;比较后若小于等于2跳转，准备下一位的输出

　　　mov ah,2
　　　mov dl,'H'
　　　int 21h

　　　mov ah,9 
　　　lea dx,cr
　　　int 21h

　　　jmp lab1

lab5: mov ah,4ch
　　　int 21h
code ends
end main
 
6.4 利用子程序read和write，编写完整程序，对输入的两个整数比较大小，输出其中大的一个。

data segment　　　　　　　　　;数据段
msg0 db 'Input error!$'
msg1 db 'Input number1:$'
msg2 db 'Input number2:$'
data ends

sseg segment stack　　　　　　;堆栈段
dw 64 dup(0)
sseg ends

code segment　　　　　　　　　;代码段
assume cs:code,ds:data,ss:sseg

max proc near　　　　　　　　 ;子程序"求两个数的大数"
　　　push bp　　　　　　　　 ;入口参数:堆栈中存放两个数
　　　mov bp,sp　　　　　　　 ;出口参数:大数在ax中
　　　mov ax,word ptr [bp+6]
　　　cmp ax,word ptr [bp+4]
　　　jge mlab
　　　mov ax,word ptr [bp+4]
mlab: pop bp
　　　ret
max endp

main: mov ax,data
　　　mov ds,ax

　　　mov ah,9　　　　　　　　;读取第一个数放在bx中
　　　lea dx,msg1
　　　int 21h
　　　clc
　　　call read
　　　jc err
　　　mov bx,ax

　　　mov ah,9　　　　　　　　;读取第二数放在ax中
　　　lea dx,msg2
　　　int 21h
　　　clc
　　　call read
　　　jc err

　　　push bx　　　　　　　　 ;将两个数压入椎栈并调用子程序求两数
　　　push ax
　　　call max

　　　stc　　　　　　　　　　 ;子程序结果在ax中,输出结果.
　　　call write

　　　pop ax　　　　　　　　　;弹出栈中的两个数
　　　pop bx

　　　jmp labe
err:　mov ah,9　　　　　　　　;输入数据有错时的提示
　　　lea dx,msg0
　　　int 21h

labe: mov ah,4ch
　　　int 21h
　　　include read.asm
　　　include write.asm
code ends
end main

6.5 编写排序子程序sort，以ds、si和cx作为入口参数，把ds:si为起始地址的一个带符号的字型数组进行由小到大排序，参数cx中存放的是数组中元素个数。

data segment　　　　　　　;数据段
buf dw 55,21,65,-21,0,32,123,-43,-23,11
msg1 db 'before sort:$'
msg2 db 'sorted:$'
data ends

sseg segment stack　　　　;堆栈段
dw 64 dup(0)
sseg ends

code segment　　　　　　　;代码段
assume cs:code,ds:data,ss:sseg

sort proc near　　　　　　;排序子程序
　　　push ax　　　　　　 ;保护现场
　　　push bx
　　　push dx
　　　push ds

　　　cmp cx,0　　　　　　;若cx小于或等于0，即没有任何数据，输出错误提示。
　　　jg sor0
　　　push cs
　　　pop ds
　　　lea dx,err1
　　　mov ah,9
　　　int 21h
　　　jmp sor4

sor0: dec cx　　　　　　　;冒泡排序。cx减1设置外循环次数，若为0，表明只有一个数，转sor4返回。
　　　jz sor4
sor1: push cx　　　　　　 ;将外循环次数压入栈中保存。内循环的次数cx等于外循环次数
　　　mov bx,0　　　　　　;地址偏移的变量
sor2: mov ax,[si+bx+2]　　;两个数比较，若第1数大于第2数，则交换。并通过循环完成一趟冒泡。
　　　cmp [si+bx],ax
　　　jle sor3
　　　xchg [si+bx],ax
　　　mov [si+bx+2],ax
sor3: add bx,2
　　　loop sor2

　　　pop cx　　　　　　　;弹出外循环的cx，通过loop使外循环次数减1，继续下一趟冒泡。
　　　loop sor1

sor4: pop ds　　　　　　　;恢复现场
　　　pop dx
　　　pop bx
　　　pop ax
　　　ret
err1 db 'sort err:n<=0$'　;定义错误提示的变量
sort endp

outp proc　　　　　　　　 ;输出子程序。入口参数为“ds:si指向变量的入口地址，cx存放输出的元素个数。”
　　　push ax　　　　　　 ;保护现场
　　　push bx
　　　push dx
　　　push ds

　　　cmp cx,0　　　　　　;元素个数小于或等于0时，输出错误提示。
　　　jg out0
　　　push cs
　　　pop ds
　　　lea dx,err2
　　　mov ah,9
　　　int 21h
　　　jmp out2

out0: mov bx,0　　　　　　;地址偏移的变量
out1: mov ax,[si+bx]　　　;将数据放在ax中，调用write子程序输出。
　　　stc
　　　call write
　　　mov ah,2　　　　　　;输出空格
　　　mov dl,' '
　　　int 21h
　　　add bx,2　　　　　　;偏移量下移，并利用循环输出数据。
　　　loop out1

out2: pop ds　　　　　　　;恢复现场
　　　pop dx
　　　pop bx
　　　pop ax
　　　ret
err2 db 'output err:n<=0$'
outp endp

main: mov ax,data　　　　 ;主程序
　　　mov ds,ax
　　　mov ah,9　　　　　　;输出排序前的数据
　　　lea dx,msg1
　　　int 21h
　　　lea si,buf
　　　mov cx,10
　　　call outp

　　　lea si,buf　　　　　;调用排序子程序
　　　mov cx,10
　　　call sort
　　　call cr

　　　mov ah,9　　　　　　;输出排序后的数据
　　　lea dx,msg2
　　　int 21h
　　　lea si,buf
　　　mov cx,10
　　　call outp

　　　mov ah,4ch
　　　int 21h
　　　include write.asm
　　　include cr.asm
code ends
end main
6.6 编写一个子程序，判断一个无符号数是不是素数。入口参数和出口参数自行设计。

data segment　　　　　;数据段
msg1 db 'Yes$'
msg2 db 'No$'
data ends

sseg segment stack　　;堆栈段
dw 64 dup(0)
sseg ends

code segment　　　　　;代码段
assume cs:code,ds:data,ss:sseg

shushu proc near　　　;判断是否为素数子程序。入口参数为“ax”，出口参数为“cf=1为素数，cf=0不是素数，ax保存原数。”
　　　push bx　　　　 ;保护现场
　　　push cx
　　　push dx

　　　cmp ax,1　　　　;若数据为1或2时，则为素数。否则大于2时，则应利用除法判断。
　　　jz ss1
　　　cmp ax,2
　　　jz ss1

　　　mov cx,2　　　　;设置除数cx，循环从2一直到ax-1。
　　　mov bx,ax　　　 ;被除数暂存到bx中
ss0:　mov dx,0　　　　;利用dx,ax除以cx，判断余数dx是否为0。
　　　mov ax,bx
　　　div cx
　　　cmp dx,0　　　　;余数为0，非素数。余数不为0，除数加1后，继续利用除法判断。
　　　jz ss2
　　　inc cx
　　　cmp cx,bx　　　 ;判断除数是否大于原数
　　　jl ss0
　　　mov ax,bx　　　 ;将原数重新送回ax
ss1:　stc
　　　jmp ss3
ss2:　mov ax,bx　　　 ;将原数重新送回ax
　　　clc
ss3:　pop dx　　　　　;恢复现场
　　　pop cx
　　　pop bx
　　　ret
shushu endp

main: mov ax,data
　　　mov ds,ax