第六章 子程序程序设计

合集下载

汇编语言程序设计第6章

汇编语言程序设计第6章

第6章 子 程 序 设 计
该指令先把返回地址(即主程序中CALL指令的下一条指令 的地址)保存到堆栈中,以便子程序执行完返回主程序时使用, 然后则转移到子程序的入口地址去执行子程序。指令中的DST 一般是过程名(被调用过程),即子程序入口的符号地址,D16是 子程序入口地址和CALL指令之间的偏移量。
第6章 子 程 序 设 计 6.2.2 子程序调用方法说明
一个完整的子程序,应当包括子程序调用方法说明、保护现 场和恢复现场、子程序定义等部分。为了使用的方便,子程序应 以文件形式编写。子程序文件由子程序说明和子程序本身构成。 子程序说明部分要求语言简明、确切。
子程序说明一般由如下几部分组成: (1) 功能描述:包括子程序的名称、功能、性能指标(如执 行时间)等。 (2) 所用的寄存器和存储单元。 (3) 子程序的入口、出口参数。 (4) 子程序中又调用的其他子程序。 (5) 调用实例。
第6章 子 程 序 设 计
2.重复性 子程序是可多次重复使用的。—个子程序只占一段存储空 间,但可以多次地调用它,这样就避免了编程人员的重复劳动, 节省了存储空间。由于增加了调用、返回指令以及现场保护, 因此程序执行时间会增长。如果一个程序段只用到一次,就没 有必要编写成子程序形式。
第6章 子 程 序 设 计
RET SUBA ENDP SUBB PROC FAR

SUBB CODEB
RET ENDP ENDS END
MAIN
第6章 子 程 序 设 计
由于SUBB既被段间调用又被段内调用,所以必须是FAR属性。 例6-2给出的子程序SUBA、SUBB与主程序MAIN不在同一代码 段中,主程序MAIN在CODEA代码段中,而子程序SUBA、SUBB在 CODEB代码段中。 例6-1和例6-2说明,汇编语言程序中的主、子程序,既可 以在同一个代码段中(如例6-1),也可以在不同的代码段中(如 例6-2)。

《IBM PC 80X86汇编语言程序设计》PPT电子课件教案-第六章 子程序设计

《IBM PC 80X86汇编语言程序设计》PPT电子课件教案-第六章 子程序设计

《IBM PC 80X86汇编语言程序设计》
冶金工业出版社
第6章
1、子程序的概念和特点
子程序:把在程序中多次出现,具有独立功能 的程序段写成程序模块,该模块可被多次调用, 称之为子程序。
特点:①可重复使用(调用) ②具有通用性(可通过入口参数实现) ③可浮动性(存放位置灵活) ④可递归性和可重入性
第6章
第六章 子程序设计
一、子程序的定义 二、子程序的结构形式
三、子程序的设计和调用 四、子程序的参数传递方法 五、子程序的嵌套和递归调用 六、子程序的设计举例 七、多模块程序设计 八、汇编语言和高级语言的混合编程
《IBM PC 80X86汇编语言程序设计》
冶金工业出版社
第6章
一、子程序的定义
1、子程序的概念和特点 2、子程序的定义 3、子程序的调用和返回
《IBM PC 80X86汇编语言程序设计》
冶金工业出版社
第6章
2、子程序的定义
子程序的定义是由过程定义伪指令PROC和ENDP 来完成的。其格式如下:
过程名 PROC [NEAR/FAR]

过程名 ENDP
其中PROC表示过程定义开始,ENDP表示过程定 义结束。过程名是过程入口地址的符号表示。
一般过程名同标号一样,具有三种属性,即段 属性、偏移地址属性以及类型属性。
《IBM PC 80X86汇编语言程序设计》
冶金工业出版社
第6章
3、子程序的调用和返回
❖ 调用
①段内直接调用
格式:CALL 子程序名
功能:将子程序返回地址(断点)入栈
SP←SP-2
(SP)←IP,
并转到子程序入口地址去执行子程序。
❖ 返回指令

实验六循环子程序结构程序设计

实验六循环子程序结构程序设计
(1)循环结构将重复执行循环体中的语句,直到循环条件不成立。 (2)循环结构程序由初始化、循环处理、循环控制和循环结束 4部 分组成,循环控制条件有用计数控制循环和用条件控制循环两种方 式。 (3)循环结构程序的基本结构形式有“先执行,后判断”和“先判 断,后执行”两种。 2.子程序:子程序又称过程,用过程定义伪指令 PROC/ENDP 进行定 义,并集中存放在存储区的特定区域构成子程序库,需要时,用调 用指令 CALL调用。子程序执行完毕,应该返回到调用指令的下一条 指令继续执行。 实验内容与步骤 1.在数据段中有如下数据区,2,-3,0,5,-7,0,0,8,6,-9,统计该数 据区中正数,0,负数的个数。 参考程序如下:(程序名:SY6-1.ASM) data segment var db 2,-3,0,5,-7,0,0,8,6,-9 xx db ? ;存正数个数 yy db ? ;存负数个数 zz db ? ;存 零个数 data ends code segment assume cs:code,ds:data start: mov ax,data
36E6:002C 75F8 JNZ 0026
36E6:002E C3 RET 一 G=0 C ;观察第一次求和,DH=06H AX=0300 BX=0600 CX=032F DX=0600 SP=0000 BP=0000 SI=0000 DI=0000
DS=2000 ES=36D6 SS=36E6 CS=36E6 IP=000C NV UP EI PL ZR NA PE NC
B44C MOV AH,4C 2CA2:0034 CD21
INT 21 一 g=0 32
AX=0403 BX=0300 CX=0000 DX=0000 SP=0000 BP=0000 SI=000A

第六章子程序设计

第六章子程序设计
ASSUME CS:CODE2 DISP PROC FAR
MOV DL, ’P’ MOV AH, 2 INT 21H RET DISP ENDP CODE2 ENDS
END START
2023/12/31
汇编语言程序设计教程
12
例:段间间接调用
DATA SEGMENT NUM DW 1 CAADDR DW OFFSET SUBRT0
2023/12/31
汇编语言程序设计教程
23
6.3 子程序的嵌套与递归
6.3.1 子程序的嵌套调用 6.3.2 子程序的递归调用
2023/12/31
汇编语言程序设计教程
24
子程序的嵌套调用
• 子程序内包含有子程序的调用就是子程序的嵌套。嵌套深 度(即嵌套的层次数)逻辑上没有限制,但由于子程序的 调用需要在堆栈中保存返回地址以及寄存器等数据,因此 实际上受限于开设的堆栈空间。
• 子程序处理完数据后,将执行结果作为出口参数 存入寄存器中。
• 返回主程序后,主程序对存放在寄存器中的出口 参数进行相应的处理。
• 用寄存器传递参数方便、直观,是经常使用的方 法。但能传递的参数有限,适于参数较少的情况。
2023/12/31
汇编语言程序设计教程
21
通过堆栈传递参数
• 通过堆栈传递参数的思想是:主程序把入 口参数入栈保存,然后调用子程序,子程 序从堆栈中弹出入口参数进行处理。
• 递归子程序必须采用寄存器或堆栈传递参数,递归深度受 堆栈空间的限制。
• 递归子程序对应于数学上对函数的递归定义,它往往能设 计出效率较高的程序,可以完成相当复杂的计算。
2023/12/31
汇编语言程序设计教程
返回

第六章子程序

第六章子程序

(即当前的CS、IP)
b、将过程名的
偏移量
段地址 偏移量
堆栈
CS IP
RET
A、NEAR B、FAR
将栈顶一个字的内容 将栈顶两个字的内容
IP IP、CS
(二)完整的主程序及子程序的结构形式 1、近过程 CODE ASSUME START:MOV MOV MOV …… SEGMENT CS: CODE ,DS:DATA DS ,AX ES,AX AX,DATA
与主程序不在同一段CS不同
……
过程名 ENDP
2、调用和返回指令及功能
(1)指令

CALL
RET
A、近过程 B、远过程
CALL CALL
过程名 FAR PTR 过程名
(2)功能: CALL 过程名
A、若过程名为NEAR属性 a、将断点的偏移量 (即当前的IP) b、将过程名的偏移量 IP 堆栈
(寄存器、存贮器) B、若过程名为FAR属性a、将断点的地址 段地址
CALL ……
过程名(字程序名)
MOV INT 过程名 PORC …… RET 过程名 ENDP CODE END 2、远过程
AH,4CH 21H (NEAR)
ENDS START
CODEI SEGMENT ASSUME CS:CODEI ,DS:DATA
START: MOV MOV AX,DATA DS, AX
子程序
子程序又称过程,相当于高级语言中的过程和函数,在一个程序中多次用 到一个程序段。这个程序段的功能和形式都相同,只是某些变量的赋值不 同,可以把这些程序段写成子程序的形式,以便需要时调用。 (一)子程序(过程)的定义、调用和返回指令 1、过程(子程序)的定义伪指令 NEAR 过程名 PROC Attribute 或FAR 与主程序在同一段CS相同

语言程序掌握子程序的设计

语言程序掌握子程序的设计

语言程序掌握子程序的设计
1.定义子程序
子程序是一种由一系列指令组成的程序单元,它不能独立执行,而是在主程序中被调用,完成特定功能。

它常常由多个步骤组成,每个步骤完成特定的工作,并接受传入的参数值,以便实现代码复用。

2.子程序的优点
子程序有以下优点:
(1)节省内存:存储程序的代码时,每个子程序只需要一次存储,只要在主程序中调用,就可以运行。

因此,节省了大量的存储空间,能够有效的提升程序的执行效率。

(2)提高程序的可读性:当程序中有很多功能,用子程序的方式将功能拆分开来,方便阅读和编写程序,提高了程序的可读性。

(3)提高程序的重用性:由于子程序可以通过一次存储,可以无限次调用,因此可以大大提升程序的重用性,减少编程的重复工作量。

(4)代码可维护性:由于子程序只执行特定功能,代码量比较小,因此可以有效的提高代码维护的效率,对代码进行修改和改进。

3.子程序的编写
(1)定义子程序的参数:在编写子程序前,需要先定义子程序的参数,包括参数的类型、个数、变量名等。

(2)编写子程序的步骤:根据参数、功能定义,编写具体的步骤,完成子程序的编写。

汇编语言程序 掌握子程序的设计

汇编语言程序 掌握子程序的设计

汇编语言程序掌握子程序的设计汇编语言程序掌握子程序的设计什么是子程序子程序是汇编语言中一种独立的可重复使用的程序代码片段,它可以被主程序调用和执行。

子程序的设计可以让程序更加模块化,提高代码的复用性和可维护性。

子程序的设计原则1. 单一职责原则:每个子程序只负责一个特定的任务,功能要清晰明确,只有一个明确的入口和出口。

2. 低耦合原则:子程序之间应该尽量少的依赖和耦合,可以独立进行调试和修改,互相之间不会产生影响。

3. 高内聚原则:子程序内部的代码要高度集中和相关联,功能相关的代码应该放在一起。

4. 应该尽量避免代码的冗余和重复,可以将常用的代码片段封装成子程序,提高代码的可维护性和可读性。

子程序的设计步骤1. 确定子程序的功能和功能的输入输出:明确子程序的任务和需要的输入参数,确定子程序的输出结果。

2. 设计子程序的接口和入口参数:确定子程序的调用方式和输入参数的传递方式,以及子程序返回结果的方式。

3. 编写子程序代码:根据子程序的功能和接口的要求,编写相应的汇编语言代码。

4. 调试和测试子程序:进行子程序的单独测试和调试,确保子程序的功能正确和稳定。

5. 在主程序中调用子程序:将子程序集成到主程序中,并按照子程序的接口要求传递参数并获取结果。

子程序的设计案例:计算阶乘假设我们需要在汇编语言中设计一个子程序,用于计算给定整数的阶乘。

assemblysection .datanum db 5result dw 0section .textglobal _start_start:mov al, te [num]call factorialmov word [result], ax ; 其他指令factorial:push bpmov bp, sppush axpush cxxor ax, axmov cl, alcmp al, 1je end_factorialdec alcall factorialmul clend_factorial:pop cxpop axpop bpret在上面的例子中,我们使用了一个子程序`factorial`,用于计算给定整数的阶乘。

微机原理与应用第六章

微机原理与应用第六章

数组字<AX? N 内容交换 修改数组指针 N 到100字?
YRT: MOV MOV MOV MOV MOV NEXT1: CMP
AX,2000H DS,AX BX,0042H AX,0 CX,100 AX,[BX]
循环次数已知 (计数控制)
JA
MOV NEXT: INC
NEXT
MAX PROC NEAR PUSHF PUSH AX PUSH CX PUSH SI
STAR:MOV BX,2000H MOV AL,5 MOV AH,0 [BX+AL] XLAT HLT ADD BX,AX
MOV AL,[BX] 执行后:AL=19H
复习换码指令
…… 64H 51H 40H 31H 24H 19H 10H 09H 04H 01H 00H
⑴ 段内直接调用与返回
格式:CALL 过程名 功能:调用当前段内的子程序 操作:SP←SP-2,[SP]←IP,IP←IP+disp 格式:RET 操作:IP ←[SP],SP← SP+2 16位通用寄存器或 ⑵ 段内间接调用与返回 字存储器 格式:CALL OPRD 操作:SP←SP-2,[SP]←IP,IP←(OPRD) 格式: RET 操作:IP ←[SP],SP← SP+2
子 程 序 段
子 程 序 段
subr1 proc near ...... ret subr1 endp main endp code ends
主 程 序 段
code ends
例:
MY SEGMENT ASSUME CS:MY MAIN PROC FAR START: PUSH DS SUB AX,AX PUSH AX MOV CL,04 CALL DP5 MOV BL,CL CALL DP5 ADD AL,BL RET MAIN ENDP DP5 PROC MOV SAL SAL ADD MOV NEAR AL,CL AL,1 AL,1 AL,CL CL,AL

第六章-子程序设计

第六章-子程序设计
MAIN
CODE1 SEGMENT PROC FAR CALL FAR PTR SUB2 RET ENDP ENDS SEGMENT PROC FAR CALL FAR PTR SUB2 RET ENDP PROC FAR RET ENDP ENDS END MAIN
MAIN CODE1 CODE2 SUB1
DEC_DIV
DEC_DIV CODE
PROC ;CX中为十进制的位权 MOV AX,BX MOV DX,0 DIV CX ;商为转换后的一位十进制数 MOV BX,DX MOV DL,AL ADD DL,30H ;转换成ASCII码 MOV AH,2 ;显示 INT 21H RET ENDP ENDS 10 END MAIN
21
NEXT:
ARY_SUM CODE2
ADD AX,[SI] ADD SI,2 LOOP NEXT MOV [DI],AX POP DI POP SI POP CX POP AX RET ENDP ENDS END MAIN
;累加和 ;修改地址指针 ;存和 ;恢复寄存器
22
4.通过堆栈传递参数或参数地址
6.2
子程序参数传递
通过给子程序传递参数使其更通用。常用 的参数传递方法如下: 通过寄存器传递; 通过内存传递:若主子程序在同模块中, 子程序可以直接访问模块中的变量; 通过地址表传递参数地址; 通过堆栈传递参数或参数地址。
6
1.通过寄存器传递 这种传递方式使用方便,适用于参数较 少的情况。 例1.把BX中的16位二进制数转换成十 进制并显示在屏幕上。 分析:二进制到十进制数的转换方法有 多种,本例采用从高到低逐个除以十进 制位权的方法。
第六章
子程序设计
为了程序共享或模块化设计的需要,可以把一 段公共语句序列设计成子程序或宏指令的形式。 本章介绍子程序的设计方法。 在汇编语言中,允许子程序嵌套和递归。子程 序作为调用程序去调用另一子程序,把这种关 系称为子程序嵌套。嵌套的层数没什么限制, 其层数称为嵌套深度。 在子程序嵌套情况下,如果一个子程序调用的 子程序就是它自身,这样的子程序称为递归子 程序。显然递归调用是子程序嵌套的一种特殊 情况。用递归算法可设计出效率较高的程序。 子程序设计时,要注意堆栈足够大。 1

汇编语言程序设计第六章 子程序结构

汇编语言程序设计第六章   子程序结构

20016H
20018H
SP
BX AX
IP CS
2001AH

DX CX BX AX ENDP
2001CH 2001EH
20020H
11
6.1.3 保存与恢复寄存器
先看一个例子(如图): SUBT PROC FAR PUSH AX PUSH BX PUSH CX PUSH DX
POP POP POP POP RET SUBT
DX CX
20016H
20018H 2001AH
BX AX
IP CS

DX CX BX AX ENDP
2001CH 2001EH
20020H
8
下一页
6.1.3 保存与恢复寄存器
先看一个例子(如图): SUBT PROC FAR PUSH AX PUSH BX PUSH CX PUSH DX
POP POP POP POP RET SUBT
18
newchar: mov int sub jl cmp jg cbw ;(digit is now in ;multiply number xchg mov mul xchg add jmp exit: ret DEC2BIN endp ah,1 21h al,30h exit al,9d exit ;keybroad input ;call DOS ; ASCⅡ to binary ;jump if<0 ;is it >9d? ;yes,not dec digit ;byte in AL to word in AX
stack_seg
tos stack_seg ; dw label
segment 100 dup(?) Word;教材P132 ends

子程序设计和调用

子程序设计和调用

子程序设计和调用1.子程序:子程序是完成特定任务的一段代码,它可以接受输入参数,执行一系列操作,并返回结果。

子程序可以是函数(用于数据的转换和处理)或过程(仅用于执行一系列操作而不返回结果)。

2.调用:调用是指程序在需要使用子程序时,通过特定的语法将程序的控制权转移到子程序中执行,并在子程序执行完后返回原来的位置继续执行。

3.参数传递:在调用子程序时,可以将一些数据(参数)传递给子程序使用。

参数可以是常量、变量或表达式。

参数可以用于向子程序传递数据,也可以用于将子程序的结果返回给调用者。

1.模块化:通过将程序划分为多个子程序,可以将复杂的任务分解为小的、可独立实现的模块,提高了程序的模块化程度,使程序结构更清晰,易于理解和维护。

2.代码复用:子程序可以在程序的不同部分多次调用,避免了重复编写相同的代码,提高了代码的复用性,减少了代码量。

3.可重用性:将问题分解为多个子程序后,每个子程序都可以独立编写和测试,可以被其他程序使用,提高了代码的可重用性。

4.高效性:通过将一部分功能委托给子程序处理,可以提高程序的执行效率,减少了代码的冗长和重复。

1.定义子程序:确定需要什么功能和操作,根据需求编写子程序,包括接受参数、执行操作和返回结果。

子程序的定义包括子程序名、参数、返回值等信息。

2.调用子程序:在程序的适当位置调用子程序,使用特定的语法将程序的控制权转移到子程序中执行。

3.传递参数:在调用子程序时,传递需要的参数。

参数的传递可以是值传递,将参数的值复制给子程序;也可以是引用传递,将参数的地址传给子程序,子程序可以访问参数的值。

4.执行子程序:子程序接收参数后,执行一系列操作,可能包括数据处理、运算、条件判断等。

5.返回结果:子程序执行完毕后,将结果返回给调用者,结果可以是计算结果、处理结果等。

调用者可以使用返回的结果继续程序的执行。

6.返回控制权:子程序返回结果后,将程序的控制权返回给调用者,调用者在接收到返回结果后,根据需要继续程序的执行。

汇编语言程序 掌握子程序的设计(2023版)

汇编语言程序 掌握子程序的设计(2023版)

汇编语言程序掌握子程序的设计汇编语言程序设计——子程序的设计一、引言汇编语言是一种低级别程序设计语言,与计算机硬件之间的联系非常紧密。

掌握子程序的设计是汇编语言程序设计的重要环节之一,本文档将详细介绍汇编语言程序中子程序的设计方法。

二、子程序的概念⒈子程序的定义子程序是一段独立的代码段,用于完成特定的功能,可以被主程序或其他子程序调用。

⒉子程序的优点⑴提高程序的模块化和可读性⑵重复利用代码,减少代码冗余⑶便于程序的维护和调试三、子程序的设计⒈子程序的设计要素⑴子程序的输入参数⑵子程序的返回值⑶子程序的功能描述⒉子程序的设计步骤⑴确定子程序的功能和输入参数⑵设计子程序的算法⑶编写子程序的代码⑷调试子程序并验证其正确性四、子程序的调用与返回⒈子程序的调用⑴传递参数⑵调用子程序⑶获取返回值⒉子程序的返回⑴返回值的存储⑵返回地质的存储五、子程序的参数传递⒈参数传递的方式⑴寄存器传递参数⑵栈传递参数⑶内存传递参数⒉参数传递的注意事项⑴参数传递的顺序⑵参数传递的大小和类型⑶参数传递的规范六、子程序的返回值⒈返回值的存储方式⑴寄存器存储返回值⑵内存存储返回值⒉返回值的类型⑴整型返回值⑵实型返回值⑶字符串返回值七、附件本文档没有附件。

八、法律名词及注释⒈子程序:在计算机程序中,独立完成特定功能的代码段。

⒉模块化:将程序分成多个独立的模块,每个模块负责完成特定功能。

⒊可读性:指程序的易读程度,便于程序员理解和维护。

⒋代码冗余:程序中重复出现的代码。

⒌算法:解决问题的一系列步骤。

汇编语言程序设计-子程序

汇编语言程序设计-子程序

6.1 子程序的设计方法
MOV DL,’B’ MOV AH,2 INT 21H MOV AH,4CH INT 21H CSEG ENDS END START
6.1 子程序的设计方法 ;子程序:NWELINE
;功能:回车和换行(光标移到下一行首) ;入口参数:无 ;出口参数:无 ;说明:通过显示回车符形成回车,通过显示换行符形成换 行 NEWLINE PROC MOV DL,0AH;显示换行符 PUSH AX MOV AH,2 PUSH DX INT 21H MOV DL,0DH;显示回车符 POP DX POP AX MOV AH,2 RET INT 21H
6.1 子程序的设计方法
NEXT:MOV AL,[SI] INC SI OR AL,AL JZ OK;判断是否为0 CALL ISDECM JNC NEXT MOV [DI],AL INC DI JMP NEXT OK:MOV [DI],AL MOV AH,4CH INT 21H CSEG ENDS END START
6.1 子程序的设计方法
MOV AL,0 MADD PROC ADC AL,0 PUSH AX MOV BYTE PTR DATA4+4, PUSH CX AL POP SI PUSH SI POP CX MOV CX,2 POP AX XOR SI,SI RET MADD PTR MADD1:MOV AX,WORD ENDP DATA1[SI] ADC AX,WORD PTR DATA2[SI] MOV WORD PTR DATA3[SI],AX INC SI INC SI LOOP MADD1
6.1 子程序的设计方法
2. 子程序的调用与返回
子程序调用:隐含使用堆栈保存返回地址

第6章 子程序设计

第6章 子程序设计

;保存程序前缀PSP地址
;AX清0 ;RES字单元清0 ;置地址指针 ;过程调用计算RES+2X ;过程调用计算RES+5Y
;过程调用计算RES+8Z ;程序返回
汇编语言程序设计
子程序编写
MULL PROC MUL ADD MOV INC RET MULL ENDP NEAR ;乘法子程序 BYTE PTR [BX] ;做乘法结果在AX WORD PTR RES,AX ;做加法 AX,0 ;AX清0 BX ;地址加1 ;返回主程序
(IP) ← (EA)
DST给出寄存器或存储单元的内 容(转向地址) 比如: CALL word ptr [bx]
汇编语言程序设计
DST给出子程序的入口地址 (子程序为far属性) 比如:CALL far ptr subp
段间直接远调用:CALL FAR PTR DST
执行操作: PUSH CS PUSH IP (IP) ← DST偏移地址 (CS) ← DST段地址
指令功能: 把CALL指令的下一条指令地址(称为返回点或断点) 推 入堆栈保存,然后转到目标地址(DST)。 CALL指令可以在段内、段间调用,寻址方式分为直接和 间接两种。
汇编语言程序设计
段内直接近调用:CALL DST 执行操作: (SP) ← (SP) - 2 ( (SP)+1,(SP) ) ← (IP)
(SP) 段间间接远调用:CALL FAR PTR DST →
(IP) (CS)
执行操作: PUSH CS PUSH IP (IP) ← (EA) (CS) ← (EA+2)
汇编语言程序设计
(2)RET 返回主程序指令: 属于无 条件转移指令。可以在段内或段间返 回。 段内近返回:RET

第六章 子程序设计

第六章 子程序设计
第六章
子程序设计
1、 子程序的设计方法 2 、子程序的嵌套 3 、子程序应用举例
汇编语言程序设计
子程序的设计方法 1、子程序的定义 2、 子程序的调用与返回指令 3、 保存与恢复寄存器 4、子程序的参数传递
汇编语言程序设计
子程序的定义
将一些常用的具有通用功能的操作编写成子程序,便于一 个或多个程序使用,使程序设计模块化,从而达到代码 复用、简化编程的目的。 子程序定义伪指令: 子程序名 PROC [NEAR /FAR ] 子程序体 RET 子程序名 ENDP 其中: PROC表示子程序开始,ENDP表示子程序结束。 过程名是子程序的入口地址,在程序中是唯一的。它应 满足标识符的命名规则。 FAR或NEAR是子程序的属性操作符,缺省时为NEAR属性。 汇编语言程序设计
子程序的参数传递 参数传递通常有三种方法:
1、通过寄存器传递参数 2、通过地址表传递参数地址 3、通过堆栈传递参数或参数地址
汇编语言程序设计
通过寄存器传递参数
通过寄存器进行主程序和子程序之间的参数传 递是最常用的参数传递方式。由于CPU中的寄 存器是有限的,因此通过寄存器传递参数适 用于入口参数较少的情况。它一般通过寄存 器传递数据或数据地址。常用:AL,AX,DX 寄存器传数据,用SI,DI,BX 传地址。
汇编语言程序设计
保护现场和恢复现场的方法
(1) 利用压栈和出栈指令,将寄存器内容或状态标志位内容 保存在堆栈中,恢复时再从堆栈中取出。如: SUBT PROC NEAR PUSH AX ;保存现场 PUSH BX PUSH CX PUSH DX ... ;子程序正常工作 POP DX ;恢复现场 POP CX POP BX POP AX RET SUBT ENDP 汇编语言程序设计

第六章子程序程序设计

第六章子程序程序设计

;现场保护
;内循环次数,大小由单位时间定 ;延时10ms
子程序调用,实现100ms、550延时
CSEG
MAIN
MAIN
SEGMENT ASSUME PROC PUSH SUB PUSH …… MOV CALL MOV CALL …… RET ENDP
CS:CSEG,…… FAR DS AX,AX AX
① 间接寻址 CALL far mem32 ② ③ ④ 例:CALL far [BX]
注:DWORD PTR表明内存操作数属性为双字,用于段间调用
RET 指令
返回类型 格 式 操 作
IP出栈
段内:
RET
RET exp
RET RET exp
注:返回类型由调用类型定
① IP出栈 ② SP ← SP + exp
第6章 子程序程序设计
一、 过程定义、过程调用
1. 定义 过程名 PROC … RET … 过程名 ENDP [类型]
2. 调 用 CALL 过程名
N E A R 子 程 序 书 写 形 式
CODE SEGMENT ASSUME …… MAIN PROC FAR …… CALL SUB1 …… RET SUB1 PROC NEAR …… CALL SUB2 …… RET SUB2 PROC NEAR …… RET SUB2 ENDP SUB1 ENDP MAIN ENDP CODE ENDS
AH = 6 向上滚屏
AH = 7 向下滚屏 AH = 0EH 显示字符
例:8088CPU,主频4.77M,每个时钟周期为:
1/4.77M = 0.21μ s。循环指令LOOP,当CX不为零 时,执行循环转移分支,占用17个时钟周期;当CX 为零时,退出循环,占用5个时钟周期。如果CX初 值是2801时,执行指令WAIT1:LOOP WAIT1,所需 时间为:

第六章 子程序和函数PPT课件

第六章 子程序和函数PPT课件
DECLARE语句中括弧内参数的个数和类型与子程序形参的个数和类型 一致。
在子程序中还可以调用子程序,也可以调用它自身(递归调用)。
子程序的输入
在QBASIC环境下,无论在哪个编辑窗口,只 要在新一行键入子程序的初始行,如:SUB Star(n AS INTEGER),按回车键;如果已经输 入主程序,将窗口Split,在其中的一个窗口中 的主程序后键入子程序(该窗口中的主程序会 自动清除,而且存盘后另一窗口主程序的前面 加DECLARE SUB 子程序名);通过View菜 单的SUBs…菜单项选择或激活要编辑的子菜 单或主程序。
IF (x > y) THEN fmax% = x: EXIT FUNCTION
ELSE fmax% = y: EXIT FUNCTION
END IF END FUNCTION
模块化的函数
FUNCTION函数的结构形式如下: FUNCTION〈函数名〉[〈形参表列〉][〈STATIC〉] … LET〈函数名〉=〈表达式〉 … END FUNCTION
DECLARE FUNCTION fmax% (x AS INTEGER, y AS INTEGER) REM main program DIM a AS INTEGER, b AS INTEGER, max AS INTEGER INPUT "Plese input a,b="; a, b PRINT "a="; a, "b="; b max = fmax%(a, b) PRINT "The max is:"; max END FUNCTION fmax% (x AS INTEGER, y AS INTEGER)
abxy 21.2 12.1 0 0
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

4. 结构伪指令
• 到目前为止,允许分配和命名指定大小(字节、字和双字等)的变量的 指令,但大多数应以程序是使用相关的变量组而非单个变量。例如保存 人名的一个应用程序,如果该程序要保存人的最后名、最初名和中间的 词首分隔符,每个名是三个独立的文本串。可以使用独立的BYTE指令 来分配每个串,但将这三个串放在一起作为一组分配是方便的。MASM 中的STRUC指令正好提供这种功能——定义一个由(可能是)• 不同类 型变量组成的整体数据结构。 • 使用STRUC组织用户数据 • 为结构分配空间 • 在汇编过程中初始化结构域 • MASM中嵌套的结构 • 访问结构中的域 • 访问嵌套结构中的域 • 返回
CALL指令祥解
• 段内调用:
– 直接调用
• CALL <过程名>
–ቤተ መጻሕፍቲ ባይዱ间接调用
• • • • CALL CALL CALL CALL reg /mem BX CX WORD PTR 20H[BX][SI]
– 如果在段内调用远过程
• CALL FAR PTR <过程名>

返回
2. 子程序的结构类型
1. 2. 3. 4. 5. 6. 7.
1. 定义子程序的伪指令
子程序的结构如下: <子程序名> PROC [NEAR/FAR] … RET [n] … <子程序名> ENDP 调用指令: CALL <子程序名> 子程序的类型有NEAR和FAR(缺省为NEAR)• ,和调用程序在同一代码 段中的子程序用NEAR,和调用程序不在同一代码段中的子程序使用 FAR属性,当然定义为FAR的子程序在同一段也可调用。 在执行CALL语句时,将CALL语句的下一语句的IP(或CS和IP)压栈, 在执行子程序时中的RET[n]语 • 句时,系统将用栈顶的内容弹出并更新IP (或IP和CS)的值,若有[n]系统将再多弹出n个字节(n必须为偶数)。 • 返回
10) 11)
返回
代码转换举例
• • • • • • • • • • • • • • • • • • • • • • DEC_BIN PROC FAR ;BX中存放从键盘输入的十进制数转换的二进制数 MOV BX,0 ;BX中存放输入的数值 NEWCHAR: MOV AH,01H INT 21H ;(al)为ASCII字符 SUB AL,30H ;ASCII TO binary JL EXIT ;jump if <0 CMP AL,0AH ;is it >9d? JGE EXIT ;yes not decimals digit CBW ;byte in AL to word in AX ;digit is now in AX ;将BX乘上10 XCHG AX,BX ;exchange ax and bx MOV CX,10 ; MUL CX ;将AX乘上10 ADD BX,AX ;将AX与BX相加并送BX JMP NEWCHAR ;get next digit EXIT : RET DEC_BIN ENDP 返回
⑴ 一个主程序调用一个子程序
⑵ 多层嵌套调用:
子程序再调用子程序,要格外注意程序中的堆栈变化,要确 保子程序在每次返回时,SP指向的是正确的返回地址,而不 是数据或其它信息。 ⑶ 递归调用子程序: 子程序调用自身,这种结构程序短效率高,它是嵌套调用的 一种特殊情况 返回
3. 子程序的数据传送方法
通常有五种方法: ⑴ 直接访问: 子程序和调用程序在同一程序模块中,则子程序可直接访问模块中的 变量 ⑵ 使用PUBLIC定义的公共(全局)变量和EXTRN说明的外部变量。 ⑶ 通过寄存器 ⑷ 通过堆栈 ⑸ 通过公共数据区 各模块分别定义一个同名的数据段,并用组合类型COMMON合并为 一个覆盖段,这样变量即成为本模块的局部变量,可直接引用。 • 返回
十二算法
• 思路:
123=1*100+2*10+3 =(((0*10)+1)*10+2)*10+3 X=X*10+Y

算法:
1) 2) 3) 4) 5) 6) 7) 设BX中存放最终二进制数,初值为0 从键盘输入一个字符,如1,则(al)中为其ASCII AL(AL)-30H ;将ASCII变成实际的数值 判断0<=(AL)<=9?,不是转7) 执行CBW命令将ALAX BX(BX)*10+AX,转2) 结束
为结构分配空间
• 前面的定义只是为该结构定义了一个模板,• 但MASM 还未分配空间。• 用户可以为FullName数据结构和其它 数据类型的实例分配空间并加以初始化。• 下面的例子 创建FullName结构的两个实例,• Naba和Mitch,还创建 含有10个FullName结构的数组,它可以通过People进行 访问。 • Naba FullName {} • Mitch FullName {} • People FullName 10 dup({}) • 返回
• • • • • • • • •
MASM中嵌套的结构
• MASM允许用户对结构定义进行嵌套,在一些情况下,这就允许 一个结构的某些域是结构本身。例如: • point STRUC • x db ? • y db ? • point ENDS • Rectangle STRUC • UpperLft point ;左上角坐标(x,y) • LowerRt point ;右上角坐标(x,y) • Rectangle ENDS • 返回
第六章 子程序程序设计
• 在一个程序中,当不同的地方需要多次使用的某程序段 (即完成一个给定功能的程序段)常常单独编制一指令序 列。在程序运行时,若需要这个给定功能,就转移到这个 指令序列,待指令执行完后,又返回到原来位置继续执行。 这个单独编制的指令序列就叫子程序,转移到子程序称为 调用子程序。 定义子程序的伪指令 子程序的结构类型 子程序的数据传送方法 结构伪指令 代码转换 递归程序设计 多模块之间的连接
代码转换举例
BIN_DEC PROC FAR MOV CX,10000D ;DEVIDE BY 10000 CALL DEC_DIV MOV CX,1000D ;DEVIDE BY 1000 CALL DEC_DIV MOV CX,100D ;DEVIDE BY 100 CALL DEC_DIV MOV CX,10D ;DEVIDE BY 10 CALL DEC_DIV MOV CX,1D ;DEVIDE BY 1 CALL DEC_DIV RET BIN_DEC ENDP ;-----------------------------------------------------------------------DEC_DIV PROC NEAR ;打印商到屏幕上 ;被除数在(DX,AX)里,除数在CX中 MOV AX,BX MOV DX,0 ;将高字赋0 DIV CX MOV BX,DX ;余数在BX中 MOV DL,AL ;商在DL中 ;显示DL到屏幕上 ADD DL,30H ;转换成ASCII MOV AH,02h ;INT 21H的02号功能显示DL中的ASCII到屏幕上 INT 21H RET DEC_DIV ENDP
使用STRUC组织用户数据
• 使用STRUC组织用户数据很容易,• 例如定义一个包含 最初名、最后名和中间分隔符的结构FullName,可以 使用代码: FullName STRUC Firstname db 15 dup(?) Initial db ? LastName db 24 dup(?) FullName ENDS • 结构定义并不占用空间,但MASM在遇到结构中的 域时就会为它分配空间。 • 返回
访问结构中的域
• • • • • • • • • • • • 当用户说明了某种结构类型的变量时,MASM将结构的第一字节的偏移设 置为该变量名,用户可以使用地址表达式了访问该结构的域。访问方式: <变量名>[位移量] <变量名>.<域名> 例: MOV al,Naba+15 MOV al,Naba.Initial MOV al,Naba.Firstname[4] LEA si,stname 若将Naba的地址已被装入ES:[BX]中,如果要访问LastName,使用指令 MOV al,ES:[BX].Lastname 若Lastname是由几个结构共享的域名,将会发生错误。 返回

算法及思路

• • • •
二 十: 向屏幕输出时,通常输出十进制数,因为符合人们的习惯,但在计算机内部为十六 进制,如将7BH输出到屏幕,必须将其化成十进制数123的ASCII码31H、32H、 33H再分别输出到屏幕。使用DOS中断的02号功能,显示字符到屏幕 mov ah,02h int 21H 算法与思路 举例: 十二 二十 返回
在汇编过程中初始化结构域
• • • • • • • • • 上例中用户说明结构变量时,• MASM并不初始化这些域为任何值(实际上为0)。用户也可在定义结 构时进行初始化: FullName STRUC Firstname db '---------------' Initial db '-' LastName db '------------------------' FullName ENDS 使用这种定义,则用FullName类型说明的任何变量在缺省时其中的域都初始化为短线。 如果用户所需的大多数(或所有的)结构都以相同的域值开始,那么缺省的初始化是很有用的。• 但 通常用户需要将每个结构实例初始化为不同的域值。• 例如上述的变量Naba和Mitch要包含类似于 "Naba"和"Mitchell"这样的串,• 而不是短线。MASM提供了使用指定值替换缺省值的手段。当定义一 个结构变量的实例时,可以在参数域的"{"和"}"(也可使用"< >")符号之间包含一个初始化表。 Naba FullName {"Naba"," ","Barkakati"} Mitch FullName {"Matchell"," ","Waite"} 用户可以只初始化结构中的某些域,如果初始化表中某一项为空,MASM就给该域使用缺省值。如: Jonathon FullName {"Johnny"} ;Initial/Lastname=-John FullName {,"A"} ;First/Lastname=-Jon FullName {,,"Apple"} ;First/Initial=--Johnny FullName {"John"," "} ;Last=----------返回
相关文档
最新文档