返回列表 发帖

[原创]汇编语言教学

第一课 基本概念(win32)汇编教程 我们先假设您已知道了如何使用MASM。如果您还不知道的话,请下载 win32asm.exe ,并请仔细研读其中所附带的文档资料。好,如果您已准备就绪,我们这就开始吧! 理论: WIN32 程序运行在保护模式下的,保护模式的历史可以追溯到 80286。而今 80286 已成为了历史。所以我们将只把精力集中于 80386 及后续的X86 系列 CPU。Windows 把每一个 Win32 应用程序放到分开的虚拟地址空间中去运行,也就是说每一个应用程序都拥有其相互独立的 4GB 地址空间,当然这倒不是说它们都拥有 4GB 的物理地址空间,而只是说能够在 4GB 的范围内寻址。操作系统将会在应用程序运行时完成 4GB 的虚拟地址和物理内存地址间的转换。这就要求编写应用程序时必须格守 Windows 的规范,否则极易引起内存的保护模式错误。而过去的 Win16 内存模式下,所有的应用程序都运行于同一个 4GB 地址空间,它们可以彼此"看"到别的程序的内容,这极易导致一个应用程序破坏另一个应用程序甚至是操作系统的数据或代码。 和 16 位 Windows 下的把代码分成 DATA,CODE 等段的内存模式不同,WIN32 只有一种内存模式,即 FLAT 模式,意思是"平坦"的内存模式,再没有 64K 的段大小限制,所有的 WIN32 的应用程序运行在一个连续、平坦、巨大的 4GB 的空间中。这同时也意味着您无须和段寄存器打交道,您可以用任意的段寄存器寻址任意的地址空间,这对于程序员来说是非常方便的,这也使得用32位汇编语言和用C语言一样方便。 在Win32下编程,有许多重要的规则需要遵守。有一条很重要的是:Windows 在内部频繁使用 ESI,EDI,EBP,EBX 寄存器,而且并不去检测这些寄存器的值是否被更改,这样当您要使用这些寄存器时必须先保存它们的值,待用完后再恢复它们,一个最显著的应用例子就是 Windows 的 CallBack 函数中。 内容: 下面的程序段是一个框架, 若您现在还不知道这些指令的确切意义的话,没关系, 随后我就会给大家详细解释。 .386 .MODEL Flat, STDCALL .DATA ...... .DATA? ...... .CONST ...... .CODE

[原创]汇编语言教学

感谢楼主!!收了

TOP

[原创]汇编语言教学

OK!我正在找类似的资料,太谢谢啦!

TOP

[原创]汇编语言教学

呵呵
图书馆一直借不到汇编书
最近正郁闷呢
谢谢了啊~~~

TOP

[原创]汇编语言教学

真的很需要这样的教程,多谢楼主了,决定收藏!!!!!

TOP

[原创]汇编语言教学

VxD 程序设计入门 我们在上一节学会了如何编写一个什么事也不做的VxD程序。在这一节里,我们要给它增加处理控制消息的功能。 VxD的初始化和结束 VxD程序分为两种:静态的和动态的。每种的加载方法都不同,接受到的初始化和结束的控制消息也不同。 静态VxD: 下列情况下,VMM加载一个静态VxD: 一个实模式常驻程序通过调用中断2FH,1605H,来调用此VxD。 此VxD在注册表中的如下位置有定义: HKEY_LOCAL_MACHINE\System\CurrentControlSet\Services\VxD\key\StaticVxD=VxD带路径文件名 此VxD在system.ini中的[386enh]行下有定义:[386enh] section: device=VxD带路径文件名 在开发的时候,我建议你从system.ini载入VxD程序,因为这样如果你的VxD程序有错而导致Windows不能启动的话,你可以在Dos下修改system.ini,而如果你使用的注册表载入的办法,就无法修改了。 当VMM加载你的静态VxD程序时,你的VxD程序会按以下顺序接收到三个系统控制消息: Sys_Critical_Init VMM在转入到保护模式后,开放中断前发出这个控制消息。大多数VxD程序到不要用到这个消息,除非: 你的VxD程序要接管一些其他VxD程序或者保护模式程序要用到的中断。既然你处理这个消息的时候这个中断还没有打开,你就可以确定在你接管这个中断的时候此中断不会被调用。 你的VxD程序为其他的VxD程序提供了一些VxD服务。例如,一些在你的VxD程序后加载的VxD程序在处理Device_Init控制消息时需要调用一些你的VxD服务,既然Sys_Critical_Init 控制消息在Device_Init消息之前被发送,所以你应该在Sys_Critical_Init 消息发送时初始化你的程序。 如果你要对这消息进行处理,你应该尽可能快的做完初始化工作,以免太长的执行时间导致的硬中断丢失。(记住:中断还没打开) Device_Init VMM在开放中断后发送此信息。大多数VxD程序都在得到这个消息时初始化。因为中断都开放了,所以耗时的操作也可以在这里执行而不必怕会导致硬中断的丢失。你可以在这时进行初始化(如果你需要的话)。 Init_Complete 在所有的VxD程序处理完Device_Init 消息之后,VMM释放初始化段(ICODE和RCODE段类)之前,VMM发出这个控制消息。只有少数几个VxD要处理这个消息。 你的VxD程序在成功地初始化后,必须将返回标志清零,反之,必须在返回之前把返回标志设为出错信息。如果你的VxD不需要初始化,你就不必对这些消息进行处理。 当要结束静态VxD的时候,VMM发送如下的控制消息: System_Exit2 当你的VxD程序收到这个消息,Windows95正在关闭系统,除了系统虚拟机所有其他虚拟机都已经退出了。尽管如此,CPU仍然处于保护模式下,在系统虚拟机上执行实模式编码也是安全的。在这时Kernel32.dll也已经被卸载了。 Sys_Critical_Exit2 当所有的VxD完成对System_Exit2的响应处理并且中断都被关闭后,你的VxD收到到这个消息。 许多VxD程序并不要响应这两个消息,除非你要为系统做转换到实模式的准备。要知道,当Window95关闭时,它进入到实模式。所以如果你的VxD程序对实模式影像做了一些会导致它不稳定的操作,它就需要在这时进行恢复。 你也许会感到奇怪:为什么这两个消息后面都跟着个“2" ”。这是因为:在VMM加载VxD程序的时候,它是按照初始化顺序值小的VxD先加载的顺序加载的,这样VxD程序就可以使用那些在它们之前加载的VxD程序提供的服务。例如,VxD2要用到VxD1中的服务,它就必须把它的初始化顺序值定义的比VxD小。加载的顺序是: ..... VxD1 ===> VxD2 ===> VxD3 ..... 那么卸载的时候,理所当然的是初始化顺序值大的VxD程序先被卸载,这样他们仍然可以使用比它们后加载的那些VxD程序提供的服务。如上面的例子,次序是: .... VxD3 ===> VxD2 ===> VxD1..... 在上边的例子中,如果VxD2在初始化时调用了VxD1中的某些服务,那么卸载时它可能也要再次用到一些VxD1中的服务。System_Exit2和Sys_Critical_Exit2是反初始化顺序发送的。这表示,当VxD2接受到这些消息时,VxD1还没有被卸载,它仍可以调用VxD1的服务,而System_Exit和Sys_Critical_Exit消息不是按照反初始化顺序发送的。这意味着,你不能肯定你是否仍能调用在你之前加载的VxD提供的VxD服务。新一代的VxD程序不应该使用这些消息。 还有两种退出消息: Device_Reboot_Notify2 告诉VxD程序VMM正在准备重新启动系统。这时候中断还是开放的。 Crit_Reboot_Notify2 告诉VxD程序VMM正在准备重新启动系统。这时候中断已经被关闭了。 到这里,你可以猜到还有Device_Reboot_Notify和Crit_Reboot_Notify 消息,但它们并不是像“2”版本的消息一样按反初始化顺序发送的。 动态VxD: 动态VxD在Windows9x里可以动态的被加载和卸载。这个特点在Window3.x下是没有的。动态VxD程序的主要作用是用来支持某些动态的硬件设备的重装,比如:即插即用设备。尽管如此,你可以从你的Win32程序中加载/卸载它,也可以把它看作是你的程序的一个到ring-0的扩展。 上一节我们提到的例子是一个静态的VxD,你可以把它转换成一个动态的VxD,只要在.def文件中VxD标记的后面加上关键字DYNAMIC。 VxD FIRSTVxD DYNAMIC 这就是你把一个静态VxD转换成一个动态的VxD所要做的一切。 一个动态的VxD可以按以下的方法被加载: 把它放到你的Windows目录下的\SYSTEM\IOSUBSYS目录中。在这个目录里的VxD会被输入输出监视器(ios)加载。这些VxD必须支持层设备驱动。所以用这种方法加载你的动态VxD并不是一个好办法。 用VxD加载服务。 VxDLDR是一个可以加载动态VxD的静态VxD。你可以在其他VxD里面或者在16位代码里面调用它的服务。 用Win32应用程序里的 CreateFile API。你在调用CreateFile时,你的动态VxD要以下面的格式填写: \\.\VxD完整路径名 例如,如果你要加载一个在当前目录下名为FirstVxD的动态VxD,你需要做如下的工作: .data VxDName db "\\.\FirstVxD.VxD",0 ...... .data? hDevice dd ? ..... .code ..... invoke CreateFile, addr VxDName,0,0,0,0, FILE_FLAG_DELETE_ON_CLOSE,0 mov hDevice,eax ...... invoke CloseHandle,hDevice ...... FILE_FLAG_DELETE_ON_CLOSE 这个标志用来说明该VxD在CreateFile返回的句柄关闭时被卸载。 如果你用CreateFile来加载一个动态VxD,那么这个动态VxD必须处理w32_DeviceIoControl 消息。当你的动态VxD第一次被CreateFile函数加载的时候,VWIN32 向你的VxD发出这个消息。你的VxD响应这个消息,返回时eax中的值必须为零。当应用程序调用DeviceIoControl API来与一个动态VxD通讯时,w32_DeviceIoControl消息也被发送。我们会在下一章讲到DeviceIoControl接口。 一个动态VxD在初始化时收到一个消息: Sys_Dynamic_Device_Init 在结束时也收到一个控制消息: Sys_Dynamic_Device_Exit 动态VxD不会收到Sys_Critical_Init, Device_Init和Init_Complete控制消息,因为这些消息是在系统虚拟机初始化时发送的。除了这三个消息,动态VxD能收到所有的控制消息,只要它还在内存里。它可以做静态VxD可以做的所有事情。简单的说,动态VxD除了加载机制和接收到的初始化/结束消息跟静态VxD不同以外,它能做静态VxD所能做的一切。 其它系统控制消息 当VxD在内存里的时候,除了接收和初始化及结束相关的消息外,它还要收到许多别的控制消息。有些消息是关于虚拟机管理器的,有的是关于各种事件的。例如,关于虚拟机的消息如下: Create_VM VM_Critical_Init VM_Suspend VM_Resume Close_VM_Notify Destroy_VM 选择地响应你所感兴趣的消息是你自己的责任。 在VxD内创建函数 你要在一个段里面定义你的函数。你应该首先定义一个段,然后把你的函数放进去。例如,如果你要把你的函数放到一个可调页段中。你应该先定义一个可调页段,像这样: VxD_PAGEABLE_CODE_SEG (你的函数写在这里) VxD_PAGEABLE_CODE_ENDS 你可以在一个段里面插入多个的函数。作为一个VxD编写者,你必须决定每一个函数应该放到哪个段里面去。如果你的函数必须时刻存在于内存中,如某些硬件中断处理程序,就把它们放到锁定页面段里面,否则,你应该把它们放到可调页段。 你要用BeginProc和EndProc 宏来定义你的函数: BeginProc 函数名 EndProc 函数名 使用BeginProc 宏还可以加上一些参数,想了解这些细节,你可以看看Win95 DDK的文档。大多数时候,你只用填写函数的名字就够了。 因为BeginProc-EndProc 宏比proc-endp 指令的功能要强,所以你应该用BeginProc-EndProc宏来代替proc-endp指令 VxD编程约定 寄存器的使用 你的VxD程序可以使用所有的寄存器,FS和GS。但是在改动段寄存器的时候一定要小心。尤其是,一定不要改动CS和SS的内容,除非你对将发生的事情有绝对的把握。你可以使用DS和ES,但一定要记住在返回时恢复它们初值。有两个特征位尤其重要:方向和中断特征位。不要长时间的屏蔽中断。还有如果你要改动方向特征位,不要忘了在返回之前恢复它的初值。 参数传递约定 VxD服务函数有两种调用约定:寄存器法和堆栈法。调用寄存器法服务函数时,你通过各种寄存器来传递服务函数的参数。并且,在调用完成后检查寄存器的值来看操作是否成功。不要总是以为在调用服务函数后主要寄存器的值还和以前一样。当调用堆栈法服务函数时,你把要传递的参数压栈,在eax得到返回值。堆栈调用法的服务函数保存ebx,esi,edi和ebp的值。许多寄存器调用法服务函数都源于Windows3.x的时代。在大多数时候,你可以通过名字来区分这两种服务函数,如果一个函数的名字一下划线开头,如_HeapAllocate,它就是一个堆栈法的服务函数(除了少数从VWIN32.VxD导出的函数)。如果函数名不是一下划线开头,它就是一个寄存器法的服务函数。 调用VxD服务函数 你可以通过VMMCall和VxDCall 宏来调用VMM和VxD服务。这两个宏的语法是一样的。当你要调用VMM导出的VxD服务函数时,用VMMCall。当你要用其它VxD程序导出的VxD服务函数时,用VxDCall。 VMMCall service ; 调用寄存器法服务函数e VMMCall _service, ; 调用堆栈法服务函数 正如我在前面所讲的,VMMCall和VxDCall分解出一个跟着一个双字的20h中断,这样用起来很方便。当你调用堆栈法服务时,你必须用角括号把你的参数列括起来。 VMMCall _HeapAllocate, <, HeapLockedIfDP> _HeapAllocate是一个堆栈法服务函数。它有两个参数,我们必须用角括号把它们括起来。由于第一个参数是一个这个宏不能正确解释的表达式,所以我们又要用一个角括号把它括起来。 Flat地址 在老的编译工具里,当你使用offset 操作符时,编译器和联接器会生成错误地址,所以VxD编写者用offset flat:来代替offset。imm.inc包括了一个使这更简单的宏:OFFSET32 来代替offset flat:。所以如果你要用地址操作时,用OFFSET32 来代替offset操作符。 注意: 当我写这篇教程的时候,我试了一下用offset 操作符。它可以生成正确的地址。所以我想MASM6.14修正了这个bug。但是为了安全起见,你还是应该用OFFSET32宏来代替offset。

TOP

[原创]汇编语言教学

8086/8088指令系统 一、数据传送指令 1.通用数据传送指令 MOV(Move)传送 PUSH(Push onto the stack)进栈 POP(Pop from the stack)出栈 XCHG(Exchange)交换 .MOV指令 格式为: MOV DST,SRC 执行的操作:(DST)<-(SRC) .PUSH进栈指令 格式为:PUSH SRC 执行的操作:(SP)<-(SP)-2 ((SP)+1,(SP))<-(SRC) .POP出栈指令 格式为:POP DST 执行的操作:(DST)<-((SP+1),(SP)) (SP)<-(SP)+2 .XCHG 交换指令 格式为:XCHG OPR1,OPR2 执行的操作:(OPR1)<-->(OPR2) 2.累加器专用传送指令 IN(Input) 输入 OUT(Output) 输出 XLAT(Translate) 换码 这组指令只限于使用累加器AX或AL传送信息. .IN 输入指令 长格式为: IN AL,PORT(字节) IN AX,PORT(字) 执行的操作: (AL)<-(PORT)(字节) (AX)<-(PORT+1,PORT)(字) 短格式为: IN AL,DX(字节) IN AX,DX(字) 执行的操作: AL<-((DX))(字节) AX<-((DX)+1,DX)(字) .OUT 输出指令 长格式为: OUT PORT,AL(字节) OUT PORT,AX(字) 执行的操作: (PORT)<-(AL)(字节) (PORT+1,PORT)<-(AX)(字) 短格式为: OUT DX,AL(字节) OUT DX,AX(字) 执行的操作: ((DX))<-(AL)(字节) ((DX)+1,(DX))<-AX(字) 在IBM-PC机里,外部设备最多可有65536个I/O端口,端口(即外设的端口地址)为0000~FFFFH.其中前256个端口(0~FFH)可以直接在指令中指定,这就是长格式中的PORT,此时机器指令用二个字节表示,第二个字节就是端口号.所以用长格式时可以在指定中直接指定端口号,但只限于前256个端口.当端口号>=256时,只能使用短格式,此时,必须先把端口号放到DX寄存器中(端口号可以从0000到0FFFFH),然后再用IN或OUT指令来 传送信息. .XLAT 换码指令 格式为: XLAT OPR 或: XLAT 执行的操作:(AL)<-((BX)+(AL)) 3.有效地址送寄存器指令 LEA(Load effective address)有效地址送寄存器 LDS(Load DS with Pointer)指针送寄存器和DS LES(Load ES with Pointer)指针送寄存器和ES .LEA 有效地址送寄存器 格式为: LEA REG,SRC 执行的操作:(REG)<-SRC 指令把源操作数的有效地址送到指定的寄存器中. .LDS 指针送寄存器和DS指令 格式为: LDS REG,SRC 执行的操作:(REG)<-(SRC) (DS)<-(SRC+2) 把源操作数指定的4个相继字节送到由指令指定的寄存器及DS寄存器中.该指令常指定SI寄存器. .LES 指针送寄存器和ES指令 格式为: LES REG,SRC 执行的操作: (REG)<-(SRC) (ES)<-(SRC+2) 把源操作数指定的4个相继字节送到由指令指定的寄存器及ES寄存器中.该指令常指定DI寄存器. 4.标志寄存器传送指令 LAHF(Load AH with flags)标志送AH SAHF(store AH into flags)AH送标志寄存器 PUSHF(push the flags) 标志进栈 POPF(pop the flags) 标志出栈 .LAHF 标志送AH 格式为: LAHF 执行的操作:(AH)<-(PWS的低字节) .SAHF AH送标志寄存器 格式为: SAHF 执行的操作:(PWS的低字节)<-(AH) .PUSHF 标志进栈 格式为: PUSHF 执行的操作:(SP)<-(SP)-2 ((SP)+1,(SP))<-(PSW) .POPF 标志出栈 格式为: POPF 执行的操作:(PWS)<-((SP)+1,(SP)) (SP)<-(SP+2) 二、算术指令 1.加法指令 ADD(add)加法 ADC(add with carry)带进位加法 INC(increment)加1 .ADD 加法指令 格式: ADD DST,SRC 执行的操作:(DST)<-(SRC)+(DST) .ADC 带进位加法指令 格式: ADC DST,SRC 执行的操作:(DST)<-(SRC)+(DST)+CF .ADD 加1指令 格式: INC OPR 执行的操作:(OPR)<-(OPR)+1 2.减法指令 SUB(subtract)减法 SBB(subtract with borrow)带借位减法 DEC(Decrement)减1 NEG(Negate)求补 CMP(Compare)比较 .SUB 减法指令 格式: SUB DST,SRC 执行的操作:(DST)<-(DST)-(SRC) .SBB 带借位减法指令 格式: SBB DST,SRC 执行的操作:(DST)<-(DST)-(SRC)-CF .DEC 减1指令 格式: DEC OPR 执行的操作:(OPR)<-(OPR)-1 .NEG 求补指令 格式: NEG OPR 执行的操作:(OPR)<- -(OPR) .CMP 比较指令 格式: CMP OPR1,OPR2 执行的操作:(OPR1)-(OPR2) 该指令与SUB指令一样执行减法操作,但不保存结果,只是根据结果设置条件标志西半球. 3.乘法指令 MUL(Unsigned Multiple)无符号数乘法 IMUL(Signed Multiple)带符号数乘法 .MUL 无符号数乘法指令 格式: MUL SRC 执行的操作: 字节操作数:(AX)<-(AL)*(SRC) 字操作数:(DX,AX)<-(AX)*(SRC) .IMUL 带符号数乘法指令 格式: IMUL SRC 执行的操作:与MUL相同,但必须是带符号数,而MUL是无符号数. 4.除法指令 DIV(Unsigned divide)无符号数除法 IDIV(Signed divide)带符号数除法 CBW(Convert byte to word)字节转换为字 CWD(Contert word to double word)字转换为双字 .DIV 无符号数除法指令 格式: DIV SRC 执行的操作: 字节操作:(AL)<-(AX)/(SRC)的商 (AH)<-(AX)/(SRC)的余数 字操作: (AX)<-(DX,AX)/(SRC)的商 (AX)<-(DX,AX)/(SRC)的余数 .IDIV 带符号数除法指令 格式: DIV SRC 执行的操作:与DIV相同,但操作数必须是带符号数,商和余数也均为带符号数,且余数的符号与被除数的符号相同. .CBW 字节转换为字指令 格式: CBW 执行的操作:AL的内容符号扩展到AH.即如果(AL)的最高有效位为0,则(AH)=00;如(AL)的最高有效位为1,则(AH)=0FFH .CWD 字转换为双字指令 格式: CWD 执行的操作:AX的内容符号扩展到DX.即如(AX)的最高有效位为0,则(DX)=0;否则(DX)=0FFFFH. 这两条指令都不影响条件码. 三、逻辑指令 1.逻辑运算指令 AND(and) 逻辑与 OR(or) 逻辑或 NOT(not) 逻辑非 XOR(exclusive or)异或 TEST(test) 测试 .AND 逻辑与指令 格式: AND DST,SRC 执行的操作:(DST)<-(DST)^(SRC) .OR 逻辑或指令 格式: OR DST,SRC 执行的操作:(DST)<-(DST)V(SRC) .NOT 逻辑非指令 格式: NOT OPR 执行的操作:(OPR)<-(OPR) .XOR 异或指令 格式: XOR DST,SRC 执行的操作:(DST)<-(DST)V(SRC) .TEST 测试指令 格式: TEST OPR1,OPR2 执行的操作:(DST)^(SRC) 两个操作数相与的结果不保存,只根据其特征置条件码 2.移位指令 SHL(shift logical left) 逻辑左移 SAL(shift arithmetic left) 算术左移 SHR(shift logical right) 逻辑右移 SAR(shift arithmetic right) 算术右移 ROL(Rotate left) 循环左移 ROR(Rotate right) 循环右移 RCL(Rotate left through carry) 带进位循环左移 RCR(Rotate right through carry) 带进位循环右移 格式: SHL OPR,CNT(其余的类似) 其中OPR可以是除立即数以外的任何寻址方式.移位次数由CNT决定,CNT可以是1或CL. 循环移位指令可以改变操作数中所有位的位置;移位指令则常常用来做乘以2除以2操作.其中算术移位指令适用于带符号数运算,SAL用来乘2,SAR用来除以2;而逻辑移位指令则用来无符号数运算,SHL用来乘2,SHR用来除以2. 四、串处理指令 1.与REP相配合工作的MOVS,STOS和LODS指令 .REP重复串操作直到(CX)=0为上 格式: REP string primitive 其中String Primitive可为MOVS,LODS或STOS指令 执行的操作: 1)如(CX)=0则退出REP,否则往下执行. 2)(CX)<-(CX)-1 3)执行其中的串操作 4)重复1)~3) .MOVS 串传送指令 格式:可有三种 MOVS DST,SRC MOVSB(字节) MOVSW(字) 其中第二、三种格式明确地注明是传送字节或字,第一种格式则应在操作数中表明是字还是字节操作,例如: MOVS ES:BYTE PTR[DI],DS:[SI] 执行的操作: 1)((DI))<-((SI)) 2)字节操作: (SI)<-(SI)+(或-)1,(DI)<-(DI)+(或-)1 当方向标志DF=0时用+,当方向标志DF=1时用- 3)字操作: (SI)<-(SI)+(或-)2,(DI)<-(DI)+(或-)2 当方向标志DF=0时用+,当方向标志DF=1时用- 该指令不影响条件码. .CLD(Clear direction flag)该指令使DF=0,在执行串操作指令时可使地址自动增量; .STD(Set direction flag)该指令使DF=1,在执行串操作指令时可使地址自动减量. .STOS 存入串指令 格式: STOS DST STOSB(字节) STOSW(字) 执行的操作: 字节操作:((DI))<-(AL),(DI)<-(DI)+-1 字操作: ((DI))<-(AX),(DI)<-(DI)+-2 该指令把AL或AX的内容存入由(DI)指定的附加段的某单元中,并根据DF的值及数据类型修改DI的内容,当它与REP联用时,可把AL或AX的内容存入一个长度为(CX)的缓冲区中. .LODS 从串取指令 格式: LODS SRC LODSB LODSW 执行的操作: 字节操作:(AL)<-((SI)),(SI)<-(SI)+-1 字操作: (AX)<-((SI)),(SI)<-(SI)+-2 该指令把由(SI)指定的数据段中某单元的内容送到AL或AX中,并根据方向标志及数据类型修改SI的内容.指令允许使用段跨越前缀来指定非数据段的存储区.该指令也不影响条件码. 一般说来,该指令不和REP联用.有时缓冲区中的一串字符需要逐次取出来测试时,可使用本指令. 2.与REPE/REPZ和REPNZ/REPNE联合工作的CMPS和SCAS指令 .REPE/REPZ 当相等/为零时重复串操作 格式: REPE(或REPZ) String Primitive 其中String Primitive可为CMPS或SCAS指令. 执行的操作: 1)如(CX)=0或ZF=0(即某次比较的结果两个操作数不等)时退出,否则往下执行 2)(CX)<-(CX)-1 3)执行其后的串指令 4)重复1)~3) .REPNE/REPNZ 当不相等/不为零时重复串操作 格式: REPNE(或REPNZ) String Primitive 其中String Primitive可为CMPS或SCAS指令 执行的操作: 除退出条件(CX=0)或ZF=1外,其他操作与REPE完全相同. .CMPS 串比较指令 格式: CMP SRC,DST CMPSB CMPSW 执行的操作: 1)((SI))-((DI)) 2)字节操作:(SI)<-(SI)+-1,(DI)<-(DI)+-1 字操作: (SI)<-(SI)+-2,(DI)<-(DI)+-2 指令把由(SI)指向的数据段中的一个字(或字节)与由(DI)指向的附加段中的一个字(或字节)相减,但不保存结果,只根据结果设置条件码,指令的其它特性和MOVS指令的规定相同. .SCAS 串扫描指令 格式: SCAS DST SCASB SCASW 执行的操作: 字节操作:(AL)-((DI)),(DI)<-(DI)+-1 字操作: (AL)-((DI)),(DI)<-(DI)+-2 该指令把AL(或AX)的内容与由(DI)指定的在附加段中的一个字节(或字)进行比较,并不保存结果,只根据结果置条件码.指令的其他特性和MOVS的规定相同. 五、控制转移指令 1.无条件转移指令 .JMP(jmp) 跳转指令 1)段内直接短转移 格式:JMP SHORT OPR 执行的操作:(IP)<-(IP)+8位位移量 2)段内直接近转移 格式:JMP NEAR PTR OPR 执行的操作:(IP)<-(IP)+16位位移量 3)段内间接转移 格式:JMP WORD PTR OPR 执行的操作:(IP)<-(EA) 4)段间直接(远)转移 格式:JMP FAR PTR OPR 执行的操作:(IP)<-OPR的段内偏移地址 (CS)<-OPR所在段的段地址 5)段间间接转移 格式:JMP DWORD PTR OPR 执行的操作:(IP)<-(EA) (CS)<-(EA+2) 2.条件转移指令 1)根据单个条件标志的设置情况转移 .JZ(或JE)(Jump if zero,or equal) 结果为零(或相等)则转移 格式:JE(或JZ) OPR 测试条件:ZF=1 .JNZ(或JNE)(Jump if not zero,or not equal) 结果不为零(或不相等)则转移 格式:JNZ(或JNE) OPR 测试条件:ZF=0 .JS(Jump if sign) 结果为负则转移 格式: JS OPR 测试条件:SF=1 .JNS(Jump if not sign) 结果为正则转移 格式:JNS OPR 测试条件:SF=0 .JO(Jump if overflow) 溢出则转移 格式: JO OPR 测试条件:OF=1 .JNO(Jump if not overflow) 不溢出则转移 格式: JNO OPR 测试条件:OF=0 .JP(或JPE)(Jump if parity,or parity even) 奇偶位为1则转移 格式: JP OPR 测试条件:PF=1 .JNP(或JPO)(Jump if not parity,or parity odd) 奇偶位为0则转移 格式: JNP(或JPO) OPR 测试条件:PF=0 .JB(或JNAE,JC)(Jump if below,or not above or equal,or carry) 低于,或者不高于或等于,或进位位为1则转移 格式:JB(或JNAE,JC) OPR 测试条件:CF=1 .JNB(或JAE,JNC)(Jump if not below,or above or equal,or not carry) 不低于,或者高于或者等于,或进位位为0则转移 格式:JNB(或JAE,JNC) OPR 测试条件:CF=0 2)比较两个无符号数,并根据比较的结果转移 .JB(或JNAE,JC) 格式:同上 .JNB(或JAE,JNC) 格式:同上 .JBE(或JNA)(Jump if below or equal,or not above) 低于或等于,或不高于则转移 格式:JBE(或JNA) OPR 测试条件:CFVZF=1 .JNBE(或JA)(Jump if not below or equal,or above) 不低于或等于,或者高于则转移 格式:JNBE(或JA) OPR 测试条件:CFVZF=0 3)比较两个带符号数,并根据比较的结果转移 .JL(或LNGE)(Jump if less,or not greater or equal) 小于,或者不大于或者等于则转移 格式:JL(或JNGE) OPR 测试条件:SFVOF=1 .JNL(或JGE)(Jump if not less,or greater or equal)不小于,或者大于或者等于则转移 格式:JNL(或JGE) OPR 测试条件:SFVOF=0 .JLE(或JNG)(Jump if less or equal,or not greater) 小于或等于,或者不大于则转移 格式:JLE(或JNG) OPR 测试条件:(SFVOF)VZF=1 .JNLE(或JG)(Jump if not less or equal,or greater) 不小于或等于,或者大于则转移 格式:JNLE(或JG) OPR 测试条件:(SFVOF)VZF=0 4)测试CX的值为0则转移指令 .JCXZ(Jump if CX register is zero) CX寄存器的内容为零则转移 格式:JCXZ OPR 测试条件:(CX)=0 注:条件转移全为8位短跳! 3.循环指令 .LOOP 循环指令 格式: LOOP OPR 测试条件:(CX)<>0 .LOOPZ/LOOPE 当为零或相等时循环指令 格式: LOOPZ(或LOOPE) OPR 测试条件:(CX)<>0且ZF=1 .LOOPNZ/LOOPNE 当不为零或不相等时循环指令 格式: LOOPNZ(或LOOPNE) OPR 测试条件:(CX)<>0且ZF=0 这三条指令的步骤是: 1)(CX)<-(CX)-1 2)检查是否满足测试条件,如满足则(IP)<-(IP)+D8的符号扩充. 4.子程序 .CALL调用指令 .RET返回指令 5.中断 .INT指令 格式: INT TYPE 或 INT 执行的操作:(SP)<-(SP)-2 ((SP)+1,(SP))<-(PSW) (SP)<-(SP)-2 ((SP)+1,(SP))<-(CS) (SP)<-(SP)-2 ((SP)+1,(SP))<-(IP) (IP)<-(TYPE*4) (CS)<-(TYPE*4+2) .INTO 若溢出则中断 执行的操作:若OF=1则: (SP)<-(SP)-2 ((SP)+1,(SP))<-(PSW) (SP)<-(SP)-2 ((SP)+1,(SP))<-(CS) (SP)<-(SP)-2 ((SP)+1,(SP))<-(IP) (IP)<-(10H) (CS)<-(12H) .IRET 从中断返回指令 格式: IRET 执行的操作:(IP)<-((SP)+1,(SP)) (SP)<-(SP)+2 (CS)<-((SP)+1,(SP)) (SP)<-(SP)+2 (PSW)<-((SP)+1,(SP)) (SP)<-(SP)+2 六、处理机控制指令 1.标志处理指令 .CLC进位位置0指令(Clear carry)CF<-0 .CMC进位位求反指令(Complement carry)CF<-CF .STC进位位置1指令(Set carry)CF<-1 .CLD方向标志置0指令(Clear direction)DF<-0 .STD方向标志置1指令(Set direction)DF<-1 .CLI中断标志置0指令(Clear interrupt)IF<-0 .STI中断标志置1指令(Set interrupt)IF<-0 2.其他处理机控制指令 NOP(No Opreation) 无操作 HLT(Halt) 停机 WAIT(Wait) 等待 ESC(Escape) 换码 LOCK(Lock) 封锁 这些指令可以控制处理机状态.这们都不影响条件码. .NOP 无操作指令 该指令不执行任何操作,其机器码占有一个字节,在调试程序时往往用这条指令占有一定的存储单元,以便在正式运行时用其他指令取代. .HLT停机指令 该指令可使机器暂停工作,使处理机处于停机状态以便等待一次外部中断到来,中断结束后可继续执行下面的程序. .WAIT等待指令 该指令使处理机处于空转状态,它也可以用来等待外部中断的发生,但中断结束后仍返回WAIT指令继续德行. .ESC换码指令 格式ESC mem 其中mem指出一个存储单元,ESC指令把该存储单元的内容送到数据总线去.当然ESC指令不允许使用立即数和寄存器寻址方式.这条指令在使用协处理机(Coprocessor)执行某些操作时,可从存储器指得指令或操作数.协处理机(如8087)则是为了提高速度而可以选配的硬件. .LOCK封锁指令 该指令是一种前缀,它可与其他指令联合,用来维持总线的锁存信号直到与其联合的指令执行完为止.当CPU与其他处理机协同工作时,该指令可避免破坏有用信息.

TOP

[原创]汇编语言教学

第十七课 动态链接库 本课中,我们将学习DLLs,它们到底是什么和如何创建它们。 理论: 如果您编程的时间非常长,就会发现很多的程序之间其实有相当多的重复代码。每编一个程序就重写一遍这些代码既没必要又浪费时间。在DOS时代,一般的做法是把这些重复的代码写成一个个的函数,然后把它们按类别放到不同的库文件中去。当要使用这些函数时,只要把您的目标文件(.obj)文件和先前存放在库文件中的函数进行链接,链接时链接器会从库文件中抽取相关的信息并把它们插入到可执行文件中去。这个过程叫做静态链接。C运行时库就是一个好例子。这样的库的缺点是您在每一个调用库函数的程序中都必须嵌入同一函数的拷贝,这显然很浪费磁盘。在DOS时代毕竟每一时刻仅有一个程序在运行,所以浪费的还只是磁盘而已,在多任务的WINDOWS时代就不仅浪费磁盘,还要浪费宝贵的内存了。 在WINDOWS中,由于有多个程序同时运行,如果您的程序非常大的话,那将消耗相当多的内存。WINDOWS的解决办法是:使用动态链接库。动态链接库从表面上看也是一大堆的通用函数,不过即使有多个程序调用了它,在内存中也仅仅只有动态链接库的唯一一份拷贝。WINDOWS是通过分页机制来作到这一点的。当然,库的代码只有一份,但是每一个应用程序要有自己单独的数据段,要么就会乱掉。 不象旧时的静态链接库,它并不会把这些函数的可执行代码放入到应用程序中去,而是当程序已经在内存中运行时,如果需要调用该函数时才调入内存也即链接。这也就是为什么把它叫做“动态”的原因所在。另外您还可以动态地卸载动态链接库,当然要求这时没有其它的应用程序在使用它,否则就要一直等到最后一个使用它的函数也不再使用该动态链接库时才能去卸载它。 为了正确的调用库和给库函数分配内存空间,在编译和链接应用程序时,必须把重定位等一些消息插入到执行代码中去,以便载入正确的库,并给库函数分配正确的地址。 那么这些信息从哪里得到呢?引入库。引入库包含足够的信息,链接器从中抽取足够的信息(注意区别:静态链接库放入的是可执行代码)把它们放入到可执行文件中去。当WINDOWS的加载器装入应用程序查看到有DLL时,它会查找该库文件,如果没有查到,就报错退出,否则就把它映射进进程的地址空间,并修正函数调用语句的地址。 如果没有引入库呢?当然我们也可以调用动态链接库中的任意函数。只不过您必须知道调用的函数是否在库中而且是否在库的引出名字表中,另外还需要知道该函数的参数个数和参数的类型。 (译者加:说到这里,让我想起了一件很有名的事。<>一书的作者Angel Schudleman 曾经利用此方法来跟踪微软Win3x系统动态链接库中未公开的函数,因为在微软给程序员提供的系统动态链接库的引入库中没有提供这些函数的原型,所以您无法在链接时把这些函数的信息链接到可执行文件中去,而为了某种目的您又要使用这些函数,您就可以在执行时加载动态链接库并得到这些函数的地址,从而和调用其它的库函数一样使用这些未公开的函数。由于这本书的巨大影响,当时许多程序员纷纷在它们的程序中调用未公开函数,甚至在写商业程序时也这么做。这种走偏峰的做法引起了微软的反感,后来微软在它Win3x的改进版中不再把那些未公开函数列入系统动态链接库的引出名字表,这样也就无法再利用这种方法来调用未公开的函数了。) 当您让系统的加载器为您加载动态库时,如果不能找到库文件,它就会提示一条“A required .DLL file, xxxxx.dll is missing”,这样您的应用程序就无法运行,即使该库对您的应用程序来说并不重要。 如果您选择在程序运行时自己加载该库,就没有这种问题了。 如果您知道足够的信息,就可以调用系统未公开的函数。 如果您调用LoadLibrary函数加载库,就必须再调用GetProcAddress函数来得到每一个您想调用的函数的地址,GetProcAddress会在动态链接库中查找函数的入口地址。由于多余的步骤,这样您的程序执行起来会慢一点,但是并不明显。 明白了LoadLibrary函数的优缺点,下面我们就来看看如何产生一个动态链接库。下面的代码是一个动态链接库的框架: ;-------------------------------------------------------------------------------------- ; DLLSkeleton.asm ;-------------------------------------------------------------------------------------- .386 .model flat,stdcall option casemap:none include \masm32\include\windows.inc include \masm32\include\user32.inc include \masm32\include\kernel32.inc includelib \masm32\lib\user32.lib includelib \masm32\lib\kernel32.lib .data .code DllEntry proc hInstDLL:HINSTANCE, reason:DWORD, reserved1:DWORD mov eax,TRUE ret DllEntry Endp ;--------------------------------------------------------------------------------------------------- ;下面是一个空函数,您可以象下面一样插入您的函数。 ;---------------------------------------------------------------------------------------------------- TestFunction proc ret TestFunction endp End DllEntry ;------------------------------------------------------------------------------------- ; DLLSkeleton.def ;------------------------------------------------------------------------------------- LIBRARY DLLSkeleton EXPORTS TestFunction 上面是一个动态链接库的框架,每一个DLL必须有一个入口点函数,WINDOWS每一次在做下面的动作时会调用该入口点函数: 当动态链接库被加载时 当动态链接库卸载时 同一进程的线程生成时 同一进程的线程退出时 DllEntry proc hInstDLL:HINSTANCE, reason:DWORD, reserved1:DWORD mov eax,TRUE ret DllEntry Endp 入口点函数的名称无所谓只要您让语句“END<函数名>”中的函数名和前面的相同就可以了。该函数共有三个参数,只有前面两个是重要的。 hInstDLL是该动态链接库模块的句柄。它和进程的实例句柄不一样。如果您以后要用,可以保存它,因为以后再要获得它不容易。 根据不同的时机,reason传入的值可能是下面的四个值中的一个: DLL_PROCESS_ATTACH 动态链接库第一次插入进程的地址空间时。当传入的参数是该值时,您可以做一些初始化的工作。 DLL_PROCESS_DETACH 动态链接库从进程的地址空间卸出时。您可以在此做一些清理的工作。譬如:释放内存等。 DLL_THREAD_ATTACH 新线程生成。 DLL_THREAD_DETACH 线程销毁。 如果想要库中的代码继续执行,返回TRUE,否则返回FALSE,那样动态链接库就不会加载了。譬如:您想分配一块内存,如果不成功的话就退出,这时您就可以返回FALSE。那样动态链接库就不会加载了。 您可以加入的函数,它们的位置并不重要,把它们放在入口点函数的前面或后面都可以。只是如果您想要它们能被其它的程序调用的话,就必须把它们的名字放到模块定义文件(.def)中去。 动态链接库在它们自己的编译过程就需要,而不只是提供给其它要引用它的程序参考。他们如下: LIBRARY DLLSkeleton EXPORTS TestFunction 第一行是必须的。LIBRARY 定义了DLL的模块名称。它必须和动态链接库的名称相同。 EXPORTS关键字告诉链接器该DLL的引出函数,也就是其它程序可以调用的函数。举个例子:其它的程序想要调用函数TestFunction ,我们就把它放到EXPORTS中。 还有就是,链接器的选项中必须放入开关项:/DLL 和/DEF,就像下面这样: link /DLL /SUBSYSTEM:WINDOWS /DEF:DLLSkeleton.def /LIBPATH:c:\masm32\lib DLLSkeleton.obj 编译器的开关选项是一样的,即:/c /coff /Cp。在您链接好后,链接器会生成.lib 和.dll文件。前者是引入库,当其它的程序要调用您的动态链接库中的函数时就需要该引入库,以便把必要的信息加入到其可执行文件中去。 接下来我们来看看如何使用LoadLibrary函数来加载一个DLL。 ;--------------------------------------------------------------------------------------------- ; UseDLL.asm ;---------------------------------------------------------------------------------------------- .386 .model flat,stdcall option casemap:none include \masm32\include\windows.inc include \masm32\include\user32.inc include \masm32\include\kernel32.inc includelib \masm32\lib\kernel32.lib includelib \masm32\lib\user32.lib .data LibName db "DLLSkeleton.dll",0 FunctionName db "TestHello",0 DllNotFound db "Cannot load library",0 AppName db "Load Library",0 FunctionNotFound db "TestHello function not found",0 .data? hLib dd ? ; 动态链接库的句柄 (DLL) TestHelloAddr dd ? ; TestHello 函数的地址 .code start: invoke LoadLibrary,addr LibName ;--------------------------------------------------------------------------------------------------------- ; 调用LoadLibrary,其参数是欲加载的动态链接库的名称。如果调用成功,将返回该DLL的句柄。 否则返回NULL。该句柄可以传给 :library函数和其它需要动态链接库句柄的函数。 ;----------------------------------------------------------------------------------------------------------- .if eax==NULL invoke MessageBox,NULL,addr DllNotFound,addr AppName,MB_OK .else mov hLib,eax invoke GetProcAddress,hLib,addr FunctionName ;----------------------------------------------------------------------------------------------------------- ; 当您得到了动态链接库的句柄后,把它传给GetProcAddress函数,再把您要调用的函数的名称 也传给该函数。如果成功的话,它:会返回想要的函数的地址,失败的话返回NULL。除非卸载该 动态链接库否则函数的地址是不会改变的,所以您可以把它保存到一个:全局变量中以备后用。 ;----------------------------------------------------------------------------------------------------------- .if eax==NULL invoke MessageBox,NULL,addr FunctionNotFound,addr AppName,MB_OK .else mov TestHelloAddr,eax call [TestHelloAddr] ;----------------------------------------------------------------------------------------------------------- ; 以后您就可以和调用其它函数一样调用该函数了。其中要把包含函数地址信息的变量用方括号括起来。 ;----------------------------------------------------------------------------------------------------------- .endif invoke FreeLibrary,hLib ;----------------------------------------------------------------------------------------------------------- ;调用FreeLibrary卸载动态链接库。 ;----------------------------------------------------------------------------------------------------------- .endif invoke ExitProcess,NULL end start 使用LoadLibrary函数加载动态链接库,可能要自己多做一些工作,但是这种方法确实是提供了许多的灵活性。

TOP

[原创]汇编语言教学

第十六课 事件对象
本课中我们将要学习事件对象以及如何在多线程编程中如何使用同步对象。
理论:
上一课中我们演示了如何用WINDOWS消息在不同的线程之间进行通讯。另外的两种,即:使用全局变量和事件对象,将在本课中讲解。
事件对象就像一个开关:它只有两种状态---开和关。当一个事件处于”开”状态,我们称其为”有信号”否则称为”无信号”。您可以在一个线程的执行函数中创建一个事件对象,然后观察它的状态,如果是”无信号”就让该线程睡眠,这样该线程占用的CPU时间就比较少。
产生事件对象的函数如下:
CreateEvent proto lpEventAttributes:DWORD,\
bManualReset:DWORD,\
bInitialState:DWORD,\
lpName:DWORD
lpEventAttribute--> 如果是NULL值,产生的事件对象有缺省的安全属性。
bManualReset--> 如果想在每次调用WaitForSingleObject 后让WINDOWS为您自动地把事件地状态恢复为”无信号”状态,必须把该参数设为FALSE,否则,您必须每次调用ResetEvent函数来清除事件的信号。
bInitialState--> 刚刚产生事件对象时的状态。如果设为TRUE是”有信号”,否则是”无信号”。
lpName --> 事件对象的名称。您在OpenEvent函数中可能使用。
如果CreateEvent调用成功的话,会返回新生成的对象的句柄,否则返回NULL。
这里有两个API函数用来修改事件对象的信号状态:SetEvent和ResetEvent。前者把事件对象设为”有信号”状态,而后者正好相反。
在事件对象生成后,必须调用WaitForSingleObject来让线程进入等待状态,该函数的语法如下:
WaitForSingleObject proto hObject:DWORD, dwTimeout:DWORD
hObject -->指向同步对象的指针。事件对象其实是同步对象的一种。
dwTimeout --> 等待同步对象变成”有信号”前等待的时间,以毫秒计。当等待的时间超过该值后无信号同步对象仍处于”无信号”状态,线程不再等待,WaitForSingleObject函数会返回。如果想要线程一直等待,请把该参数设为INFINITE(该值等于0xffffffff)。
例子:
下面的例子显示了一个窗口,当用户选择了菜单项”run thread”后,线程开始简单的计数运算。结束后弹出一个对话框通知用户。在整个的计数期间,您可以选择菜单项”stop thread”来随时终止线程。
.386
.model flat,stdcall
option casemap:none
WinMain proto :DWORD,:DWORD,:DWORD,:DWORD
include \masm32\include\windows.inc
include \masm32\include\user32.inc
include \masm32\include\kernel32.inc
includelib \masm32\lib\user32.lib
includelib \masm32\lib\kernel32.lib
.const
IDM_START_THREAD equ 1
IDM_STOP_THREAD equ 2
IDM_EXIT equ 3
WM_FINISH equ WM_USER+100h
.data
ClassName db "Win32ASMEventClass",0
AppName db "Win32 ASM Event Example",0
MenuName db "FirstMenu",0
SuccessString db "The calculation is completed!",0
StopString db "The thread is stopped",0
EventStop BOOL FALSE
.data?
hInstance HINSTANCE ?
CommandLine LPSTR ?
hwnd HANDLE ?
hMenu HANDLE ?
ThreadID DWORD ?
ExitCode DWORD ?
hEventStart HANDLE ?
.code
start:
invoke GetModuleHandle, NULL
mov hInstance,eax
invoke GetCommandLine
mov CommandLine,eax
invoke WinMain, hInstance,NULL,CommandLine, SW_SHOWDEFAULT
invoke ExitProcess,eax
WinMain proc hInst:HINSTANCE,hPrevInst:HINSTANCE,CmdLine:LPSTR,CmdShow:DWORD
LOCAL wc:WNDCLASSEX
LOCAL msg:MSG
mov wc.cbSize,SIZEOF WNDCLASSEX
mov wc.style, CS_HREDRAW or CS_VREDRAW
mov wc.lpfnWndProc, OFFSET WndProc
mov wc.cbClsExtra,NULL
mov wc.cbWndExtra,NULL
push hInst
pop wc.hInstance
mov wc.hbrBackground,COLOR_WINDOW+1
mov wc.lpszMenuName,OFFSET MenuName
mov wc.lpszClassName,OFFSET ClassName
invoke LoadIcon,NULL,IDI_APPLICATION
mov wc.hIcon,eax
mov wc.hIconSm,eax
invoke LoadCursor,NULL,IDC_ARROW
mov wc.hCursor,eax
invoke RegisterClassEx, addr wc
invoke CreateWindowEx,WS_EX_CLIENTEDGE,ADDR ClassName,\
ADDR AppName,\
WS_OVERLAPPEDWINDOW,CW_USEDEFAULT,\
CW_USEDEFAULT,300,200,NULL,NULL,\
hInst,NULL
mov hwnd,eax
invoke ShowWindow, hwnd,SW_SHOWNORMAL
invoke UpdateWindow, hwnd
invoke GetMenu,hwnd
mov hMenu,eax
.WHILE TRUE
invoke GetMessage, ADDR msg,NULL,0,0
.BREAK .IF (!eax)
invoke TranslateMessage, ADDR msg
invoke DispatchMessage, ADDR msg
.ENDW
mov eax,msg.wParam
ret
WinMain endp
WndProc proc hWnd:HWND, uMsg:UINT, wParam:WPARAM, lParam:LPARAM
.IF uMsg==WM_CREATE
invoke CreateEvent,NULL,FALSE,FALSE,NULL
mov hEventStart,eax
mov eax,OFFSET ThreadProc
invoke CreateThread,NULL,NULL,eax,\
NULL,0,\
ADDR ThreadID
invoke CloseHandle,eax
.ELSEIF uMsg==WM_DESTROY
invoke PostQuitMessage,NULL
.ELSEIF uMsg==WM_COMMAND
mov eax,wParam
.if lParam==0
.if ax==IDM_START_THREAD
invoke SetEvent,hEventStart
invoke EnableMenuItem,hMenu,IDM_START_THREAD,MF_GRAYED
invoke EnableMenuItem,hMenu,IDM_STOP_THREAD,MF_ENABLED
.elseif ax==IDM_STOP_THREAD
mov EventStop,TRUE
invoke EnableMenuItem,hMenu,IDM_START_THREAD,MF_ENABLED
invoke EnableMenuItem,hMenu,IDM_STOP_THREAD,MF_GRAYED
.else
invoke DestroyWindow,hWnd
.endif
.endif
.ELSEIF uMsg==WM_FINISH
invoke MessageBox,NULL,ADDR SuccessString,ADDR AppName,MB_OK
.ELSE
invoke DefWindowProc,hWnd,uMsg,wParam,lParam
ret
.ENDIF
xor eax,eax
ret
WndProc endp
ThreadProc PROC USES ecx Param:DWORD
invoke WaitForSingleObject,hEventStart,INFINITE
mov ecx,600000000
.WHILE ecx!=0
.if EventStop!=TRUE
add eax,eax
dec ecx
.else
invoke MessageBox,hwnd,ADDR StopString,ADDR AppName,MB_OK
mov EventStop,FALSE
jmp ThreadProc
.endif
.ENDW
invoke PostMessage,hwnd,WM_FINISH,NULL,NULL
invoke EnableMenuItem,hMenu,IDM_START_THREAD,MF_ENABLED
invoke EnableMenuItem,hMenu,IDM_STOP_THREAD,MF_GRAYED
jmp ThreadProc
ret
ThreadProc ENDP
end start
分析:
本例中,我们演示另一种技巧:
.IF uMsg==WM_CREATE
invoke CreateEvent,NULL,FALSE,FALSE,NULL
mov hEventStart,eax
mov eax,OFFSET ThreadProc
invoke CreateThread,NULL,NULL,eax,\
NULL,0,\
ADDR ThreadID
invoke CloseHandle,eax
在WM_CREATE 消息的处理中我们生成事件同步对象并创建线程。我们设置了相关的值让同步对象生成时处于”无信号”状态而且在调用了WaitForSingleObject后可以自动把事件对象的状态设为”无信号”。然后我们创建线程。 线程的代码开始执行后立即被阻塞:
ThreadProc PROC USES ecx Param:DWORD
invoke WaitForSingleObject,hEventStart,INFINITE
mov ecx,600000000
您可以看到线程的执行体的第一条代码就是调用WaitForSingleObject函数,该函数使得线程阻塞并且一直处于等待事件对象变成”有信号”。这也就是说,我们以开始就让该线程进入了睡眠状态。 当用户选择了菜单项”run thread”后,我们把事件对象得状态变成”有信号”:
.if ax==IDM_START_THREAD
invoke SetEvent,hEventStart
函数SetEvent可以让同步对象变成”有信号”状态,那么下一次线程得到时间片运行时,WaitForSingleObject函数就会返回,线程余下的代码就可以得到执行了。当用户选择了菜单项”stop thread” 时,我们把全局变量EventStop设为TRUE。
.if EventStop==FALSE
add eax,eax
dec ecx
.else
invoke MessageBox,hwnd,ADDR StopString,ADDR AppName,MB_OK
mov EventStop,FALSE
jmp ThreadProc
.endif
这样线程得计数工作结束,然后跳转到重新执行WaitForSingleObject函数的地方。注意:我们不用手动清除事件对象的信号,因为在调用CreateEvent函数时把参数bManualReset的值设为了FALSE。

TOP

[原创]汇编语言教学

第十五课 多线程编程
本课中,我们将学习如何进行多线程编程。另外我们还将学习如何在不同的线程间进行通信。
理论:
前一课中,我们学习了进程,其中讲到每一个进程至少要有一个主线程。这个线程其实是进程执行的一条线索,除此主线程外您还可以给进程增加其它的线程,也即增加其它的执行线索,由此在某种程度上可以看成是给一个应用程序增加了多任务功能。当程序运行后,您可以根据各种条件挂起或运行这些线程,尤其在多CPU的环境中,这些线程是并发运行的。这些是在W32下才有的概念,在WIN16下并没有等同的概念。
在同一进程中运行不同的线程的好处是这些线程可以共享进程的资源,如全局变量、资源等。当然各个线程也可以有自己的私有栈用于保存私有数据。另外每个线程需要保存其运行上下文以便在线程切换时能够记住或恢复其上下文,当然这是由操作系统来完成的,对于用户是透明的。
我们大体上可以把线程分成两大类:
处理用户界面的线程:该类线程产生自己的窗口并负责处理相关的窗口消息。用户界面线程遵守WIN16下的互斥原则,即没一刻仅有一个用户界面线程使用USER和GDI库中的内核函数,也就是说当一个用户界面程序在进入GDI或USER中时,内核不允许重入。由此我们可以推论出WIN95的该部分内核的代码是遵守16位模式的。而WINOWS NT是纯的32位操作系统,所以不存在这个问题。
工作者线程:该类线程不用处理窗口界面,当然也就不用处理消息了。它一般都运行在后台干一些计算之类的粗,这大概也是把它叫做工作者线程的原因吧。
运用W32的多线程模式来编程,我们可以遵循某种策略:即让主线程仅来做用户界面的工作,而其它繁重的工作则交由工作者线程在后台完成。这就好比我们日常生活中的许多例子。譬如:政府管理者好比是用户界面线程,它负责听取民意,给职能部门分配工作,然后把工作成果汇报给公众。而具体的职能部门就是工作者线程,它负责完成下达的具体工作。如果让政府管理这来具体地做每一件事,它必须作一件事后再做另一项,那它就不能及时来听取和反馈民意。这样就无法管理好一个国家了。当然即使采用多线程制,政府管理部门也不一定就能管理好国家,但是程序却可以采用多线程机制来管理好她自己的工作。我们可以调用CreateThread函数来生成新线程。该函数的语法如下:
CreateThread proto lpThreadAttributes:DWORD,\
dwStackSize:DWORD,\
lpStartAddress:DWORD,\
lpParameter:DWORD,\
dwCreationFlags:DWORD,\
lpThreadId:DWORD
生成一个线程的函数和生成一个进程基本相同。
lpThreadAttributes -->如果您想要线程有缺省的安全属性,可以置该值为NULL。
dwStackSize --> 指定线程的堆栈大小。如果为0,那线程的大小和进程相同。
lpStartAddress--> 线程函数的起始地址。注意该函数仅接收一个32位的参数和返回一个32位的值。(该参数可以是一个指针,而且进程的线程可以直接存取进程定义全局变量,所以您大可不必担心不能如何把大量的参数传递给线程)。
lpParameter --> 传递给线程的上下文。
dwCreationFlags -->如果是0的话则表示创线程建后立即启动,相反的是标志位CREATE_SUSPENDED,这样您需要稍后显示地让该线程运行。
lpThreadId --> 内核给新生成的线程分配的线程ID。
如果生成线程成功的话,CreateThread函数就返回新线程的句柄。否则返回NULL。
如果没有给参数dwCreationFlags指定CREATE_SUSPENDED的话,该线程就会立即运行。如果不这样,我们上面说了,需要显示地启动该线程,要这样做您需要调用ResumeThread函数。
在线程返回后(线程的执行类似与执行一个函数,如果它调用了最后一条指令后,在汇编中是ret,那么该线程就结束了,除非您让它进入一个循环,譬如我们讲的用户界面线程就是如此,只不过它不退出的原因是进入的循环是在{while ( GetMessage(...))...}中,如果您没有给它传递一个值为0的消息,那它可不会退出),系统会自动调用ExitThread函数透明地处理线程一些退出时的清理工作。当然您可以自己调用该函数,但似乎没有什么意义。要得到退出时的退出码,您可以调用GetExitCodeThread函数。
如果您想结束一个程序,可以调用TerminateThread函数,不过使用该函数要小心行事,因为该函数一旦被调用线程就会退出,这样它就没有机会来做清理自己的工作了。
现在我们来看看线程间的通讯机制。
总的说来一共有三种方法:
使用全局变量
使用Windows消息传递机制
使用事件
上面我们说了线程会共享进程的资源,其中全局变量也包括在内,所以线程可以通过使用全局变量来通讯。但是这种办法的明显的缺点是在有多个线程存取同一个全局变量时,必须考虑同步的问题。譬如:有一个有十个成员变量的结构体,其中一个线程在对起赋值时,假设只更新了五个成员变量的值,这时内核的调度线程剥夺其运行权给另一个线程,这样接下来的线程如果想要用该全局结构体变量,它的值就显然不对了。另外多线程的程序也很难调试,尤其这些错误很隐蔽和很难复现时。如果两个线程都是用户界面线程时,用WINDOWS的消息机制来进行线程间的通讯是比较方便的.
您所要做的只是自定义一些windows消息(注意不要和windows的预定义的消息冲突),然后在线程之间传递可以了。您可以这样来定义消息,把WM_USER(它的值等于0x0400)当作基数,然后顺序地去加序号,譬如:
WM_MYCUSTOMMSG equ WM_USER+100h
小于WM_USER 的值是Windows系统的保留值,大于该值留给用户来使用。
如果其中有一个线程是工作者线程的话,那就不能用该种方法来进行通讯了,这是因为工作者线程没有消息队列。您应当用下面这种策略来进行工作者线程和用户界面线程之间的通讯:
User interface Thread ------> global variable(s)----> Worker thread
Worker Thread ------> custom window message(s) ----> User interface Thread
稍后我们的例子中将讲解这种通讯办法。
最后的办法是事件对象。您可以把事件对象看作是一种标志。如果事件对象的状态是无信号的话,说明该线程正在睡眠或挂起,在该种状态下系统是不会给该线程分配CPU时间片的。当一个线程的状态转成有信号时,WINDOWS就会唤醒该线程并且让它正常运行。
例子:
您可以下载例子并运行thread1.exe,然后激活菜单项"Savage Calculation",然后程序开始执行指令"add eax,eax ",一共执行600,000,000次,您会发现在这个过程当中,用户界面将停止响应,您既不能使用菜单,也不能使用移动窗口。等到计算完成后,会弹出一个对话框,关闭掉对话框后窗口才可以和当初一样正常运行了。
为了避免这种不便,我们把计算的工作放入到一个单独的工作者线程中去,而主窗口仅仅响应用户的活动。您可以看到虽然用户界面的反应比平常时慢了,但还是可以工作的。
.386
.model flat,stdcall
option casemap:none
WinMain proto :DWORD,:DWORD,:DWORD,:DWORD
include \masm32\include\windows.inc
include \masm32\include\user32.inc
include \masm32\include\kernel32.inc
includelib \masm32\lib\user32.lib
includelib \masm32\lib\kernel32.lib
.const
IDM_CREATE_THREAD equ 1
IDM_EXIT equ 2
WM_FINISH equ WM_USER+100h
.data
ClassName db "Win32ASMThreadClass",0
AppName db "Win32 ASM MultiThreading Example",0
MenuName db "FirstMenu",0
SuccessString db "The calculation is completed!",0
.data?
hInstance HINSTANCE ?
CommandLine LPSTR ?
hwnd HANDLE ?
ThreadID DWORD ?
.code
start:
invoke GetModuleHandle, NULL
mov hInstance,eax
invoke GetCommandLine
mov CommandLine,eax
invoke WinMain, hInstance,NULL,CommandLine, SW_SHOWDEFAULT
invoke ExitProcess,eax
WinMain proc hInst:HINSTANCE,hPrevInst:HINSTANCE,CmdLine:LPSTR,CmdShow:DWORD
LOCAL wc:WNDCLASSEX
LOCAL msg:MSG
mov wc.cbSize,SIZEOF WNDCLASSEX
mov wc.style, CS_HREDRAW or CS_VREDRAW
mov wc.lpfnWndProc, OFFSET WndProc
mov wc.cbClsExtra,NULL
mov wc.cbWndExtra,NULL
push hInst
pop wc.hInstance
mov wc.hbrBackground,COLOR_WINDOW+1
mov wc.lpszMenuName,OFFSET MenuName
mov wc.lpszClassName,OFFSET ClassName
invoke LoadIcon,NULL,IDI_APPLICATION
mov wc.hIcon,eax
mov wc.hIconSm,eax
invoke LoadCursor,NULL,IDC_ARROW
mov wc.hCursor,eax
invoke RegisterClassEx, addr wc
invoke CreateWindowEx,WS_EX_CLIENTEDGE,ADDR ClassName,ADDR AppName,\
WS_OVERLAPPEDWINDOW,CW_USEDEFAULT,\
CW_USEDEFAULT,300,200,NULL,NULL,\
hInst,NULL
mov hwnd,eax
invoke ShowWindow, hwnd,SW_SHOWNORMAL
invoke UpdateWindow, hwnd
.WHILE TRUE
invoke GetMessage, ADDR msg,NULL,0,0
.BREAK .IF (!eax)
invoke TranslateMessage, ADDR msg
invoke DispatchMessage, ADDR msg
.ENDW
mov eax,msg.wParam
ret
WinMain endp
WndProc proc hWnd:HWND, uMsg:UINT, wParam:WPARAM, lParam:LPARAM
.IF uMsg==WM_DESTROY
invoke PostQuitMessage,NULL
.ELSEIF uMsg==WM_COMMAND
mov eax,wParam
.if lParam==0
.if ax==IDM_CREATE_THREAD
mov eax,OFFSET ThreadProc
invoke CreateThread,NULL,NULL,eax,\
0,\
ADDR ThreadID
invoke CloseHandle,eax
.else
invoke DestroyWindow,hWnd
.endif
.endif
.ELSEIF uMsg==WM_FINISH
invoke MessageBox,NULL,ADDR SuccessString,ADDR AppName,MB_OK
.ELSE
invoke DefWindowProc,hWnd,uMsg,wParam,lParam
ret
.ENDIF
xor eax,eax
ret
WndProc endp
ThreadProc PROC USES ecx Param:DWORD
mov ecx,600000000
Loop1:
add eax,eax
dec ecx
jz Get_out
jmp Loop1
Get_out:
invoke PostMessage,hwnd,WM_FINISH,NULL,NULL
ret
ThreadProc ENDP
end start

分析:
主程序的主线程是一个用户界面线程,它有一个普通窗口。用户选择菜单项"Create Thread",程序就会产生一个线程:
.if ax==IDM_CREATE_THREAD
mov eax,OFFSET ThreadProc
invoke CreateThread,NULL,NULL,eax,\
NULL,0,\
ADDR ThreadID
invoke CloseHandle,eax
上面的代码段产生一个线程,线程的主体代码是函数ThreadProc,该函数和主线程并行运行。在调用成功后,CreateThread函数立即返回,ThreadProc也开始运行。因为我们不再用线程句柄,我们立即关闭它以避免内存泄漏。我们前面讲过关闭句柄不会终止线程的执行,而只是减少起引用计数。
ThreadProc PROC USES ecx Param:DWORD
mov ecx,600000000
Loop1:
add eax,eax
dec ecx
jz Get_out
jmp Loop1
Get_out:
invoke PostMessage,hwnd,WM_FINISH,NULL,NULL
ret
ThreadProc ENDP
我们看到上面的线程的代码仅仅是做简单的计数工作,因为我们设了一个很大的基数,所以该线程会持续一段您能感觉得到的时间,当结束后它会向主线程发送WM_FINISH消息。WM_FINISH消息是我们自己定义的,它的定义如下:
WM_FINISH equ WM_USER+100h
WM_USER消息是我们能够使用的最小消息值。
显然我们一看到WM_FINISH,就能从字面上理解该消息的意义。主线程接收到该消息后,会弹出一个对话框告诉用户,计算线程已经结束了。
通过线程之间的通讯,用户可以多次选择"Create Thread",那样就可以运行多个计算线程了。
本例子中,线程之间的通讯是单向的。如果您想让主线程也能向工作者线程发送消息的话,譬如加入一个菜单项来控制工作者线程的结束,您可以这样做:
add a menu item saying something like "Kill Thread" in the menu
a global variable which is used as a command flag. TRUE=Stop the thread, FALSE=continue the thread
Modify ThreadProc to check the value of the command flag in the loop.
设立一个全局变量,当线程启动前,我们设置它的值为FALSE,当用户激活了我们加的菜单项时,该值变成TRUE。在线程的代码段ThreadProc中每次减1前,判断该值,如果为TRUE的话线程就结束循环体中的计算并退出线程。

TOP

[原创]汇编语言教学

第十四课 进程 本课中我们将学习:什么是进程?如何产生和终止一个进程? 初步知识: 进程是什么?下面是我从WIN32 API指南中节选的解释: “一个进程是一个正在执行的应用程序,它包含有:私有的虚拟地址空间、代码、数据和其它的操作系统资源,譬如进程可以存取的管道、文件和同步对象等等。” 从上面的定义中您可以看到,一个进程拥有几个对象:地址空间、执行模块和其它该执行程序打开或创建的任何对象或资源。至少,一个进程必须包含可执行模块、私有的地址空间和一个以上的线程。什么是线程呢?一个线程实际上是一个执行单元。当WINDOWS产生一个进程时,它自动为该进程产生一个主线程。该线程通常从模块的第一条指令处开始执行。如果进程需要更多的线程,它可以随后显式地产生。 当WINDWOS 接收到产生进程的消息时,它会为进程生成私有内存地址空间,接着把可执行文件映射到该空间。在WIN32下为进程产生了主进程后,您还可以调用函数CreateProcess来为您的进程产生更多的线程。 CreateProcess的原型如下: CreateProcess proto lpApplicationName:DWORD,\ lpCommandLine:DWORD,\ lpProcessAttributes:DWORD,\ lpThreadAttributes:DWORD,\ bInheritHandles:DWORD,\ dwCreationFlags:DWORD,\ lpEnvironment:DWORD,\ lpCurrentDirectory:DWORD,\ lpStartupInfo:DWORD,\ lpProcessInformation:DWORD 不要被这么多的参数吓倒,其实您可以忽略其中的大多数的参数(让它们有缺省值)。 lpApplicationName --> 可执行文件的名称(含或不含路径)。如果该参数为NULL,那必须在参数lpCommandLine中传递文件名称。 lpCommandLine --> 传递给欲执行的文件的命令行参数。如果lpApplicationName为NULL,那必须在该参数中指定,譬如:"notepad.exe readme.txt" 。 lpProcessAttributes 和 lpthreadAttributes --> 指定进程和主线程的安全属性。您可以把它们都设成为NULL,这样就设置了缺省的安全属性。 bInheritHandles --> 标志位。用来设置新进程是否继承创建进程所有的打开句柄。 dwCreationFlags --> 有几个标志可以在此处设置以决定欲创建进程的行为,譬如:您可能想创建进程后并不想让它立刻运行,这样在它真正运行前可以作一些检查和修改工作。您还可以在此处设置新进程中的所有线程的优先级,通常我们把它设置为NORMAL_PRIORITY_CLASS。 lpEnvironment --> 指向环境块的指针,一般地环境块包含几个环境字符串。如果该参数为NULL,那么新进程继承创建进程的环境块。 lpCurrentDirectory --> 指向当前目录以及为子进程设置的“当前目录”的路径。如果为NULL, 则继承创建进程的“当前目录”路径。 lpStartupInfo --> 指向新进程的启动结构体STARTUPINFO的指针。STARTUPINFO告诉WINDOWS如何显示新进程的外观。该参数有许多的成员变量,如果您不想新进程有什么的特别之处,可以调用GetStartupInfo函数来用创建进程的启动参数来填充STARTUPINFO结构体变量。 lpProcessInformation --> 指向结构体PROCESS_INFORMATION的指针,该结构体变量包含了一些标识该进程唯一性的一些成员变量: PROCESS_INFORMATION STRUCT hProcess HANDLE ? ; handle to the child process hThread HANDLE ? ; handle to the primary thread of the child process dwProcessId DWORD ? ; ID of the child process dwThreadId DWORD ? ; ID of the primary thread of the child process PROCESS_INFORMATION ENDS 进程句柄和进程ID是两个不同的概念。进程ID好似一个唯一值,而进程句柄是调用相关的WINDOWS API 后得到的一个返回值。不能用进程句柄来标识一个进程的唯一性,因为这个值并不唯一。在调用CreateProcess产生新进程后,该进程就被创建,而且CerateProcess函数立即返回。您可以调用函数GetExitCodeProcess来检验进程是否结束。该函数的原型如下: GetExitCodeProcess proto hProcess:DWORD, lpExitCode:DWORD 如果调用成功,lpExitCode中包含了所查询进程的状态码。如果等于STILL_ACTIVE就表明该进程依旧存在。 您可以调用函数TerminateProcess来强制终止一个进程。该函数的原型如下: TerminateProcess proto hProcess:DWORD, uExitCode:DWORD 您可以指定任意一个退出值。用该函数结束一个进程并不好,因为该进程加载的动态连接库并不会得到进程正退出的消息。 例子: 在下面的例子中,当用户选择菜单项“crate process”时我们创建一个新进程。它会去执行“"msgbox.exe”。如果用户想要终止新进程,可以选择菜单项“terminate process”。这时,应用程序检查欲终止的进程是否仍存在,若存在则调用TerminateProcess函数来终止它。 .386 .model flat,stdcall option casemap:none WinMain proto :DWORD,:DWORD,:DWORD,:DWORD include \masm32\include\windows.inc include \masm32\include\user32.inc include \masm32\include\kernel32.inc includelib \masm32\lib\user32.lib includelib \masm32\lib\kernel32.lib .const IDM_CREATE_PROCESS equ 1 IDM_TERMINATE equ 2 IDM_EXIT equ 3 .data ClassName db "Win32ASMProcessClass",0 AppName db "Win32 ASM Process Example",0 MenuName db "FirstMenu",0 processInfo PROCESS_INFORMATION <> programname db "msgbox.exe",0 .data? hInstance HINSTANCE ? CommandLine LPSTR ? hMenu HANDLE ? ExitCode DWORD ? ; contains the process exitcode status from GetExitCodeProcess call. .code start: invoke GetModuleHandle, NULL mov hInstance,eax invoke GetCommandLine mov CommandLine,eax invoke WinMain, hInstance,NULL,CommandLine, SW_SHOWDEFAULT invoke ExitProcess,eax WinMain proc hInst:HINSTANCE,hPrevInst:HINSTANCE,CmdLine:LPSTR,CmdShow:DWORD LOCAL wc:WNDCLASSEX LOCAL msg:MSG LOCAL hwnd:HWND mov wc.cbSize,SIZEOF WNDCLASSEX mov wc.style, CS_HREDRAW or CS_VREDRAW mov wc.lpfnWndProc, OFFSET WndProc mov wc.cbClsExtra,NULL mov wc.cbWndExtra,NULL push hInst pop wc.hInstance mov wc.hbrBackground,COLOR_WINDOW+1 mov wc.lpszMenuName,OFFSET MenuName mov wc.lpszClassName,OFFSET ClassName invoke LoadIcon,NULL,IDI_APPLICATION mov wc.hIcon,eax mov wc.hIconSm,eax invoke LoadCursor,NULL,IDC_ARROW mov wc.hCursor,eax invoke RegisterClassEx, addr wc invoke CreateWindowEx,WS_EX_CLIENTEDGE,ADDR ClassName,ADDR AppName,\ WS_OVERLAPPEDWINDOW,CW_USEDEFAULT,\ CW_USEDEFAULT,300,200,NULL,NULL,\ hInst,NULL mov hwnd,eax invoke ShowWindow, hwnd,SW_SHOWNORMAL invoke UpdateWindow, hwnd invoke GetMenu,hwnd mov hMenu,eax .WHILE TRUE invoke GetMessage, ADDR msg,NULL,0,0 .BREAK .IF (!eax) invoke TranslateMessage, ADDR msg invoke DispatchMessage, ADDR msg .ENDW mov eax,msg.wParam ret WinMain endp WndProc proc hWnd:HWND, uMsg:UINT, wParam:WPARAM, lParam:LPARAM LOCAL startInfo:STARTUPINFO .IF uMsg==WM_DESTROY invoke PostQuitMessage,NULL .ELSEIF uMsg==WM_INITMENUPOPUP invoke GetExitCodeProcess,processInfo.hProcess,ADDR ExitCode .if eax==TRUE .if ExitCode==STILL_ACTIVE invoke EnableMenuItem,hMenu,IDM_CREATE_PROCESS,MF_GRAYED invoke EnableMenuItem,hMenu,IDM_TERMINATE,MF_ENABLED .else invoke EnableMenuItem,hMenu,IDM_CREATE_PROCESS,MF_ENABLED invoke EnableMenuItem,hMenu,IDM_TERMINATE,MF_GRAYED .endif .else invoke EnableMenuItem,hMenu,IDM_CREATE_PROCESS,MF_ENABLED invoke EnableMenuItem,hMenu,IDM_TERMINATE,MF_GRAYED .endif .ELSEIF uMsg==WM_COMMAND mov eax,wParam .if lParam==0 .if ax==IDM_CREATE_PROCESS .if processInfo.hProcess!=0 invoke CloseHandle,processInfo.hProcess mov processInfo.hProcess,0 .endif invoke GetStartupInfo,ADDR startInfo invoke CreateProcess,ADDR programname,NULL,NULL,NULL,FALSE,\ NORMAL_PRIORITY_CLASS,\ NULL,NULL,ADDR startInfo,ADDR processInfo invoke CloseHandle,processInfo.hThread .elseif ax==IDM_TERMINATE invoke GetExitCodeProcess,processInfo.hProcess,ADDR ExitCode .if ExitCode==STILL_ACTIVE invoke TerminateProcess,processInfo.hProcess,0 .endif invoke CloseHandle,processInfo.hProcess mov processInfo.hProcess,0 .else invoke DestroyWindow,hWnd .endif .endif .ELSE invoke DefWindowProc,hWnd,uMsg,wParam,lParam ret .ENDIF xor eax,eax ret WndProc endp end start 分析: 应用程序创建主窗口,保存菜单句柄以备后用。当用户在主菜单中选择了“Process”菜单项后,消息处理过程中接收到WM_INITMENUPOPUP消息,我们在此处修改弹出式菜单中的菜单项的“使能”和“非使能”,以便同一菜单有不同的显示。 .ELSEIF uMsg==WM_INITMENUPOPUP invoke GetExitCodeProcess,processInfo.hProcess,ADDR ExitCode .if eax==TRUE .if ExitCode==STILL_ACTIVE invoke EnableMenuItem,hMenu,IDM_CREATE_PROCESS,MF_GRAYED invoke EnableMenuItem,hMenu,IDM_TERMINATE,MF_ENABLED .else invoke EnableMenuItem,hMenu,IDM_CREATE_PROCESS,MF_ENABLED invoke EnableMenuItem,hMenu,IDM_TERMINATE,MF_GRAYED .endif .else invoke EnableMenuItem,hMenu,IDM_CREATE_PROCESS,MF_ENABLED invoke EnableMenuItem,hMenu,IDM_TERMINATE,MF_GRAYED .endif 我们之所以处理该消息的目的就是让菜单显示时有不同的外观以方便用户的使用。譬如;新进程尚未运行时,我们就变亮(使能)“菜单项“start process”,而变灰(非使能)菜单项“terminate process”。当新进程运行起来后,菜单的外观就应该是相反的。 首先我们调用GetExitCodeProcess函数,其中传入由CreateProcess返回的句柄。如果GetExitCodeProcess返回FALSE,则表示进程尚未运行,我们就让菜单项“terminate process”变灰;如果返回TRUE,表示新进程已经启动了,我们再检测是否正在运行,这通过比较ExitCode是否等于STILL_ACTIVE 来完成,如果相等,表示进程仍在运行,我们就让菜单项“start process”变灰,因为在我们的简单的应用程序中不提供同时运行多个进程的能力。 .if ax==IDM_CREATE_PROCESS .if processInfo.hProcess!=0 invoke CloseHandle,processInfo.hProcess mov processInfo.hProcess,0 .endif invoke GetStartupInfo,ADDR startInfo invoke CreateProcess,ADDR programname,NULL,NULL,NULL,FALSE,\ NORMAL_PRIORITY_CLASS,\ NULL,NULL,ADDR startInfo,ADDR processInfo invoke CloseHandle,processInfo.hThread 当用户选择了菜单项“start process”时,我们先检测结构体PROCESS_INFORMATION中的成员变量hPRocess是否已经关闭。如果是第一次启动应用程序,那该变量为0,因为我们在.data分段定义结构体时已经初始化该值为0。如果该值不为0,则表明新进程已经结束,但是我们尚未关闭该进程的句柄(以减少该进程的引用记数),我们在此处完成该动作。 我们调用GetStartupInfo函数来填充启动信息的结构体变量,而该变量将被传递到CreateProcess函数中去。调用CreateProcess生成新进程,我们不检查该函数的返回值为的是让问题简化一些,在实际应用中,必须做该项工作。在调用CreateProcess后,我们立即关闭在进程信息结构体参数中返回的主线程句柄,关闭线程句柄为的是减少该内核对象的引用记数,否则即使该线程退出后,其内核对象仍惨存在内核中得不到释放,这会引起资源泄露。进程其实也是一样,之所以我们不在该处关闭进程的句柄是因为稍后我们还要用该句柄去得到一些和进程相关的信息,至于线程,我们的应用程序不需要其相关信息。 .elseif ax==IDM_TERMINATE invoke GetExitCodeProcess,processInfo.hProcess,ADDR ExitCode .if ExitCode==STILL_ACTIVE invoke TerminateProcess,processInfo.hProcess,0 .endif invoke CloseHandle,processInfo.hProcess mov processInfo.hProcess,0 当用户选择了菜单项“terminate process”后,我们调用函数GetExitCodeProcess来检查新进程是否还存在,如果还存在我们就调用函数TerminateProcess来结束它。另外我们把它的句柄关闭掉,因为我们再也不用它了。

TOP

[原创]汇编语言教学

第十三课 内存映射文件 本课中我们将要讲解内存映射文件并且演示如何运用它。您将会发现使用内存映射文件是非常简单的。 理论: 如果您仔细地研究了前一课的例子, 就会发现它有一个严重的缺陷:如果您想读的内容大于系统分配的内存块怎么办?如果您想搜索的字符串刚好超过内存块的边界又该如何处理?对于第一个问题,您也许会说,只要不断地读就不解决了吗。至于第二个问题,您又会说在内存块的边界处做一些特别的处理,譬如放上一些标志位就可以了。原理上确实是行得通,但是这随问题复杂程度加深而显得非常难以处理。其中的第二个问题是有名的边界判断问题,程序中许许多多的错误都是由此引起。想一想,如果我们能够分配一个能够容纳整个文件的大内存块该多好啊,这样这两个问题不都迎刃而解了吗?是的,WIN32的内存映射文件确实允许我们分配一个装得下现实中可能存在的足够大的文件的内存。 利用内存映射文件您可以认为操作系统已经为您把文件全部装入了内存,然后您只要移动文件指针进行读写即可了。这样您甚至不需要调用那些分配、释放内存块和文件输入/输出的API函数,另外您可以把这用作不同的进程之间共享数据的一种办法。运用内存映射文件实际上没有涉及实际的文件操作,它更象为每个进程保留一个看得见的内存空间。至于把内存映射文件当成进程间共享数据的办法来用,则要加倍小心,因为您不得不处理数据的同步问题,否则您的应用程序也许很可能得到过时或错误的数据甚至崩溃。本课中我们将主要讲述内存映射文件,将不涉及进程间的同步。WIN32中的内存映射文件应用非常广泛,譬如:即使是系统的核心模块---PE格式文件装载器也用到了内存映射文件,因为PE格式的文件并不是一次性加载到内存中来的,譬如他它在首次加载时只加载必需加载的部分,而其他部分在用到时再加载,这正好可以利用到内存映射文件的长处。实际中的大多数文件存取都和PE加载器类似,所以您在处理该类问题时也应该充分利用内存映射文件。 内存映射文件本身还是有一些局限性的,譬如一旦您生成了一个内存映射文件,那么您在那个会话期间是不能够改变它的大小的。所以内存映射文件对于只读文件和不会影响其大小的文件操作是非常有用的。当然这并不意味着对于会引起改变其大小的文件操作就一定不能用内存影射文件的方法,您可以事先估计操作后的文件的可能大小,然后生成这么大小一块的内存映射文件,然后文件的长度就可以增长到这么一个大小。 我们的解释够多的了,接下来我们就看看实现的细节: 调用CreateFile打开您想要映射的文件。 调用CreateFileMapping,其中要求传入先前CreateFile返回的句柄,该函数生成一个建立在CreateFile函数创建的文件对象基础上的内存映射对象。 调用MapViewOfFile函数映射整个文件的一个区域或者整个文件到内存。该函数返回指向映射到内存的第一个字节的指针。 用该指针来读写文件。 调用UnmapViewOfFile来解除文件映射。 调用CloseHandle来关闭内存映射文件。注意必须传入内存映射文件的句柄。 调用CloseHandle来关闭文件。注意必须传入由CreateFile创建的文件的句柄。 例子: 下面的例子允许用户通过“打开文件”对话框来打开一个文件,然后用内存映射文件来打开该文件,如果成功,窗口的标题条会显示打开的文件的名称,您可以通过选择“File/Save”菜单项来把换名保存。该程序将会把打开的文件的内容存到新文件中去。注意,这整个过程您根本就没有用到GlobalAlloc这样的分配内存的函数。 .386 .model flat,stdcall WinMain proto :DWORD,:DWORD,:DWORD,:DWORD include \masm32\include\windows.inc include \masm32\include\user32.inc include \masm32\include\kernel32.inc include \masm32\include\comdlg32.inc includelib \masm32\lib\user32.lib includelib \masm32\lib\kernel32.lib includelib \masm32\lib\comdlg32.lib .const IDM_OPEN equ 1 IDM_SAVE equ 2 IDM_EXIT equ 3 MAXSIZE equ 260 .data ClassName db "Win32ASMFileMappingClass",0 AppName db "Win32 ASM File Mapping Example",0 MenuName db "FirstMenu",0 ofn OPENFILENAME <> FilterString db "All Files",0,"*.*",0 db "Text Files",0,"*.txt",0,0 buffer db MAXSIZE dup(0) hMapFile HANDLE 0 ; Handle to the memory mapped file, must be ;initialized with 0 because we also use it as ;a flag in WM_DESTROY section too .data? hInstance HINSTANCE ? CommandLine LPSTR ? hFileRead HANDLE ? ; Handle to the source file hFileWrite HANDLE ? ; Handle to the output file hMenu HANDLE ? pMemory DWORD ? ; pointer to the data in the source file SizeWritten DWORD ? ; number of bytes actually written by WriteFile .code start: invoke GetModuleHandle, NULL mov hInstance,eax invoke GetCommandLine mov CommandLine,eax invoke WinMain, hInstance,NULL,CommandLine, SW_SHOWDEFAULT invoke ExitProcess,eax WinMain proc hInst:HINSTANCE,hPrevInst:HINSTANCE,CmdLine:LPSTR,CmdShow:DWORD LOCAL wc:WNDCLASSEX LOCAL msg:MSG LOCAL hwnd:HWND mov wc.cbSize,SIZEOF WNDCLASSEX mov wc.style, CS_HREDRAW or CS_VREDRAW mov wc.lpfnWndProc, OFFSET WndProc mov wc.cbClsExtra,NULL mov wc.cbWndExtra,NULL push hInst pop wc.hInstance mov wc.hbrBackground,COLOR_WINDOW+1 mov wc.lpszMenuName,OFFSET MenuName mov wc.lpszClassName,OFFSET ClassName invoke LoadIcon,NULL,IDI_APPLICATION mov wc.hIcon,eax mov wc.hIconSm,eax invoke LoadCursor,NULL,IDC_ARROW mov wc.hCursor,eax invoke RegisterClassEx, addr wc invoke CreateWindowEx,WS_EX_CLIENTEDGE,ADDR ClassName,\ ADDR AppName, WS_OVERLAPPEDWINDOW,CW_USEDEFAULT,\ CW_USEDEFAULT,300,200,NULL,NULL,\ hInst,NULL mov hwnd,eax invoke ShowWindow, hwnd,SW_SHOWNORMAL invoke UpdateWindow, hwnd .WHILE TRUE invoke GetMessage, ADDR msg,NULL,0,0 .BREAK .IF (!eax) invoke TranslateMessage, ADDR msg invoke DispatchMessage, ADDR msg .ENDW mov eax,msg.wParam ret WinMain endp WndProc proc hWnd:HWND, uMsg:UINT, wParam:WPARAM, lParam:LPARAM .IF uMsg==WM_CREATE invoke GetMenu,hWnd ;Obtain the menu handle mov hMenu,eax mov ofn.lStructSize,SIZEOF ofn push hWnd pop ofn.hWndOwner push hInstance pop ofn.hInstance mov ofn.lpstrFilter, OFFSET FilterString mov ofn.lpstrFile, OFFSET buffer mov ofn.nMaxFile,MAXSIZE .ELSEIF uMsg==WM_DESTROY .if hMapFile!=0 call CloseMapFile .endif invoke PostQuitMessage,NULL .ELSEIF uMsg==WM_COMMAND mov eax,wParam .if lParam==0 .if ax==IDM_OPEN mov ofn.Flags, OFN_FILEMUSTEXIST or \ OFN_PATHMUSTEXIST or OFN_LONGNAMES or\ OFN_EXPLORER or OFN_HIDEREADONLY invoke GetOpenFileName, ADDR ofn .if eax==TRUE invoke CreateFile,ADDR buffer,\ GENERIC_READ ,\ 0,\ NULL,OPEN_EXISTING,FILE_ATTRIBUTE_ARCHIVE,\ NULL mov hFileRead,eax invoke CreateFileMapping,hFileRead,NULL,PAGE_READONLY,0,0,NULL mov hMapFile,eax mov eax,OFFSET buffer movzx edx,ofn.nFileOffset add eax,edx invoke SetWindowText,hWnd,eax invoke EnableMenuItem,hMenu,IDM_OPEN,MF_GRAYED invoke EnableMenuItem,hMenu,IDM_SAVE,MF_ENABLED .endif .elseif ax==IDM_SAVE mov ofn.Flags,OFN_LONGNAMES or\ OFN_EXPLORER or OFN_HIDEREADONLY invoke GetSaveFileName, ADDR ofn .if eax==TRUE invoke CreateFile,ADDR buffer,\ GENERIC_READ or GENERIC_WRITE ,\ FILE_SHARE_READ or FILE_SHARE_WRITE,\ NULL,CREATE_NEW,FILE_ATTRIBUTE_ARCHIVE,\ NULL mov hFileWrite,eax invoke MapViewOfFile,hMapFile,FILE_MAP_READ,0,0,0 mov pMemory,eax invoke GetFileSize,hFileRead,NULL invoke WriteFile,hFileWrite,pMemory,eax,ADDR SizeWritten,NULL invoke UnmapViewOfFile,pMemory call CloseMapFile invoke CloseHandle,hFileWrite invoke SetWindowText,hWnd,ADDR AppName invoke EnableMenuItem,hMenu,IDM_OPEN,MF_ENABLED invoke EnableMenuItem,hMenu,IDM_SAVE,MF_GRAYED .endif .else invoke DestroyWindow, hWnd .endif .endif .ELSE invoke DefWindowProc,hWnd,uMsg,wParam,lParam ret .ENDIF xor eax,eax ret WndProc endp CloseMapFile PROC invoke CloseHandle,hMapFile mov hMapFile,0 invoke CloseHandle,hFileRead ret CloseMapFile endp end start 分析: invoke CreateFile,ADDR buffer,\ GENERIC_READ ,\ 0,\ NULL,OPEN_EXISTING,FILE_ATTRIBUTE_ARCHIVE,\ NULL 当用户选择打开文件时,我们调用CreateFile来打开。注意我们指定GENERIC_READ(一般的读)来表示我们打开的文件只能够读出,把dwShareMode设成0,表示我们不想其他进程在我们操作文件时来存取该文件。 invoke CreateFileMapping,hFileRead,NULL,PAGE_READONLY,0,0,NULL 我们调用CreateFileMapping来在打开的文件的基础上生成内存映射文件。CreateFileMapping的语法如下: CreateFileMapping proto hFile:DWORD,\ lpFileMappingAttributes:DWORD,\ flProtect:DWORD,\ dwMaximumSizeHigh:DWORD,\ dwMaximumSizeLow:DWORD,\ lpName:DWORD 您应当知道该函数并没有必要把整个文件映射到内存中去,您可以用该函数来只映射文件的一部分。您可以在参数dwMaximumSizeHigh和dwMaximumSizeLow中指定内存映射文件的大小,如果您指定的值大于实际的文件,则实际的文件将增长到指定的大小,如果想要映射的内存大小正好和文件的实际大小相等,则把两个参数中都设成为0。您可以设定lpFileMappingAttributes为NULL,让WINDOWS赋予该内存映射文件于缺省的安全属性。 flProtect定义了内存映射文件的保护属性,我们指定它为PAGE_READONLY来规定该内存映射文件只能够读。注意该属性不能和CreateFile中指定的属性相矛盾,否则就不能生成内存映射文件。 lpName指定内存映射文件的名称,如果您想要该内存映射文件同时可以供其它的进程使用,就必须给它取个名称。不过在我们的例子中,只有我们的进程使用该内存映射文件故我们忽略该参数。 mov eax,OFFSET buffer movzx edx,ofn.nFileOffset add eax,edx invoke SetWindowText,hWnd,eax 如果函数CreateFileMapping调用成功,我们把窗口的标题条换成被打开文件的名称。保存在缓冲区中的文件名是带有路径的全文件名,所以为了只显示文件名我们需要利用OPENFILENAME结构体中的成员nFileOffset的值来找到文件名的起始地址。 invoke EnableMenuItem,hMenu,IDM_OPEN,MF_GRAYED invoke EnableMenuItem,hMenu,IDM_SAVE,MF_ENABLED 为了避免用户一次性打开多个文件,我们让“打开文件”菜单项呈灰色显示,使得打开文件的菜单项失效。函数EnableMenuItem可以用来改变菜单项的属性。 之后用户可能保存文件或者直接关闭应用程序。如果用户选择关闭应用程序,则事先必须关闭内存映射文件和打开的文件, 代码如下: .ELSEIF uMsg==WM_DESTROY .if hMapFile!=0 call CloseMapFile .endif invoke PostQuitMessage,NULL 在上面的代码段中,当WINDOWS的消息处理过程接收到WM_DESTROY消息后,它首先检测hMapFile值是否为0。如果不为0则表示相关的文件未关闭,这样就需要调用CloseMapFile来关闭它们。 CloseMapFile PROC invoke CloseHandle,hMapFile mov hMapFile,0 invoke CloseHandle,hFileRead ret CloseMapFile endp 上述过程调用是用来关闭内存映射文件和原来打开的文件的,这样可以使得程序退出时没有资源泄漏。如果用户选择保存文件的话,就弹出一个“保存文件”对话框,当用户输入了新文件的名称后,我们调用CreateFile函数来创建新文件---输出文件。 invoke MapViewOfFile,hMapFile,FILE_MAP_READ,0,0,0 mov pMemory,eax 在输出文件创建后我们调用MapViewOfFile来映射希望映射到内存中的部分。该函数的语法如下: MapViewOfFile proto hFileMappingObject:DWORD,\ dwDesiredAccess:DWORD,\ dwFileOffsetHigh:DWORD,\ dwFileOffsetLow:DWORD,\ dwNumberOfBytesToMap:DWORD dwDesiredAccess用来指定我们想对文件进行的操作。在我们例子中,我们只想读,故指定标志FILE_MAP_READ。 dwFileOffsetHigh 和 dwFileOffsetLow 用来指定打开文件中欲映射的起始偏移位置。我们的例子中想映射整个的文件,故指定它们的值为0。 dwNumberOfBytesToMap 用来指定欲映射的字节数,如果想映射整个的文件,设定该值为0。 调用MapViewOfFile后,我们希望的部分就已经映射到内存中去了。您将得到一个指向起始内存块的指针。 invoke GetFileSize,hFileRead,NULL 调用该函数可以得到文件的大小,其值通过eax传送,如果文件的长度超过4G,那么文件长度DWORD的高值部分(也即超过4G的部分)保存在FileSizeHighWord中。因为我们估计一般的文件将没有这么大,故忽略该值。 invoke WriteFile,hFileWrite,pMemory,eax,ADDR SizeWritten,NULL 把内存映射文件中的数据写到输出文件中去。 invoke UnmapViewOfFile,pMemory 写完后,我们解除映射。 call CloseMapFile invoke CloseHandle,hFileWrite 关闭内存映射文件和输出文件的句柄。 invoke SetWindowText,hWnd,ADDR AppName 恢复窗口的标题条到应用程序的名称。 invoke EnableMenuItem,hMenu,IDM_OPEN,MF_ENABLED invoke EnableMenuItem,hMenu,IDM_SAVE,MF_GRAYED 恢复“打开文件”和“保存文件”菜单项使的可以重新开始新的打开、编辑和保存循环。

TOP

[原创]汇编语言教学

第十一课 内存管理和文件输入/输出 本课中我们将学习基本的内存管理和文件输入/输出操作方面的知识。另外我们还将用上课学的通用对话框作为我们的显示“设备”。 理论: 从用户的角度来看,WIN32的内存管理是非常简单和明了的。每一个应用程序都有自己独立的4G地址空间,这种内存模式叫做“平坦”型地址模式,所有的段寄存器或描述符都指向同样的起始地址,所有的地址偏移都是32位的长度,这样一个应用程序无须变换选择符就可以存取自己的多达4G的地址空间。这种内存管理模式是非常简洁而便于管理的,而且我们再不用和那些令人讨厌的“near”和“far”指针打交道了。 在W16下有两种主要类型的API:全局和局部。“全局”的API 分配在其他的段中,这样从内存角度来看他们是一些“far”(远)函数或者叫远过程调用,“局部”API只要和进程的堆打交道,所以把它们叫做“near”(近)函数或者近过程调用。而在WIN32中,这两种内存模式是相同的,无论您调用GlobalAlloc还是LocalAlloc,结果都是一样。 至于分配和使用内存的过程都是一样的: 调用GlobalAlloc函数分配一块内存,该函数会返回分配的内存句柄。 调用GlobalLock函数锁定内存块,该函数接受一个内存句柄作为参数,然后返回一个指向被锁定的内存块的指针。 您可以用该指针来读写内存。 调用GlobalUnlock函数来解锁先前被锁定的内存,该函数使得指向内存块的指针无效。 调用GlobalFree函数来释放内存块。您必须传给该函数一个内存句柄。 在WIN32中您也可以用“Local”替代内存分配API函数带有“Global”字样的函数中的“Global”,也即用LocalAlloc、LocalLock等。 在调用函数GlobalAlloc时使用GMEM_FIXED标志位可以更进一步简化操作。使用了该标志后,Global/LocalAlloc返回的是指向已分配内存的指针而不是句柄,这样也就不用调用Global/LocalLock来锁定内存了,释放内存时只要直接调用Global/LocalFree就可以了。不过在本课中我们只使用传统的方法,因为其它地方有许多的源代码是用这种方法写的。 WIN32的文件输入/输出API和DOS下的从外表上看几乎一样(译者注:也许不管内部实现多么不同,可以想象所有的文件系统暴露给应用程序编写者的接口的功能应该基本相同),不同的只是把DOS下的中断方式处理文件输入/输出变成了对API函数的调用。以下是基本的步骤: 调用CreateFile函数生成一个文件,该函数可以应用在多方面,除了磁盘文件外,我们还可以用来打开通讯端口、管道、驱动程序或控制台。如果成功的话,会返回指向文件或设备的句柄。然后可以使用该句柄去完成对文件或设备操作。 调用SetFilePointer来把文件指针移到想读写的地方。. 然后调用ReadFile 或 WriteFile来完成实际的读写。这些函数会自己处理文件和内存之间的数据传送,这样免得您自己去做分配内存等繁杂的琐事。 调用CloseHandle来关闭文件。该函数接受一个先前打开的文件句柄。 内容: 下面的代码段演示了:打开一个“打开文件”对话框,用户可以选择打开一个文本文件,然后在一个编辑控件中打开该文本文件的内容,另外用户还可以编辑该文本文件的内容并选择保存。 .386 .model flat,stdcall option casemap:none WinMain proto :DWORD,:DWORD,:DWORD,:DWORD include \masm32\include\windows.inc include \masm32\include\user32.inc include \masm32\include\kernel32.inc include \masm32\include\comdlg32.inc includelib \masm32\lib\user32.lib includelib \masm32\lib\kernel32.lib includelib \masm32\lib\comdlg32.lib .const IDM_OPEN equ 1 IDM_SAVE equ 2 IDM_EXIT equ 3 MAXSIZE equ 260 MEMSIZE equ 65535 EditID equ 1 ; ID of the edit control .data ClassName db "Win32ASMEditClass",0 AppName db "Win32 ASM Edit",0 EditClass db "edit",0 MenuName db "FirstMenu",0 ofn OPENFILENAME <> FilterString db "All Files",0,"*.*",0 db "Text Files",0,"*.txt",0,0 buffer db MAXSIZE dup(0) .data? hInstance HINSTANCE ? CommandLine LPSTR ? hwndEdit HWND ? ; Handle to the edit control hFile HANDLE ? ; File handle hMemory HANDLE ? ;handle to the allocated memory block pMemory DWORD ? ;pointer to the allocated memory block SizeReadWrite DWORD ? ; number of bytes actually read or write .code start: invoke GetModuleHandle, NULL mov hInstance,eax invoke GetCommandLine mov CommandLine,eax invoke WinMain, hInstance,NULL,CommandLine, SW_SHOWDEFAULT invoke ExitProcess,eax WinMain proc hInst:HINSTANCE,hPrevInst:HINSTANCE,CmdLine:LPSTR,CmdShow:SDWORD LOCAL wc:WNDCLASSEX LOCAL msg:MSG LOCAL hwnd:HWND mov wc.cbSize,SIZEOF WNDCLASSEX mov wc.style, CS_HREDRAW or CS_VREDRAW mov wc.lpfnWndProc, OFFSET WndProc mov wc.cbClsExtra,NULL mov wc.cbWndExtra,NULL push hInst pop wc.hInstance mov wc.hbrBackground,COLOR_WINDOW+1 mov wc.lpszMenuName,OFFSET MenuName mov wc.lpszClassName,OFFSET ClassName invoke LoadIcon,NULL,IDI_APPLICATION mov wc.hIcon,eax mov wc.hIconSm,eax invoke LoadCursor,NULL,IDC_ARROW mov wc.hCursor,eax invoke RegisterClassEx, addr wc invoke CreateWindowEx,WS_EX_CLIENTEDGE,ADDR ClassName,ADDR AppName,\ WS_OVERLAPPEDWINDOW,CW_USEDEFAULT,\ CW_USEDEFAULT,300,200,NULL,NULL,\ hInst,NULL mov hwnd,eax invoke ShowWindow, hwnd,SW_SHOWNORMAL invoke UpdateWindow, hwnd .WHILE TRUE invoke GetMessage, ADDR msg,NULL,0,0 .BREAK .IF (!eax) invoke TranslateMessage, ADDR msg invoke DispatchMessage, ADDR msg .ENDW mov eax,msg.wParam ret WinMain endp WndProc proc uses ebx hWnd:HWND, uMsg:UINT, wParam:WPARAM, lParam:LPARAM .IF uMsg==WM_CREATE invoke CreateWindowEx,NULL,ADDR EditClass,NULL,\ WS_VISIBLE or WS_CHILD or ES_LEFT or ES_MULTILINE or\ ES_AUTOHSCROLL or ES_AUTOVSCROLL,0,\ 0,0,0,hWnd,EditID,\ hInstance,NULL mov hwndEdit,eax invoke SetFocus,hwndEdit ;============================================== ; Initialize the members of OPENFILENAME structure ;============================================== mov ofn.lStructSize,SIZEOF ofn push hWnd pop ofn.hWndOwner push hInstance pop ofn.hInstance mov ofn.lpstrFilter, OFFSET FilterString mov ofn.lpstrFile, OFFSET buffer mov ofn.nMaxFile,MAXSIZE .ELSEIF uMsg==WM_SIZE mov eax,lParam mov edx,eax shr edx,16 and eax,0ffffh invoke MoveWindow,hwndEdit,0,0,eax,edx,TRUE .ELSEIF uMsg==WM_DESTROY invoke PostQuitMessage,NULL .ELSEIF uMsg==WM_COMMAND mov eax,wParam .if lParam==0 .if ax==IDM_OPEN mov ofn.Flags, OFN_FILEMUSTEXIST or \ OFN_PATHMUSTEXIST or OFN_LONGNAMES or\ OFN_EXPLORER or OFN_HIDEREADONLY invoke GetOpenFileName, ADDR ofn .if eax==TRUE invoke CreateFile,ADDR buffer,\ GENERIC_READ or GENERIC_WRITE ,\ FILE_SHARE_READ or FILE_SHARE_WRITE,\ NULL,OPEN_EXISTING,FILE_ATTRIBUTE_ARCHIVE,\ NULL mov hFile,eax invoke GlobalAlloc,GMEM_MOVEABLE or GMEM_ZEROINIT,MEMSIZE mov hMemory,eax invoke GlobalLock,hMemory mov pMemory,eax invoke ReadFile,hFile,pMemory,MEMSIZE-1,ADDR SizeReadWrite,NULL invoke SendMessage,hwndEdit,WM_SETTEXT,NULL,pMemory invoke CloseHandle,hFile invoke GlobalUnlock,pMemory invoke GlobalFree,hMemory .endif invoke SetFocus,hwndEdit .elseif ax==IDM_SAVE mov ofn.Flags,OFN_LONGNAMES or\ OFN_EXPLORER or OFN_HIDEREADONLY invoke GetSaveFileName, ADDR ofn .if eax==TRUE invoke CreateFile,ADDR buffer,\ GENERIC_READ or GENERIC_WRITE ,\ FILE_SHARE_READ or FILE_SHARE_WRITE,\ NULL,CREATE_NEW,FILE_ATTRIBUTE_ARCHIVE,\ NULL mov hFile,eax invoke GlobalAlloc,GMEM_MOVEABLE or GMEM_ZEROINIT,MEMSIZE mov hMemory,eax invoke GlobalLock,hMemory mov pMemory,eax invoke SendMessage,hwndEdit,WM_GETTEXT,MEMSIZE-1,pMemory invoke WriteFile,hFile,pMemory,eax,ADDR SizeReadWrite,NULL invoke CloseHandle,hFile invoke GlobalUnlock,pMemory invoke GlobalFree,hMemory .endif invoke SetFocus,hwndEdit .else invoke DestroyWindow, hWnd .endif .endif .ELSE invoke DefWindowProc,hWnd,uMsg,wParam,lParam ret .ENDIF xor eax,eax ret WndProc endp end start -------------------------------------------------------------------------------- 分析: invoke CreateWindowEx,NULL,ADDR EditClass,NULL,\ WS_VISIBLE or WS_CHILD or ES_LEFT or ES_MULTILINE or\ ES_AUTOHSCROLL or ES_AUTOVSCROLL,0,\ 0,0,0,hWnd,EditID,\ hInstance,NULL mov hwndEdit,eax 处理 WM_CREATE消息时,我们创建一个编辑控件。请注意,我们把该控件大小的有关参数都设成0,因为我们稍后将重新设置该编辑控件的大小,使得其覆盖父窗口的整个客户区。 注意:本例中我们没有必要调用ShowWindow来显示编辑控件,因为在创建时在其风格中已设置了WS_VISIBLE标志位,在创建父窗口时也可以使用这个小技巧。 ;============================================== ; Initialize the members of OPENFILENAME structure ;============================================== mov ofn.lStructSize,SIZEOF ofn push hWnd pop ofn.hWndOwner push hInstance pop ofn.hInstance mov ofn.lpstrFilter, OFFSET FilterString mov ofn.lpstrFile, OFFSET buffer mov ofn.nMaxFile,MAXSIZE 创建完编辑控件后,我们初始话ofn变量的成员。因为稍后在保存文件时还要使用该结构体变量,所以此处只初始化要用到的公共部分。WM_CREATE 消息的处理部分是进行这种初始化的绝佳之处。 .ELSEIF uMsg==WM_SIZE mov eax,lParam mov edx,eax shr edx,16 and eax,0ffffh invoke MoveWindow,hwndEdit,0,0,eax,edx,TRUE 当主窗口的客户区部分大小改变时,我们的应用程序将接收到WM_SIZE 消息。当然该窗口第一次显示时,我们也将接收到该消息。要接收到该消息,主窗口必须有CS_VREDRAW和CS_HREDRAW风格。我们应该把缩放编辑控件的动作放到此处。我们要把编辑控件变成和我们的窗口客户区一样大,所以先得要得到父窗口客户区的大小。这些值包含在参数lParam中,lParam的高字部分是客户区的高,底字部分是客户区的宽。然后我们调用MoveWindow函数来重新调整编辑控件的大小,该函数不仅能够移动窗口的位置,而且能够改变窗口的大小。 .if ax==IDM_OPEN mov ofn.Flags, OFN_FILEMUSTEXIST or \ OFN_PATHMUSTEXIST or OFN_LONGNAMES or\ OFN_EXPLORER or OFN_HIDEREADONLY invoke GetOpenFileName, ADDR ofn 当用户选择了File/Open菜单项时,我们填充ofn的其他成员,然后调用GetOpenFileName函数显示一个“打开文件”对话框。 .if eax==TRUE invoke CreateFile,ADDR buffer,\ GENERIC_READ or GENERIC_WRITE ,\ FILE_SHARE_READ or FILE_SHARE_WRITE,\ NULL,OPEN_EXISTING,FILE_ATTRIBUTE_ARCHIVE,\ NULL mov hFile,eax 如果用户选择了一个文件时,我们调用CreateFile函数来打开。我们设置标志位来让该函数的文件能够读写。文件打开后我们把返回的文件句柄保存在一个全局变量中以便以后使用。CreateFile函数应用非常广泛,其原型如下: CreateFile proto lpFileName:DWORD,\ dwDesiredAccess:DWORD,\ dwShareMode:DWORD,\ lpSecurityAttributes:DWORD,\ dwCreationDistribution:DWORD\, dwFlagsAndAttributes:DWORD\, hTemplateFile:DWORD dwDesiredAccess 指定想要进行的操作。 0 打开文件查询它的属性。 GENERIC_READ 打开文件读 GENERIC_WRITE 打开文件写. dwShareMode 指定文件的共享模式。 0 不让其他进程共享,即当您打开该文件后,其他进程欲打开该文件时将失败。 FILE_SHARE_READ 允许其他进程读。 FILE_SHARE_WRITE 允许其他进程写。 lpSecurityAttributes 该属性在WIN95下无效。 dwCreationDistribution 指定欲生成的文件在其已存在和未存在时应做的动作。 CREATE_NEW 生成一个新文件。如果文件已存在则失败。 CREATE_ALWAYS 无论文件是否存在都生成一个新文件。 OPEN_EXISTING 打开存在的文件。如果文件不存在则失败。 OPEN_ALWAYS 打开文件,如果该文件不存在则生成,这和在dwCreationDistribution 中设置 CREATE_NEW标志位一样。 TRUNCATE_EXISTING打开文件。打开时该文件的长度裁减到零(也即完全不要原来的文件了)。这要求调用进程必须有GENERIC_WRITE的权利,如果指定的文件不存在,该函数返回失败。 dwFlagsAndAttributes 指定文件的属性。 FILE_ATTRIBUTE_ARCHIVE 该文件具有一般的归档文件的属性。用户可以用该标志位来标记文件的删除和备份。 FILE_ATTRIBUTE_COMPRESSED 文件或目录是压缩的。对于文件来说是压缩其中的所有数据,而对于目录来说新生成的子目录和文件都要压缩。 FILE_ATTRIBUTE_NORMAL 该文件没有一般的属性集。该标志位只能单独使用。 FILE_ATTRIBUTE_HIDDEN 该文件是隐藏文件,当浏览一般的文件目录时将不显示它。 FILE_ATTRIBUTE_READONLY 该文件是只读文件。应用程序可以读其中的内容,但不可以写。 FILE_ATTRIBUTE_SYSTEM 该文件是系统文件。 invoke GlobalAlloc,GMEM_MOVEABLE or GMEM_ZEROINIT,MEMSIZE mov hMemory,eax invoke GlobalLock,hMemory mov pMemory,eax 文件打开后,我们将分配一块内存供随后的API 函数ReadFile 和 WriteFile使用。我们使用标志GMEM_MOVEABLE来使得WINDOWS总是把内存块移到可靠的内存中去,GMEM_ZEROINIT告诉WINDOWS把刚刚分配的内存置为零。如果GlobalAlloc调用成功的话,会在eax中返回内存块的句柄,我们把该句柄传给GlobalLock函数以得到指向内存块的指针。 invoke ReadFile,hFile,pMemory,MEMSIZE-1,ADDR SizeReadWrite,NULL invoke SendMessage,hwndEdit,WM_SETTEXT,NULL,pMemory 使内存块可用后,我们调用ReadFile函数从文件中读数据。对于第一次打开的文件,文件的指针放在偏移0处,像本例中我们从偏移0处往前读。ReadFile的第一个参数是文件句柄,第二个参数是指向内存块的指针,接下来的参数是要读的数据的长度,第四个参数是一个指向DWORD型的参数的指针,它用来存放实际读的数据的长度。读完了后,我们把这些内容存放到编辑控件中,这要用消息传递来完成,我们把消息WM_SETTEXT传给编辑控件,其中的参数lParam中包含指向内存块的指针。到此处,编辑控件就可以在它的客户区显示文件的内容了。 invoke CloseHandle,hFile invoke GlobalUnlock,pMemory invoke GlobalFree,hMemory .endif 我们不再需要让文件打开了,因为我们的目的是把修改后的数据保存到另一个文件而不是先前的那一个文件中去。所以我们可以调用CloseHandle来关闭文件。接下来我们解锁内存块,再释放它。实际上我们可以暂不释放内存块,而在以后的操作中重新利用。我们为了演示的原由,选择了释放它。 invoke SetFocus,hwndEdit 当打开文件对话框显示在屏幕上时,输入的焦点切换到了该对话框上。所以在该对话框关闭后,我们必须把焦点切换到编辑控件上。 现在打开文件的阶段结束了,用户可以编辑他们打开的文件了。当用户想把修改后的内容保存到磁盘上时,必须选择File/Save菜单项,这时会显示一个保存文件对话框。显示保存文件对话框其实和打开打开文件对话框基本一样。您甚至可以认为他们的不同只是函数名称不一样而已。此处可以复用大多数ofn变量先前设置的成员的值。 mov ofn.Flags,OFN_LONGNAMES or\ OFN_EXPLORER or OFN_HIDEREADONLY 本例中我们将生成一个新文件,所以一定不能有 OFN_FILEMUSTEXIST 和 OFN_PATHMUSTEXIST标志位。dwCreationDistribution 参数应当有CREATE_NEW标志位。 接下来的代码和打开问对话框基本一样。最后调用: invoke SendMessage,hwndEdit,WM_GETTEXT,MEMSIZE-1,pMemory invoke WriteFile,hFile,pMemory,eax,ADDR SizeReadWrite,NULL 现在我们把修改后的数据从编辑控件中写回内存块,再从内存块写回新文件。

TOP

[原创]汇编语言教学

第十一课 进一步学习对话框 本课中我们将进一步学习对话框。特别地我们将要探讨如何把对话框当成输入设备。如果您学习了上一课,那就会发现本课的例子只有少量的改动,就是把我们的对话框窗口附属到主窗口上。另外,我们还要学习通用对话框的用法。 理论: 把对话框当成一个输入设备来用确实是非常地简单,创建完主窗口后,您只要调用函数 CreatedialogParam 或 DialogBoxParam 就可以了,前一个函数只要在对话框的过程处理函数中处理相关的消息就可以,而后者你必须在消息循环段中插入函数 IsDialogMessage 的调用让它来处理键盘的按键逻辑。因为这两个程序段相对来说比较容易,我们就不详解。您可以下载并仔细研究。 下面我们来讨论通用对话框。WINDOWS已经为您准备好了预定义的对话框类,您可以拿来就用,这些通用对话框提供给用户以统一的界面。它们包括:打开文件、打印、选择颜色、字体和搜索等。您应该尽可能地用它们。处理这些对话框的代码在comdlg32.dll中,为了在您的应用程序中使用它们,就必须在链接阶段链接库文件 comdlg32.lib。然后调用其中的相关函数即可。对于打开文件通用对话框,该函数名为 GetOpenFileName,"保存为..."对话框为 GetSaveFileName,打印通用对话框是 PrintDlg, 等等。每一个这样的函数都接收一个指向一个结构体的指针的参数,您可以参考WIN32 API手册得到详细的资料,本课中我将讲解创建和使用打开文件对话框。 下面是打开对话框函数 GetOpenFileName 的原型: GetOpenFileName proto lpofn:DWORD 您可以看到,该函数只有一个参数,即指向结构体OPENFILENAME的指针。当用户选择了一个文件并打开,该函数返回TRUE,否则返回FALSE。接下来我们看看结构体OPENFILENAME的定义: OPENFILENAME STRUCT lStructSize DWORD ? hwndOwner HWND ? hInstance HINSTANCE ? lpstrFilter LPCSTR ? lpstrCustomFilter LPSTR ? nMaxCustFilter DWORD ? nFilterIndex DWORD ? lpstrFile LPSTR ? nMaxFile DWORD ? lpstrFileTitle LPSTR ? nMaxFileTitle DWORD ? lpstrInitialDir LPCSTR ? lpstrTitle LPCSTR ? Flags DWORD ? nFileOffset WORD ? nFileExtension WORD ? lpstrDefExt LPCSTR ? lCustData LPARAM ? lpfnHook DWORD ? lpTemplateName LPCSTR ? OPENFILENAME ENDS 好,我们再来看看该结构体中常用的成员的意义: lStructSize 结构体OPENFILENAME的大小。 hwndOwner 拥有打开对话框的窗口的句柄。 hInstance 拥有该打开文件对话框的应用程序的实例句柄 。 lpstrFilter 以NULL结尾的一个或多个通配符。通配符是成对出现的,前一部分是描述部分,后一部分则是通配符的格式,譬如: FilterString db "All Files (*.*)",0, "*.*",0 db "Text Files (*.txt)",0,"*.txt",0,0 注意:只有每一对中的第二部分是WINDOWS用来过滤所需选择的文件的,另外您必须在该部分后放置一个0,以示字符串的结束。 nFilterIndex 用来指定打开文件对话框第一次打开时所用的过滤模式串,该索引是从1开始算的,即第一个通配符模式的索引是1,第二个是2,譬如上面的例子中,若指定该值为2,则缺省显示的模式串就是"*.txt"。 lpstrFile 需要打开的文件的名称的地址,该名称将会出现在打开文件对话框的编辑控件中,该缓冲区不能超过260个字符长,当用户打开文件后,该缓冲区中包含该文件的全路径名,您可以从该缓冲区中抽取您所需要的路径或文件名等信息。 nMaxFile lpstrFile的大小。 lpstrTitle 指向对话框标题的字符串。 Flags 该标志决定决定了对话框的风格和特点。 nFileOffset 在用户打开了一个文件后该值是全路径名称中指向文件名第一个字符的索引。譬如:若全路径名为"c:\windows\system\lz32.dll", 则该值为18。 nFileExtension 在用户打开了一个文件后该值是全路径名称中指向个文件扩展名第一个字符的索引。 例子: 下例中,我们演示了当用户选择"File->Open"时,将弹出一个打开文件对话框,当用户选择了某个文件打开时,会弹出一个对话框,告知要打开的文件的全路径名,文件名和文件扩展名。 .386 .model flat,stdcall option casemap:none WinMain proto :DWORD,:DWORD,:DWORD,:DWORD include \masm32\include\windows.inc include \masm32\include\user32.inc include \masm32\include\kernel32.inc include \masm32\include\comdlg32.inc includelib \masm32\lib\user32.lib includelib \masm32\lib\kernel32.lib includelib \masm32\lib\comdlg32.lib .const IDM_OPEN equ 1 IDM_EXIT equ 2 MAXSIZE equ 260 OUTPUTSIZE equ 512 .data ClassName db "SimpleWinClass",0 AppName db "Our Main Window",0 MenuName db "FirstMenu",0 ofn OPENFILENAME <> FilterString db "All Files",0,"*.*",0 db "Text Files",0,"*.txt",0,0 buffer db MAXSIZE dup(0) OurTitle db "-=Our First Open File Dialog Box=-: Choose the file to open",0 FullPathName db "The Full Filename with Path is: ",0 FullName db "The Filename is: ",0 ExtensionName db "The Extension is: ",0 OutputString db OUTPUTSIZE dup(0) CrLf db 0Dh,0Ah,0 .data? hInstance HINSTANCE ? CommandLine LPSTR ? .code start: invoke GetModuleHandle, NULL mov hInstance,eax invoke GetCommandLine mov CommandLine,eax invoke WinMain, hInstance,NULL,CommandLine, SW_SHOWDEFAULT invoke ExitProcess,eax WinMain proc hInst:HINSTANCE,hPrevInst:HINSTANCE,CmdLine:LPSTR,CmdShow:DWORD LOCAL wc:WNDCLASSEX LOCAL msg:MSG LOCAL hwnd:HWND mov wc.cbSize,SIZEOF WNDCLASSEX mov wc.style, CS_HREDRAW or CS_VREDRAW mov wc.lpfnWndProc, OFFSET WndProc mov wc.cbClsExtra,NULL mov wc.cbWndExtra,NULL push hInst pop wc.hInstance mov wc.hbrBackground,COLOR_WINDOW+1 mov wc.lpszMenuName,OFFSET MenuName mov wc.lpszClassName,OFFSET ClassName invoke LoadIcon,NULL,IDI_APPLICATION mov wc.hIcon,eax mov wc.hIconSm,eax invoke LoadCursor,NULL,IDC_ARROW mov wc.hCursor,eax invoke RegisterClassEx, addr wc invoke CreateWindowEx,WS_EX_CLIENTEDGE,ADDR ClassName,ADDR AppName,\ WS_OVERLAPPEDWINDOW,CW_USEDEFAULT,\ CW_USEDEFAULT,300,200,NULL,NULL,\ hInst,NULL mov hwnd,eax invoke ShowWindow, hwnd,SW_SHOWNORMAL invoke UpdateWindow, hwnd .WHILE TRUE invoke GetMessage, ADDR msg,NULL,0,0 .BREAK .IF (!eax) invoke TranslateMessage, ADDR msg invoke DispatchMessage, ADDR msg .ENDW mov eax,msg.wParam ret WinMain endp WndProc proc hWnd:HWND, uMsg:UINT, wParam:WPARAM, lParam:LPARAM .IF uMsg==WM_DESTROY invoke PostQuitMessage,NULL .ELSEIF uMsg==WM_COMMAND mov eax,wParam .if ax==IDM_OPEN mov ofn.lStructSize,SIZEOF ofn push hWnd pop ofn.hwndOwner push hInstance pop ofn.hInstance mov ofn.lpstrFilter, OFFSET FilterString mov ofn.lpstrFile, OFFSET buffer mov ofn.nMaxFile,MAXSIZE mov ofn.Flags, OFN_FILEMUSTEXIST or \ OFN_PATHMUSTEXIST or OFN_LONGNAMES or\ OFN_EXPLORER or OFN_HIDEREADONLY mov ofn.lpstrTitle, OFFSET OurTitle invoke GetOpenFileName, ADDR ofn .if eax==TRUE invoke lstrcat,offset OutputString,OFFSET FullPathName invoke lstrcat,offset OutputString,ofn.lpstrFile invoke lstrcat,offset OutputString,offset CrLf invoke lstrcat,offset OutputString,offset FullName mov eax,ofn.lpstrFile push ebx xor ebx,ebx mov bx,ofn.nFileOffset add eax,ebx pop ebx invoke lstrcat,offset OutputString,eax invoke lstrcat,offset OutputString,offset CrLf invoke lstrcat,offset OutputString,offset ExtensionName mov eax,ofn.lpstrFile push ebx xor ebx,ebx mov bx,ofn.nFileExtension add eax,ebx pop ebx invoke lstrcat,offset OutputString,eax invoke MessageBox,hWnd,OFFSET OutputString,ADDR AppName,MB_OK invoke RtlZeroMemory,offset OutputString,OUTPUTSIZE .endif .else invoke DestroyWindow, hWnd .endif .ELSE invoke DefWindowProc,hWnd,uMsg,wParam,lParam ret .ENDIF xor eax,eax ret WndProc endp end start -------------------------------------------------------------------------------- 分析: mov ofn.lStructSize,SIZEOF ofn push hWnd pop ofn.hwndOwner push hInstance pop ofn.hInstance 我们在此填充结构体OPENFILENAME变量ofn的有关成员。 mov ofn.lpstrFilter, OFFSET FilterString 这里FilterString 是文件过滤模式的字符串地址,我们指定的过滤模式字符串如下: FilterString db "All Files",0,"*.*",0 db "Text Files",0,"*.txt",0,0 注意:所有的模式串都是配对的,前一个是描述,后一个才是真正的模式,次处"*.*"和"*.txt"是WIONDOWS用来寻找匹配的欲打开的文件的。我们当能可以指定任何模式,但是不要忘记在结尾处加0以代表字符串已结束,否则您的对话框在操作时可能不稳定。 mov ofn.lpstrFile, OFFSET buffer mov ofn.nMaxFile,MAXSIZE 这里是把缓冲区的地址放到结构体中,同时必须设定大小。以后我们可以随意编辑在该缓冲区中返回的信息。 mov ofn.Flags, OFN_FILEMUSTEXIST or \ OFN_PATHMUSTEXIST or OFN_LONGNAMES or\ OFN_EXPLORER or OFN_HIDEREADONLY Flags 中放入的是对话框的风格和特性值。 其中OFN_FILEMUSTEXIST和 OFN_PATHMUSTEXIST要求用户在打开对话框的编辑控件中输入的文件名或路径名必须存在。 OFN_LONGNAMES 告诉对话框显示长文件名。 OFN_EXPLORER 告诉WINDOWS对话框的外观必须类似资源管理器。 OFN_HIDEREADONLY 指定不要显示只读文件(既使它的扩展名符合过滤模式)。 除此之外,还有许多其它的标志位,您可以参考有关WIN32 API手册。 mov ofn.lpstrTitle, OFFSET OurTitle 指定打开文件对话框的标题名。 invoke GetOpenFileName, ADDR ofn 调用GetOpenFileName函数,并传入指向结构体ofn的指针。 这时候,打开文件对话框就显示出来了,GetOpenFileName函数要一直等到用户选择了一个文件后才会返回,或者当用户按下了CANCEL键或关闭对话框时。 当用户选择了打开一个文件时,该函数返回TRUE, 否则返回FALSE。 .if eax==TRUE invoke lstrcat,offset OutputString,OFFSET FullPathName invoke lstrcat,offset OutputString,ofn.lpstrFile invoke lstrcat,offset OutputString,offset CrLf invoke lstrcat,offset OutputString,offset FullName 当用户选择打开一个文件时,我们就在一个对话框中显示一个字符串,我们先给OutputString变量分配内存,然后调用PAI 函数lstrcat,把所有的字符串连到一起,为了让这些字符串分行显示,我们必须在每个字符串后面加一个换行符。 mov eax,ofn.lpstrFile push ebx xor ebx,ebx mov bx,ofn.nFileOffset add eax,ebx pop ebx invoke lstrcat,offset OutputString,eax 上面这几行可能需要一些解释。nFileOffset的值等于被打开文件的全路径名中的文件名的第一个字符的索引,由于nFileOffset是一个WORD型变量,而lpstrFile是一个DWORD形的指针,所以我们就要作一转换把nFileOffset存入ebx寄存器的底字节,然后再加到eax寄存器中得到DWORD型的指针。 invoke MessageBox,hWnd,OFFSET OutputString,ADDR AppName,MB_OK 我们在对话框中显示该字符串。 invoke RtlZerolMemory,offset OutputString,OUTPUTSIZE 为了下一次能正确地显示,必须清除缓冲区,我们调用函数RtlZerolMemory来做这件事。

TOP

[原创]汇编语言教学

第十课 以对话框为主要界面的应用程序
现在我们开始学习一些有关GUI编程的有趣的部分, 即:以对话框为主要界面的应用程序。我们将分两课来讲述这一过程
理论:
如果您仔细关注过前一个程序就会发现:您无法按TAB键从一个子窗口控件跳到另一个子窗口控件,要想转移的话只有 用鼠标一下一下地去点击。对用户来说这是不友好的。另一件事是如果您象前一课中那样把主窗口的背景色从白色改成 灰色,为了子窗口控件无缝地作相应地改变,您必须细分类所有子窗口。 造成上述诸多不便的原因是子窗口控件本来是为对话框而设计的,象子窗口控件的背景色是灰色的,而对话框的背景色也是 灰色的,这样它们本来就相互协调了,而无须程序员加入其他的处理。 在我们深入讨论对话框前我们必须知道何谓对话框。一个对话框其实是有很多的子窗口控件的一个窗口,WINDOWS在对话框 内部有一个管理程序,由其来处理象按下TAB键则输入焦点从一个子窗口空间条到另一个子窗口控件、按下ENTER键等于在当 前具有输入焦点的子窗口控件上点击了鼠标 等等这些杂事,这样程序员就可以集中精力于他们的逻辑事务了。对话框主要用 作输入输出接口,人们无须知道它们内部的工作原理,而只要知道如何和他们进行交互就可以了。这也是面向对象设计中的 所谓信息隐藏。只要这个黑盒子中的实现足够完美,我们就可以放心地使用,当然我们必须强调的是“黑盒子”必须完美。 WIN32 API 内部 的实现即是一个“黑盒子”。 噢,好象我们的讨论有些走题,现在让我们回到正题来,对话框的设计是为了减少程序员的工作量的,一般您如果在窗口中 自己放一个子窗口控件您就必须自己处理其中的按键逻辑和细分类它的窗口过程。如果您把它放到对话框中,则这些杂事 对话框会自己处理,您只要知道如何获得用户输入的数据和如何把数据放入到子窗口控件中去就可以了。 在程序中对话框和菜单谎欢ㄒ宄梢恢肿试矗梢栽诮疟疚募行匆桓龆曰翱蚰0澹渲邪枚曰翱蚝妥哟翱诘奶匦裕?然后用资源编辑器编辑。需要注意的是所有的资源必须放在同一个脚本文件中。 虽然可以用文本编辑器去编辑脚本文件,但是象要调整子窗口控件位置时要涉及到一些坐标值时最好还是用一些可视化的编 辑器,这样方便多了。一般在编译器的开发包中都会带资源编辑器,您可以用它们来产生一个模板然后增删一些子窗口控件。 有两种主要的对话框:模式对话框和无模式对话框。无模式对话框允许您把输入焦点切换到(同一个应用程序的)另一个窗口,而该对话框无须关闭 。比如MS WORD 中的FIND对话框。模式对话框又有两类:应用程序模式对话框和系统对话框。应用程序对话框不允许您在本 应用程序中切换输入焦点,但是可以切换到其它的应用程序中去,而系统对话框则必须您对该对话框做出响应否则不能切换到 任何的应用程序中去。要创建一个无模式对话框调用API函数CreateDialogParam,而创建一个模式对话框则调用API函数DialogBoxParam。 其中应用程序模式对话框和系统模式对话框之间的差别是style参数不同,要想创建一个系统模式对话框该参数必须“或”上 DS_SYSMODAL标志位。在对话框中若要和子窗口控件通讯则调用函数SendDlgItemMesage。该函数的语法如下:

SendDlgItemMessage proto hwndDlg:DWORD,\
idControl:DWORD,\
uMsg:DWORD,\
wParam:DWORD,\
lParam:DWORD
该PAI函数对于用在向子窗口控件发送方面是非常有用的。譬如:如果您想得到编辑控件中的字符串可以这么做:
call SendDlgItemMessage, hDlg, ID_EDITBOX, WM_GETTEXT, 256, ADDR text_buffer
具体要发送那些消息应当查询有关的WIN32 API 参考手册。 WINDOWS 还 提供几个快速存取控件数据的函数。譬如:GetDlgItemText、CheckDlgButton等。这样一来,您就可以不用去查询每个消息的wParam和lParam参数获得相关信息了。您应尽可能地使用这些API 函数,这样使得您的代码将来比较容易维护。对话框的管理函数会把一些消息发送给一个特定的回调函数:对话框过程处理函数,该函数的格式为:
DlgProc proto hDlg:DWORD ,\
iMsg:DWORD ,\
wParam:DWORD ,\
lParam:DWORD
该函数的格式非常类似于窗口的过程函数,除了返回值是TURE和FALSE,而不是HRESULT,存在于WINDOWS内部的对话框管理器才是对话框真正的窗口过程函数。它会把某些消息传递给我们的窗口过程函数。所以当我们的窗口过程函数处理这些消息时就返回TTRUE,否则就在eax中返回FALSE。这也意味着我们的窗口过程函数在接受到自己不处理的消息时并不会调用DefWindowProc函数,因为它本身不是一个真正的窗口过程函数。对于对话框有两种用法:一种是把它作为一个主窗口来用,一种是把它作为一种输入输出设备使用。本课中我们将示范第一种用法。“把对话框用作主窗口”有两种意思: 1。您可以调用RegisterClassEx函数把对话框模板注册为一个窗口类。这样该对话框的行为就类似于一个普通的窗口了:它通过在注册窗口时指定的窗口过程来处理所有的消息,通过这种方法来使用对话框的好处是您不需要显示地创建子窗口控件,WINDOWS本身会帮您创建好,另外还会帮您处理所有的按键逻辑,另外您还可以指定您窗口类结构中的光标和图标; 2。您的应用程序创建没有父窗口的对话框窗口,这种方法中,没有必要需要一段处理消息循环的代码,因为所有的消息被直接送到对话框过程处理函数,这样您也可以不要注册一个窗口类。本课中我门将先使用第一种方法然后使用第二中方法。
例子:
--------------------------------------------------------------------------------
dialog.asm
--------------------------------------------------------------------------------
.386
.model flat,stdcall
option casemap:none
WinMain proto :DWORD,:DWORD,:DWORD,:DWORD
include \masm32\include\windows.inc
include \masm32\include\user32.inc
include \masm32\include\kernel32.inc
includelib \masm32\lib\user32.lib
includelib \masm32\lib\kernel32.lib
.data
ClassName db "DLGCLASS",0
MenuName db "MyMenu",0
DlgName db "MyDialog",0
AppName db "Our First Dialog Box",0
TestString db "Wow! I'm in an edit box now",0
.data?
hInstance HINSTANCE ?
CommandLine LPSTR ?
buffer db 512 dup(?)
.const
IDC_EDIT equ 3000
IDC_BUTTON equ 3001
IDC_EXIT equ 3002
IDM_GETTEXT equ 32000
IDM_CLEAR equ 32001
IDM_EXIT equ 32002
.code
start:
invoke GetModuleHandle, NULL
mov hInstance,eax
invoke GetCommandLine
mov CommandLine,eax
invoke WinMain, hInstance,NULL,CommandLine, SW_SHOWDEFAULT
invoke ExitProcess,eax
WinMain proc hInst:HINSTANCE,hPrevInst:HINSTANCE,CmdLine:LPSTR,CmdShow:DWORD
LOCAL wc:WNDCLASSEX
LOCAL msg:MSG
LOCAL hDlg:HWND
mov wc.cbSize,SIZEOF WNDCLASSEX
mov wc.style, CS_HREDRAW or CS_VREDRAW
mov wc.lpfnWndProc, OFFSET WndProc
mov wc.cbClsExtra,NULL
mov wc.cbWndExtra,DLGWINDOWEXTRA
push hInst
pop wc.hInstance
mov wc.hbrBackground,COLOR_BTNFACE+1
mov wc.lpszMenuName,OFFSET MenuName
mov wc.lpszClassName,OFFSET ClassName
invoke LoadIcon,NULL,IDI_APPLICATION
mov wc.hIcon,eax
mov wc.hIconSm,eax
invoke LoadCursor,NULL,IDC_ARROW
mov wc.hCursor,eax
invoke RegisterClassEx, addr wc
invoke CreateDialogParam,hInstance,ADDR DlgName,NULL,NULL,NULL
mov hDlg,eax
invoke ShowWindow, hDlg,SW_SHOWNORMAL
invoke UpdateWindow, hDlg
invoke GetDlgItem,hDlg,IDC_EDIT
invoke SetFocus,eax
.WHILE TRUE
invoke GetMessage, ADDR msg,NULL,0,0
.BREAK .IF (!eax)
invoke IsDialogMessage, hDlg, ADDR msg
.IF eax ==FALSE
invoke TranslateMessage, ADDR msg
invoke DispatchMessage, ADDR msg
.ENDIF
.ENDW
mov eax,msg.wParam
ret
WinMain endp
WndProc proc hWnd:HWND, uMsg:UINT, wParam:WPARAM, lParam:LPARAM
.IF uMsg==WM_DESTROY
invoke PostQuitMessage,NULL
.ELSEIF uMsg==WM_COMMAND
mov eax,wParam
.IF lParam==0
.IF ax==IDM_GETTEXT
invoke GetDlgItemText,hWnd,IDC_EDIT,ADDR buffer,512
invoke MessageBox,NULL,ADDR buffer,ADDR AppName,MB_OK
.ELSEIF ax==IDM_CLEAR
invoke SetDlgItemText,hWnd,IDC_EDIT,NULL
.ELSE
invoke DestroyWindow,hWnd
.ENDIF
.ELSE
mov edx,wParam
shr edx,16
.IF dx==BN_CLICKED
.IF ax==IDC_BUTTON
invoke SetDlgItemText,hWnd,IDC_EDIT,ADDR TestString
.ELSEIF ax==IDC_EXIT
invoke SendMessage,hWnd,WM_COMMAND,IDM_EXIT,0
.ENDIF
.ENDIF
.ENDIF
.ELSE
invoke DefWindowProc,hWnd,uMsg,wParam,lParam
ret
.ENDIF
xor eax,eax
ret
WndProc endp
end start

--------------------------------------------------------------------------------
Dialog.rc
--------------------------------------------------------------------------------
#include "resource.h"
#define IDC_EDIT 3000
#define IDC_BUTTON 3001
#define IDC_EXIT 3002
#define IDM_GETTEXT 32000
#define IDM_CLEAR 32001
#define IDM_EXIT 32003

MyDialog DIALOG 10, 10, 205, 60
STYLE 0x0004 | DS_CENTER | WS_CAPTION | WS_MINIMIZEBOX |
WS_SYSMENU | WS_VISIBLE | WS_OVERLAPPED | DS_MODALFRAME | DS_3DLOOK
CAPTION "Our First Dialog Box"
CLASS "DLGCLASS"
BEGIN
EDITTEXT IDC_EDIT, 15,17,111,13, ES_AUTOHSCROLL | ES_LEFT
DEFPUSHBUTTON "Say Hello", IDC_BUTTON, 141,10,52,13
PUSHBUTTON "E&xit", IDC_EXIT, 141,26,52,13, WS_GROUP
END

MyMenu MENU
BEGIN
POPUP "Test Controls"
BEGIN
MENUITEM "Get Text", IDM_GETTEXT
MENUITEM "Clear Text", IDM_CLEAR
MENUITEM "", , 0x0800 /*MFT_SEPARATOR*/
MENUITEM "E&xit", IDM_EXIT
END
END
分析:
我们先来分析第一个例子:
该例显示了如何把一个对话框模板注册成一个窗口类,然后创建一个由该窗口类派生的窗口。由于您没有必要自己去创建子窗口控件,所以就简化了许多的工作。
我们先来分析对话框模板。
MyDialog DIALOG 10, 10, 205, 60
先是对话框的名字,然后是关键字“DAILOG”。接下来的四个数字中,前两个是对话框的坐标,后两个是对话框的宽和高(注意:它们的单位是对话框的单位,而不一定是像素点)。
STYLE 0x0004 | DS_CENTER | WS_CAPTION | WS_MINIMIZEBOX |
WS_SYSMENU | WS_VISIBLE | WS_OVERLAPPED | DS_MODALFRAME | DS_3DLOOK
上面定义了对话框的风格。
CAPTION "Our First Dialog Box"
这是显示在对话框标题条上的标题。
CLASS "DLGCLASS"
这一行非常关键。正是有了关键字CLASS,我们才可以用它来声明把一个对话框当成一个窗口来用。跟在关键字后面的是“窗口类”的名称。
BEGIN
EDITTEXT IDC_EDIT, 15,17,111,13, ES_AUTOHSCROLL | ES_LEFT
DEFPUSHBUTTON "Say Hello", IDC_BUTTON, 141,10,52,13
PUSHBUTTON "E&xit", IDC_EXIT, 141,26,52,13
END
上面的一块定义了对话框中的子窗口控件,它们是声明在一头一尾的两个关键字BEGIN和END之间的。
control-type "text" ,controlID, x, y, width, height [,styles]
控件的类型是资源编辑器定义好了的常数,您可以查找有关的手册。
现在我们来看看汇编源代码。先看这部分:
mov wc.cbWndExtra,DLGWINDOWEXTRA
mov wc.lpszClassName,OFFSET ClassName
通常cbWndExtra被设成NULL,但我们想把一个对话框模板注册成一个窗口类,我们必须把该成员的值设成DLGWINDOWEXTRA。注意类的名称必须和模板中跟在CLASS关键字后面的名称一样。余下的成员变量和声明一般的窗口类相同。填写好窗口类结构变量后调用函数RegisterClassEx进行注册。看上去这一切和注册一个普通的窗口类是一样的。
invoke CreateDialogParam,hInstance,ADDR DlgName,NULL,NULL,NULL
注册完毕后,我们就创建该对话框。在这个例子中,我们调用函数CreateDialogParam产生一个无模式对话框。这个函数共有5个参数,其中前两个参数是必须的:实例句柄和指向对话框模板名称的指针。注意第二个参数是指向模板名称而不是类名称的指针。这时,WINDOWS将产生对话框和子控件窗口。同时您的应用程序将接收到由WINDOWS传送的第一个消息WM_CREATE。
invoke GetDlgItem,hDlg,IDC_EDIT
invoke SetFocus,eax
在对话框产生后,我们把输入输出焦点设到编辑控件上。如果在WM_CREATE消息处理段中假如设置焦点的代码,GetDlgItem函数就会失败,因为此时空间窗口还未产生,为了在对话框和所有的子窗口控件都产生后调用该函数我们把它安排到了函数UpdatWindow后,GetDlgItem函数返回该控件的敞口句柄。
invoke IsDialogMessage, hDlg, ADDR msg
.IF eax ==FALSE
invoke TranslateMessage, ADDR msg
invoke DispatchMessage, ADDR msg
.ENDIF
现在程序进入消息循环,在我们翻译和派发消息前,该函数使得对话框内置的对话框管理程序来处理有关的键盘跳转逻辑。如果该函数返回TRUE,则表示消息是传给对话框的已经由该函数处理了。注意和前一课不同,当我们想得到控件的文本信息时调用GetDlgItemText函数而不是GetWindowText函数,前者接受的参数是一个控件的ID 号,而不是窗口的句柄,这使得在对话框中调用该函数更方便。

--------------------------------------------------------------------------------
好我们现在使用第二种方法把一个对话框当成一个主窗口来使用。在接下来的例子中,我们将产生一个应用程序的模式对话框,您将会发现其中根本没有消息循环或窗口处理过程,因为它们根本没有必要!
--------------------------------------------------------------------------------
dialog.asm (part 2)
--------------------------------------------------------------------------------
.386
.model flat,stdcall
option casemap:none
DlgProc proto :DWORD,:DWORD,:DWORD,:DWORD
include \masm32\include\windows.inc
include \masm32\include\user32.inc
include \masm32\include\kernel32.inc
includelib \masm32\lib\user32.lib
includelib \masm32\lib\kernel32.lib
.data
DlgName db "MyDialog",0
AppName db "Our Second Dialog Box",0
TestString db "Wow! I'm in an edit box now",0
.data?
hInstance HINSTANCE ?
CommandLine LPSTR ?
buffer db 512 dup(?)
.const
IDC_EDIT equ 3000
IDC_BUTTON equ 3001
IDC_EXIT equ 3002
IDM_GETTEXT equ 32000
IDM_CLEAR equ 32001
IDM_EXIT equ 32002

.code
start:
invoke GetModuleHandle, NULL
mov hInstance,eax
invoke DialogBoxParam, hInstance, ADDR DlgName,NULL, addr DlgProc, NULL
invoke ExitProcess,eax
DlgProc proc hWnd:HWND, uMsg:UINT, wParam:WPARAM, lParam:LPARAM
.IF uMsg==WM_INITDIALOG
invoke GetDlgItem, hWnd,IDC_EDIT
invoke SetFocus,eax
.ELSEIF uMsg==WM_CLOSE
invoke SendMessage,hWnd,WM_COMMAND,IDM_EXIT,0
.ELSEIF uMsg==WM_COMMAND
mov eax,wParam
.IF lParam==0
.IF ax==IDM_GETTEXT
invoke GetDlgItemText,hWnd,IDC_EDIT,ADDR buffer,512
invoke MessageBox,NULL,ADDR buffer,ADDR AppName,MB_OK
.ELSEIF ax==IDM_CLEAR
invoke SetDlgItemText,hWnd,IDC_EDIT,NULL
.ELSEIF ax==IDM_EXIT
invoke EndDialog, hWnd,NULL
.ENDIF
.ELSE
mov edx,wParam
shr edx,16
.if dx==BN_CLICKED
.IF ax==IDC_BUTTON
invoke SetDlgItemText,hWnd,IDC_EDIT,ADDR TestString
.ELSEIF ax==IDC_EXIT
invoke SendMessage,hWnd,WM_COMMAND,IDM_EXIT,0
.ENDIF
.ENDIF
.ENDIF
.ELSE
mov eax,FALSE
ret
.ENDIF
mov eax,TRUE
ret
DlgProc endp
end start

--------------------------------------------------------------------------------
dialog.rc (part 2)
--------------------------------------------------------------------------------
#include "resource.h"
#define IDC_EDIT 3000
#define IDC_BUTTON 3001
#define IDC_EXIT 3002
#define IDR_MENU1 3003
#define IDM_GETTEXT 32000
#define IDM_CLEAR 32001
#define IDM_EXIT 32003

MyDialog DIALOG 10, 10, 205, 60
STYLE 0x0004 | DS_CENTER | WS_CAPTION | WS_MINIMIZEBOX |
WS_SYSMENU | WS_VISIBLE | WS_OVERLAPPED | DS_MODALFRAME | DS_3DLOOK
CAPTION "Our Second Dialog Box"
MENU IDR_MENU1
BEGIN
EDITTEXT IDC_EDIT, 15,17,111,13, ES_AUTOHSCROLL | ES_LEFT
DEFPUSHBUTTON "Say Hello", IDC_BUTTON, 141,10,52,13
PUSHBUTTON "E&xit", IDC_EXIT, 141,26,52,13
END

IDR_MENU1 MENU
BEGIN
POPUP "Test Controls"
BEGIN
MENUITEM "Get Text", IDM_GETTEXT
MENUITEM "Clear Text", IDM_CLEAR
MENUITEM "", , 0x0800 /*MFT_SEPARATOR*/
MENUITEM "E&xit", IDM_EXIT
END
END

--------------------------------------------------------------------------------
分析如下:
DlgProc proto :DWORD,:DWORD,:DWORD,:DWORD
我们已经定义了DlgProc函数的原型,所以可以用操作符ADDR来获得它的地址(记得吗,它可以在运行时动态地获得标识符的有效地址):
invoke DialogBoxParam, hInstance, ADDR DlgName,NULL, addr DlgProc, NULL
上面的几行调用了函数DialogBoxPAram,该函数有五个参数,分别是:实例句柄、对话框模板的名字、父窗口的句柄、对话框过程函数的地址、和对话框相关的数据。该函数产生一个模式对话框。如果不显示地关闭该函数不会返回。
.IF uMsg==WM_INITDIALOG
invoke GetDlgItem, hWnd,IDC_EDIT
invoke SetFocus,eax
.ELSEIF uMsg==WM_CLOSE
invoke SendMessage,hWnd,WM_COMMAND,IDM_EXIT,0
除了不处理WM_CREATE消息外对话框的窗口处理过程函数和一般的窗口处理过程相似。该过程函数接收到的第一个消息是WM_INITDIALOG。通常把初始化的代码放到此处。注意如果您处理该消息必须在eax中返回TRUE。内置的对话框管理函数不会把WM_DESTROY 消息发送到对话框的消息处理函数,所以如果我们想在对话框关闭时进行处理,就把它放到WM_CLOSE消息的处理中。在我们的例子中我们发送消息WM_COMMAND,并在参数wParam中放置IDM_EXIT,这和处理WM_CLOSE 消息效果一样,在处理IDM_EXIT 中我们调用EndDialog函数。如果我们想要销毁一个对话框,必须调用EndDialog函数,该函数并不会立即销毁一个窗口,而是设置一个标志位,然后对话框管理器会处理接下去的销毁对话框动作。好,现在我们来看看资源文件,其中最显著的变化是在指定菜单时我们不是用字符串指定该菜单的名称而是用了一个常量 IDR_MENU1。在调用DialogBoxParam产生的对话框中挂接一个菜单必须这么做,注意在该对话框模板中,在该标识符前必须加MENU关键字,这两个例子中的显著不同是后者没有图标,这可以在处理WM_INITDIALOG中发送消息WM_SETICON消息,然后在该消息处理代码中作适当的处理即可。

TOP

返回列表 回复 发帖