The Assembly Programming Master Book

History deserves to be learned! Although this chapter presents information of only historical interest, and although those who remember Windows 3.1 are few in number, I won't delete it even from future editions of my book. This chapter contains material that is valuable from a historical point of view. As a rule, when providing basic information about Windows programming in Assembly language, most authors start by describing 16-bit programming. In my opinion, it is obsolete and can no longer serve as an introduction to Windows programming. ^[i] Since it is extremely unlikely that you'll need to develop a 16-bit application, I'll limit myself to providing a simple example. If you are interested in this topic, I recommend that you read other books [1, 7] in addition to this chapter.

The Idea of 16-Bit Windows Programming

Let me start by considering the differences between 16-bit and 32-bit Assembly programming. You'll discover that programming has become considerably easier over time.

• In contrast to the Windows 9x model, the memory model in Windows 3.1x was segmented. Accordingly, in the program, the data, the stack, and the code relate to different segments. ^[ii] As with MS-DOS, the DS register pointed to the data segment and CS pointed to the code segment.

• In the 16-bit model, addressing is accomplished according to the segment/offset method. Accordingly, the address is defined by two 16-bit components . For example, to load the address of variable M into the stack, you'll need at least two commands: PUSH DS/PUSH OFFSET M. At the same time, the segment address must be loaded into the cell with the address higher than that of the offset (the stack grows in the direction of lower addresses).

• For developing 16-bit applications, MASM 6.1 is the most convenient tool. Because this chapter provides only a historical overview, I won't concentrate attention on the development of 16-bit applications using Turbo Assembler. For linking the applications, you will use the LIBW.LIB library supplied with MASM 6.1. A feature of API calls, in this case, is the inverse order of loading parameters into the stack, as compared to all examples considered previously. In this chapter, and only here, I will use the following principle: from left to rightfrom top to bottom.

• After starting the program, it is necessary to initialize startup. For this purpose, it is necessary to call the following API functions: INITTASK , WAITEVENT , and INITAPP .

  • INITTASK initializes registers, the command line, and memory. This function doesn't require any parameters and is the first one to be called. Return values of registers are as follows : AX = 1 (0 = error), CX = the stack size , DI = the unique number for the current task, DX = NCMDSHOW (described later), ES = the segment address (selector) PSP, ES:BX = the command line address, and SI = the unique number of the previous copy of the same application started earlier. In Windows 3.1, when starting an application, only a part of the registers is loaded into the memory each time and a part of the segments is the common resource. This was the way to economize on the memory. The developers of Windows 95 abandoned this approach. Every task running in the system is isolated and independent. In Windows 95, SI is always zero. Furthermore, this procedure fills the reserved header of the data segment.

  • WAITEVENT checks whether there are events intended for the specified application. If there is such an event in the queue, it is removed from the queue. The call looks as follows:

    PUSH AX ; AX --- Application number ; If it is set to 0, this is the current application CALL WAITEVENT

  • INITAPP initializes the event queue for the current application. The call looks as follows:

    PUSH DI ; Unique number of the task CALL INITAPP

    In case of an error, this function returns 0; otherwise , it returns a nonzero value.

• Some parameters of the API functions of a 16-bit application have a size of 2 bytes. In particular, the WPARAM and HWND parameters of the window procedure are 2 bytes long. When you need to operate with 4-byte parameters, they must be processed in two passes .

• Consider the last difference: the data segment in the program start must contain the reserved 16-byte block.

• An interesting fact is that in a 16-bit application, you can use normal MS-DOS interrupts by means of INT 21H. You only have to bear in mind which functions make sense with Windows.

An Example of 16-bit Windows Application

To illustrate the idea explained in the preceding section, I'll provide a simple program. Program translation is carried out using MASM 6.1:

ML /c prog.asm LINK prog, prog, libw

The question about the DEF file can be ignored.

Listing 4.1: An example of a 16-bit application

.286 .DOSSEG ; Segment order according to the agreement with Microsoft DGROUP GROUP DATA, STA ASSUME CS:CODE, DS:DGROUP ; Prototypes of external procedures EXTRN INITTASK:FAR EXTRN INITAPP:FAR EXTRN WAITEVENT:FAR EXTRN DOS3CALL:FAR EXTRN REGISTERCLASS:FAR EXTRN LOADCURSOR:FAR EXTRN GETSTOCKOBJECT:FAR EXTRN GETMESSAGE:FAR EXTRN TRANSLATEMESSAGE:FAR EXTRN DISPATCHMESSAGE:FAR EXTRN CREATEWINDOW:FAR EXTRN CREATEWINDOWEX:FAR EXTRN UPDATEWINDOW:FAR EXTRN SHOWWINDOW:FAR EXTRN POSTQUITMESSAGE:FAR EXTRN DEFWINDOWPROC:FAR ; Templates WNDCL STRUCT STYLE DW 0 ; Window class style LPFNWNDPROC DD 0 ; Pointer to the handler procedure CBCLSEXTRA DW 0 CBWNDEXTRA DW 0 HINSTANCE DW 0 HICON DW 0 HCURSOR DW 0 HBRBACKGROUND DW 0 LPSZMENUNAME DD 0 ; Pointer to the string LPSZCLASSNAME DD 0 ; Pointer to the string WNDCL ENDS ; MESSA STRUCT HWND DW ? MESSAGE DW ? WPARAM DW ? LPARAM DD ? TIME DW ? X DW ? Y DW ? MESSA ENDS ; Stack segment STA SEGMENT STACK 'STACK' DW 2000 DUP(?) STA ENDS ; Data segment DATA SEGMENT WORD 'DATA' ; The 16 bits at the starting point provide the reserve ; required for a 16-bit application to correctly ; operate in the Windows environment DWORD 0 WORD 5 WORD 5 DUP (0) HPREV DW ? HINST DW ? LPSZCMD DD ? CMDSHOW DW ? ; Structure for creating a class WNDCLASS WNDCL <> ; Message structure MSG MESSA <> ; Window class name CLASS_NAME DB 'HELLO', 0 ; Window header APP_NAME DB '16-bit program', 0 ; Cursor type CURSOR EQU 00007F00H ; Window style STYLE EQU 000CF0000H ; Window parameters XSTART DW 100 YSTART DW 100 DXCLIENT DW 300 DYCLIENT DW 200 DATA ENDS ; Code segment CODE SEGMENT WORD 'CODE' _BEGIN: ; I. Initial code CALL INITTASK ; Initialize the task OR AX, AX ; CX --- Stack boundaries JZ _ERR MOV HPREV, SI ; Number of the previous application MOV HINST, DI ; Number for the new task MOV WORD PTR LPSZCMD, BX ; ES:BX - Address MOV WORD PTR LPSZCMD+2, ES ; of the command line MOV CMDSHOW DX ; Screen parameter PUSH 0 ; Current task CALL WAITEVENT ; Clear the event queue PUSH HINST CALL INITAPP ; Initialize applications OR AX, AX JZ _ERR CALL MAIN ; Start the main procedure _TO_OS: MOV AH, 4CH INT 21H ; Exit the program _ERR: ; Here, it is possible to place the error message JMP SHORT _TO_OS ; Main procedure ;***************************************************** MAIN PROC ; II. Registering the window class ; Window style NULL --- Standard window MOV WNDCLASS.STYLE, 0 ; Handler procedure LEA BX, WNDPROC MOV WORD PTR WNDCLASS.LPFNWNDPROC, BX MOV BX, CS MOV WORD PTR WNDCLASS.LPFNWNDPROC+2, BX ;----------------------------------------- ; Reserved bytes terminating the structure being reserved MOV WNDCLASS.CBCLSEXTRA, 0 ; Reserved bytes terminating the structure for each window MOV WNDCLASS.CBWNDEXTRA, 0 ; The window icon is missing MOV WNDCLASS.HICON, 0 ; The number of the task being started MOV AX, HINST MOV WNDCLASS.HINSTANCE, AX ; Get the standard cursor number PUSH 0 PUSH DS PUSH CURSOR CALL LOADCURSOR MOV WNDCLASS.HCURSOR, AX ; Get the number of the standard object PUSH 0 ; WHITE_BRUSH CALL GETSTOCKOBJECT ; Background color MOV WNDCLASS.HBRBACKGROUND, AX ; Menu name from the resource file (NULL if missing) MOV WORD PTR WNDCLASS.LPSZMENUNAME, 0 MOV WORD PTR WNDCLASS.LPSZMENUNAME+2, 0 ; Pointer to the string containing the class name LEA BX, CLASS_NAME MOV WORD PTR WNDCLASS.LPSZCLASSNAME, BX MOV WORD PTR WNDCLASS.LPSZCLASSNAME+2, DS ; Call the registration procedure PUSH DS; Pointer to LEA DI, WNDCLASS PUSH DI; WNDCLASS structures CALL REGISTERCLASS CMP AX, 0 JNZ _OK1 ; Registration error RET ; Error in the course of registration _OK1 ; III. Creating the window ; Address of the window class name string PUSH DS LEA BX, CLAS_NAME PUSH BX ; Address of the window header string PUSH DS LEA BX, APP_NAME PUSH BX ; Window style MOV BX, HIGHWORD STYLE PUSH BX MOV BX, LOWWORD STYLE PUSH BX ; X coordinate of the window's top left corner PUSH XSTART ; Y coordinate of the window's top left corner PUSH YSTART ; Window width PUSH DXCLIENT ; Window height PUSH DYCLIENT ; Number of the parent window PUSH 0 ; Number (identifier) of the window menu PUSH 0 ; NULL ; Task number PUSH HINST ; Address of the block of window parameters (none) PUSH 0 PUSH 0 CALL CREATEWINDOW CMP AX, 0 JNZ NO_NULL ; Window creation error RET ; Error when creating a window ; Set the window visibility state (window or icon) ; according to the CMDSHOW parameter and its display NO_NULL: MOV SI, AX PUSH SI PUSH CMDSHOW CALL SHOWWINDOW ; Send the command to redraw the window area ; (WM_PAINT command) ; The message is sent to the window directly PUSH SI CALL UPDATEWINDOW ; IV. Waiting loop LOOP1: ; Retrieve the message from the queue PUSH DS LEA BX, MSG ; Pointer to the message structure PUSH BX PUSH 0 PUSH 0 PUSH 0 CALL GETMESSAGE ; Check whether the "exit" message has been received CMP AX, 0 JZ NO_LOOP1 ; Convert all received messages to the ANSI standard PUSH DS LEA BX, MSG PUSH BX CALL TRANSLATEMESSAGE ; Instruct Windows to pass this message ; to the appropriate window PUSH DS LEA BX, MSG PUSH BX CALL DISPATCHMESSAGE ; Close the message-processing loop JMP SHORT LOOP1 NO_LOOP1: RET MAIN ENDP ; Procedure for the specified window class ; Windows passes the following parameters to this procedure: ; HWND - Window descriptor, WORD type ; MES --- Message number, WORD type ; WPARAM - Additional information, WORD type ; LPARAM --- Additional information, DWORD type WNDPROC PROC PUSH BP MOV BP, SP MOV AX, [BP+0CH] ; MES - Message number CMP AX, 2 ; Is this the WM_DESTROY message? JNZ NEXT ; Pass the message about application termination ; This message will be received by the message-handling ; loop, and the application will thus be terminated PUSH 0 CALL POSTQUITMESSAGE JMP _QUIT NEXT: ; Pass the message further to Windows ; This means that everything that wasn't processed ; by the procedure is provided to Windows for processing PUSH [BP+0EH] ; HWND PUSH [BP+0CH] ; MES - Message number PUSH [BP+0AH] ; WPARAM PUSH [BP+8] ; HIGHWORD LPARAM PUSH [BP+6] ; LOWWORD LPARAM CALL DEFWINDOWPROC ;****************************************************** _QUIT: POP BP ; The call to the window procedure is always FAR; therefore, you use RETF RETF 10 ; Clear the stack from the parameters WNDPROC ENDP CODE ENDS END _BEGIN

That's all. The compiled and linked program will start both in older versions of the operating system and in all newer versions of operating systems from the Windows family. I'd only like to draw your attention to the .DOSSEG directive. This directive specifies a certain order of segments in the EXE file. This order is as follows: The starting segment is the segment of the CODE class, it is followed by segments of classes other than CODE that do not belong to the group of segments ( GROUP ), then there are segments grouped using the GROUP directive. At the same time, the segments not from the BSS and STACK classes go first, then come the segments of the BSS class (if any), and the last segment is the segment of the STACK class.

For Assembly language, Windows 95 was a significant advance. Obviously, Assembly language programming became considerably easier.

Now, say good-bye to 16-bit programming. You'll never encounter it again in this book.

^[i] As you'll see for yourself, 16-bit programming is slightly more difficult than 32-bit programming.

^[ii] I hope that you remember that in 32-bit model division of data and code into segments is a matter of convention.