Assembly Language Step by Step 1992

^KH: Hide/unhide the marked block ^KY: Delete marked block

^KU: Move marked block ^KC: Copy marked block

^QL: Undo changes to line

Alt-F: Change current source code file

QR: Move to start of file	^Y: Delete line ^T: Delete word
^Q¥: Del. to EOL	^QF: Find ^QA: Find/Replace
^QC: Move to end of file
^L: Find/repl. again
: A Move 1 word left	Options: N: Without asking U: Whole words
only ^F Move 1 word right	G: Global U: Ignore case B:
Backwards

«REMEMBER!!» If your .ASM file is not a standalone program, but a device driver or a library of procedures, pressing F10 may lock up your system!!

4.3 Using JED's Tools

The very best way to explain JED's commands and how they are used is to run through a simple JED session with a real assembly language program and explain what happens as we go. The program we'll use is EAT2.ASM, which is shown in chapter 7. EAT2.ASM is not much of a program, but gets you started in understanding the internal mechanisms of a real, working assembly-language program. When you run EAT2.EXE from the DOS prompt, this simple message displays on your screen:

Eat at Joe's...

...ten million flies can't ALL be wrong!

After it displays those two lines, this program ends and returns control to DOS. EAT2.ASM is the source-code file from which the executable program file EAT2.EXE is assembled and linked. EAT2.ASM is present on the disk with JED. If you have somehow obtained JED without the rest of the example files from this book, you can type EAT2.ASM into JED after running JED.

If you, as I suggested earlier, created a subdirectory on your hard disk called ASM, copy all of the files on the JED disk into subdirectory ASM. In order for JED to operate correctly, the following files must be present in the subdirectory with JED:

•Your assembler. This can be any command-line oriented assembler, but will typically be either MASM.EXE or TASM.EXE.

•Your assembler's linker. Assemblers are usually shipped with their own linker. This is certainly true of MASM and TASM. Some assemblers may not use their own linker, but will use the DOS linker, LINK.EXE, instead.

•The DOS debugger, DEBUG.COM. Some versions of DOS are no longer shipped with DEBUG, which is offered as part of an additional utilities disk. Prior to DOS 3.2, all versions have DEBUG.COM. If you don't have DEBUG.COM, you will find it slow going, since nearly all of the debugging skills I'll be teaching in this book center on

DEBUG.COM.

Of course, other files can be present without any hindrance to your work.

Invoking JED

Make the current directory your working assembly-language subdirectory, which I have suggested you call ASM. From the DOS prompt, invoke JED and load EAT2.ASM

C:\ASM>JED EAT2

Notice that you don't have to type the .ASM extension at the end of the filename. JED has a default file extension of .ASM. In other words, if you don't enter a file extension, JED will append the file extension .ASM on the end of the name you enter on the command line. (You can also enter the full filename including extension.) In either case, JED will consider the name of the current file to be EAT2.ASM.

Now, either EAT2.ASM exists on your disk or it doesn't. JED won't mind if the file doesn't exist—new files have to start somewhere! If JED can't find the file you entered on the command line, it will display the words "New file" in the upper-left corner of the Edit screen and create an empty text file on your hard disk. When you type text into the Edit screen, JED will save the text into that new file.

The file may well exist on disk, and if it does, JED will load the file into the editor screen and display it for you. Assuming you entered the name EAT2, the screen should look almost identical to that shown in Figure 4.1.

You might wonder what will happen if you simply type JED at the DOS command line without specifying filename. One of two things will happen:

•JED will load the file that you last worked on from within JED. JED keeps a record of this file in a small file named JED.CFG. If it can find JED.CFG, and if the file named in JED.CFG is in current subdirectory, JED will load that file. JED updates JED.CFG automatically.

•If there is no JED.CFG on your disk, JED will create a file imaginatively named NONAME.ASM and store your text into a new file with that name. NONAME.ASM is a pretty rank name for any assembly-language program, so you might as well think of a better name and enter that when invoking JED.

JED's ability to remember the name of the last file you worked on makes it unnecessary for you to remember what project you were in the middle of when you pulled the plug and went to bed. Furthermore, JED also remembers the cursor position when you saved your file and exited from JED.

Moving around the Edit Screen

Your place to stand is JED's text editor, and when nothing else is going on (like assembling, linking, debugging, or running your program) you'll be in the text editor. When you're in the text editor, any characters you type will be inserted into the current file and displayed on the Edit screen. You can move the cursor around the current file by using any of a number of cursor control keys.

The easiest to remember are the PC's keypad keys. The four arrow keys will move the cursor one character position in the direction the arrow points. The PgUp key will move the cursor one page up the size of your screen; typically 25,

43, or 50 lines, whereas PgDn will move the cursor one page down. The Home key will move the cursor immediately to the left screen margin, and the End key will move the cursor immediately to the end of the current line (End of the line is defined as the character after the rightmost non blank character in the line.)

There are numerous other cursor control keys that you can use within JED. I'll describe them all in detail in Section 4.4.

Take a few moments scooting around inside EAT2 until you feel comfortable with it.

Making Changes to the File

The simplest way to change the file is to enter something from the keyboard. All characters you type will appear at the cursor position. The cursor will move one position to the right as you enter each character.

You can insert a new line beneath the current line by pressing Enter.

Getting rid of unwanted text is as important as adding new text. You can delete one character at a time by moving the cursor to the immediate right of the offending character, and pressing Backspace to back the cursor over it. The character will disappear.

You can delete an entire line by placing the cursor on the line and pressing Ctrl+Y. Be careful when using Ctrl+Y! You don't want to accidentally lose a line that you may or may not have in your head or written down on paper.

JED contains numerous other ways to delete text, all of which will be described in Section 4.4. For the sake of the current guided tour through JED, move the cursor to the blank line immediately beneath EAT2's comment header (line 9 in the file) and type the word "FOO". That done, press Enter and add a new line beneath it.

Saving Changes to a File

As they say in Chicago, that grand old (and cold) town where I grew up, "Vote early and often." The same philosophy applies to saving the changes you make to your current file under JED. Every so often, perhaps when you kick back in your chair to think for a bit, save your work. It's easy: one keystroke, the function key F2. JED will display the word "Saving..." in the status line at the top of the screen while it saves your file to disk. If you have a fast hard disk this will rarely take more than a second. If you're still working on diskettes, the process may take a few seconds more, especially if the current file is a good size.

Get in the habit of pressing F2 once in a while. Keep in mind that if you save your work every five minutes, you will never lose more than five minutes of work!

JED keeps an eye on things and does its level best to keep you from losing any of your work. If you try to exit JED without saving your file to disk, JED will remind you with the following prompt:

File modified. Save it? (Y/N)

If you press "Y", JED will save your work to disk. Pressing "N" will allow you to exit JED without saving your work. All other keys but Y and N will be ignored. JED also automatically saves your work every time you go out to use the assembler, linker, or debugger, or when you run the program you're developing, as I'll explain a little later.

Changing the Current File

If you want to change the current file while you're in JED, simply press Alt+F. (Think File.) A window will appear in the center of the screen displaying the name of the current file above a field where you can enter the name of the new file.

The name of the current file will be in the field. You can do one of two things to the name:

•Begin typing a new name. The old name will vanish as soon as you press a printable character key.

•Backspace over some portion of the old name. This allows you to change the name of the current file from EAT2.ASM to EAT3.ASM without typing the whole name.

When you press Enter, JED will attempt to load the specified file. If the file does not exist, or if you left the name field blank, JED will create a new file according to the rules summarized in the previous section.

Checking and Changing the Assemble and Link Commands

The whole point of JED is to help you do your work in assembly language, and the central task in assembly-language work is processing a correct file through an assembler. JED can execute your assembler program and assemble your current file with only one keystroke on your part. That keystroke is function key F9, as you'll see from the prompt bar at the bottom of the screen. Before you press F9 on our tour, however, we'd better make sure JED has your assembler and linker commands straight.

As programs go, JED is pretty clever, but it doesn't read minds. It can make use of any assembler that operates from the DOS command line, but you have to tell JED how to invoke the assembler you've chosen. MASM and TASM are invoked in different ways, and JED must know which assembler you're using to invoke the assembler program from disk and make use of it.

Pressing function key F4 displays a whole new screen that allows you to specify your assembler. See Figure 4.3. The screen contains two command lines, one that invokes your assembler, and another that invokes your linker. I've set JED up to assume the use of Borland's Turbo Assembler TASM, which is faster and in many ways more sophisticated than Microsoft's MASM. If you are using TASM, you needn't change JED's built-in default command lines. Figure 4.3 shows the default command lines for TASM.

To use MASM or some other assembler, however, you'll need to change both command lines. This will require some knowledge of how your assembler and linker operate. I'll provide you with some basic information about MASM and TASM; for other assemblers (or for using specialized features of MASM and TASM) you're on your own.

The line beneath the prompt "Assemble command" is the line JED will use to invoke your assembler. The default is

TASM ~

which will invoke Borland's Turbo Assembler with all default conditions in force. The tilde character ~ is used to indicate where in the line JED is to substitute the name of the current file. In other words, when JED goes out to DOS to execute TASM on the file EAT2.ASM, it will substitute EAT2.ASM for the tilde, using the following line for invoking TASM:

TASM EAT2.ASM

If you're using MASM instead, you must change the Assemble command. Invoking MASM with all defaults in force (using the tilde to indicate the position of the filename) requires this command line:

MASM ~;

Again, in our example JED would automatically expand the line to read:

MASM EAT2.ASM;

The semicolon is very important, and prevents MASM from going into interac-tive mode. If you omit the semicolon, MASM will stop and begin asking questions from the keyboard. JED is not equipped to answer these questions, and while you yourself could answer MASM's questions from the keyboard, there's no point to it if all we want to do is use MASM's defaults. If you're using MASM, make sure you enter that semicolon! Modifying a command line isn't difficult. You can backspace over the existing command line and replace it with a new one, or zap the whole line at once by pressing Ctrl+X, and then typing in your new command line.

When the changes are the way you want them, press Enter to retain the changes and record them in JED.CFG. If somehow you change your mind after zapping or otherwise altering the existing command line, you can abandon your changes and leave the original command line untouched by simply pressing Esc.

You'll notice that while you're editing a command line, a line of periods runs from the end of the command line to the right margin. These periods indicate how large the command line can be. You can type as far as the periods allow. If you try to type further,

JED will quite literally say "uh-uh." Try it and see!

Changing the link command line is done the same way. TASM's link command line is this:

TLINK ~

MASM's link command line, on the other hand, requires a semicolon, and for the same reasons mentioned before:

LINK ~;

These are the absolute simplest command lines possible, and will suffice for simple learning programs like EAT2.ASM. For more advanced work you may need to use assembler or linker options, which are additional commands that provide special information to the assembler or linker about the job at hand.

Figure 4.3. Changing JED's assembler and link commands

\\JED\\ Assenble/link command edit screen Assemble connand:

************************************************

Link connand: TLINK ~

Line editing commands:

CR:	Accepts changes and continues
ESC:	Abandons changes and continues

Ctrl-X: Clears entire field to empty string

BS: Destructive backspace

For example, under MASM you can specify that the assembler write the program's segments to disk in alphabetical order (don't mind for now if you don't know what that means) by using the /A option. This requires that you enter the /A option as part of the assemble command line:

MASM /A ~;

Both TASM and MASM have numerous options of this type. You won't need any of them while working your way through this book. Later on, when you graduate to larger, more sophisticated assembly-language work, you will need to understand and use these options. If you continue to use JED at that stage, you'll have to add the desired options to the assemble and link command lines.

Assembling the Current File

If you're satisfied that the assemble and link command lines are correct, it's time to assemble EAT2. Press F9, and the following things happen:

•JED saves the current file to disk. Any time JED transfers control outside of itself (by executing the program under development or by executing one of the utilities) it saves the current file.

•The screen clears, and JED invokes your assembler using the assemble command line described in the previous subsection. The assembler displays its copyright notice and certain other information on the screen. (Precisely what information displays depends on the assembler you're using.) This information will include error messages, if your source code file contains any errors.

•When the assembler is finished, JED saves the contents of the screen.

You can recall the information (typically error messages) back for examina-tion later on. Saving the screen's contents happens invisibly and takes almost no time.

• A prompt reading "Press any key to return to JED" appears in the center of the bottom line of the screen. JED then waits for a keystroke, which allows you to take time to read the displayed error messages. When you're ready to resume work, press a key and the Editor screen will reappear. An example of the screen at this point is shown in Figure 4.4.

If you recall, you made a change to EAT2.ASM a little earlier, by typing the word "FOO" on line 9. This word at this location in the file means nothing, and it will generate an assembler error message. You can see this error message as

Figure 4.4. A TASM error message

***************************************************************

Turbo Assembler	Version 2.0 Copyright (c) 1988, 1990 Borland International
Assembling file:	EAT2.ASM

**Error** EAT2.ASM(9) Illegal instruction

Error messages:	1
Warning Messages:	None
Passes:	1

Remaining Memory: 93k

Press any key to return to JED...

**************************************************************

TASM presents it, along with TASM's copyright notice and other information, in Figure 4.4. TASM calls the word "FOO" an illegal instruction because no FOO instruction exists in the 86-family instruction set. If you misspelled a genuine instruction (say, by fumble-fingering MOV into MVO) you would most likely see the same error message. Both MASM and TASM are helpful in that they identify the line where they first noticed an error. (This line is not always where the error actually is, but we'll return to that matter later in the book.) This time, the error is a pretty obvious one and no assembler should have any trouble telling you that the problem exists in line 9 of the source code file. Once you press a key and return to JED's Edit screen, move to line 9 and delete the offending line. Just press Ctrl+Y and the line will vanish. Save the repaired file by pressing F2. Finally, invoke the assembler again by pressing F9. This time you won't see any error messages.

"Make"ing and Running an Executable File

What, exactly, does running the assembler actually accomplish? By itself, not much. Invoking the assembler alone is useful to determine if there are any errors in your source code file. If the file contains no errors, you still don't have an executable program file after the assembler has done its job. What you do have is a relocatable object file, with the same name as the current file but with an .OBJ file extension. In our example here, the assembler read in the current file, EAT2.ASM, and produced a new file, EAT2.OBJ. You can't run EAT2.OBJ, and you can't read it or print it. You can't do much of anything with it, in fact, except link it. As I explained in the previous chapter linking is a process by which one or more .OBJ files are translated into an executable program file with an

.EXE extension. It's called linking because more than one .OBJ file can be combined into a single .EXE file through the linking process. However, even if you only have one .OBJ file (as we do here with EAT2) you must still perform the link step on that file to create an executable program file.

JED can perform the link step very easily. It does not, however, perform the link step all by itself. Running the assembler alone is useful to identify errors, but running the linker

alone is pretty pointless unless you intend to run the executable program file produced by the link step. JED combines the link step with the step of actually running your new assembly language program to see what it does. Furthermore, it performs the assemble step again, so that you can do it all in one keystroke: assemble, link, and away you go! When you press F10, JED will do basically the same things it did when you pressed F9, and then some:

•JED saves the current file to disk. The first time you run any new assembly-language program, you had better prepare to reboot your machine. It happens to the best of us now and then, and it will happen to you with dismaying frequency. Because we humans sometimes forget to save the source code file before running the .EXE file, JED never forgets.

•JED executes the assembler. If there are no errors in the file JED produces an .OBJ

version of the current file. If errors are detected, no .OBJ file is generated and JED immediately takes control back from the assembler with-out performing the link and "go" (that is, execute) steps. JED will wait for a keystroke so that you can stare at the error messages for awhile.

•If there were no assembler errors, JED executes the linker The .OBJ file is translated into a .EXE file. Again, there is the possibility that linker errors will occur, although they are much less common than assembler errors. If errors are detected, JED takes control back directly from the linker and the .EXE file will not be run. In the event of an error, JED waits for a keystroke so that you can examine the wreckage before pressing a key and going on.

•The .EXE file is executed. Your fledgling program runs, and when it finishes JED will once again wait for a keystroke as you examine your program's output. In our test case of EAT2, this output consists of those two lines of text shown earlier about eating at Joe's.

At this point, I have a confession to make.

What I just told you was the truth, but not the whole truth. The F10 command is a little more complicated than just those four steps. Suppose, for example, that you use the F10 command to create and run an .EXE file as we just did. Then suppose that you wanted to see it work again almost immedi-ately, without making any further changes to the program. You press F10, expecting to have to wait through the assemble and link step again.

But no...

The second time you press F10, the .EXE file executes immediately, with neither the assembler nor the linker doing their thing.