Contents  Introduction  MASM's HL Syntax  Getting A Game  Loop Running  Connecting to  Direct Draw  Our DDraw Library  Our Bitmap Library  A Game... Kinda'  Until Next Time  Printable version     The Series  Part 1  Part 2  Part 3  Part 4  Part 5  Part 6

MASM's HL Syntax

I am sure many of you have seen an old DOS assembly language listing. Take a moment to recall that listing, and picture the code. Scary? Well, 9 times out of 10 it was scary. Most ASM programmers wrote very unreadable code, simply because that was the nature of their assembler. It was littered with labels and jmp's, and all sorts of other mysterious things. Try stepping through it with your mental computer. Did you crash? Yeah, don't feel bad. It is just how it is. Now, that was the 9 out of 10 ... what about that 1 out of 10? What is the deal with them? Well, those are the programmers who coded MACRO's to facilitate High Level constructs in their programs. For once, Microsoft did something incredibly useful with MASM 6.0 ... they built those HL MACRO's, that smart programmers had devised, into MASM as pseudo-ops.

If you aren't aware of what this means I will let you in on it. MASM's assembly code is now just as readable and easy to write as C. This, of course, is just my opinion. But, it is an opinion shared by thousands and thousands of ASM coders. So, now that I have touted its usefulness let's take a look at some C constructs and their MASM counterparts.

IF - ELSE IF - ELSE

The C version: if ( var1 == var2 ) { // Code goes here } else if ( var1 == var3 ) { // Code goes here } else { // Code goes here }

The MASM version: .if ( var1 == var2 ) ; Code goes here .elseif ( var1 == var3 ) ; Code goes here .else ; Code goes here .endif

DO - WHILE

The C version: do { // Code goes here } while ( var1 == var2 );

The MASM version: .repeat ; Code goes here .until ( var1 != var2 )

WHILE

The C version: while ( var1 == var2 ) { // Code goes here }

The MASM version: .while ( var1 == var2 ) ; Code goes here .endw

Those are the constructs that we can use in our code. As you can see they are extremely simple and allow for nice readable code. Something assembly language has long been without. There is no performance loss for using these constructs, at least I haven't found any. They typically generate the same jmp and cmp code that a programmer would if he were writing it with labels and such. So, feel free to use them in your code as you see fit ... they are a great asset.

There is one other thing we should discuss and that is the psuedo-ops that allow us to define procedures/functions easily. PROTO and PROC. Using them is really simple. To begin with, just as in C you need to have a prototype. In MASM this is done with the PROTO keyword. Here are some examples of declaring protoypes for your procedures:

	;==================================
	; Main Program Procedures
	;==================================
	WinMain PROTO  		:DWORD,:DWORD,:DWORD,:DWORD
	WndProc PROTO  		:DWORD,:DWORD,:DWORD,:DWORD

The above code tells the assembler it should expect a procedure by the name of WinMain and one by the name of WndProc. Each of these has a parameter list associated with them. They both happen to expect 4 DWORD values to be passed to them. For those of you using the MASM32 package, you already have all of the Windows API functions prototyped, you just need to include the appropriate include file. But, you need to make sure that any user defined procedure is prototyped in the above fashion.

Once we have the function prototyped we can create it. We do this with the PROC keyword. Here is an example:

;##############################################################
; WinMain Function
;##############################################################
WinMain PROC	hInstance	:DWORD,
		hPrevInst	:DWORD,
		CmdLine		:DWORD,
		CmdShow		:DWORD




	;===========================
	; We are through
	;===========================
	return msg.wParam

WinMain endp
;##############################################################
; End of WinMain Procedure
;##############################################################

By writing our functions in this manner we can access all passed parameters by the name we give to them. The above function is WinMain w/o any code in it. You will see the code in a minute. For now though, pay attention to how we setup the procedure. Also notice how it allows us to create much cleaner looking code, just like the rest of the high level constructs in MASM do also.

Next : Getting A Game Loop Running