Category : Assembly Language Source Code
Archive   : D86V372.ZIP
Filename : D02.DOC

 
Output of file : D02.DOC contained in archive : D86V372.ZIP
CHAPTER 2 D86 DEMONSTRATION

To demonstrate some of the powers of D86, let's walk through a
D86 session.

1. Make sure your current directory contains all the files
A86.COM, D86.COM, and HEXOUT.8.

2. Assemble the HEXOUT program by typing the command A86
HEXOUT.8. The A86 assembler will create the files HEXOUT.COM
and HEXOUT.SYM. Look over the listing of the program, to get
acquainted with what it does.

3. Type the command D86 HEXOUT 41 42 5A followed by the ENTER
key. Everything following the "D86 " in the line you just
typed is what you would have typed if you had invoked HEXOUT
without the debugger-- 41 42 5A are the hex codes that HEXOUT
will turn into ABZ and send to the console. When the debugger
takes control, the screen should blank; and the D86 debugger
screen should appear. The blinking cursor should be at the
bottom left. A sign-on message should appear at the upper
right. A disassembly of the HEXOUT program should be in the
upper left. The label HEXOUT should appear on the first line,
followed on the second line by the address 0100 and the
instruction MOV SI,TAIL_BUFF. To the left of the address
should be a reverse video hash sign. If you have a CGA
monitor, the hash sign will blink, to compensate for the fact
that the reverse video isn't as obvious in the lower
resolution of CGA.

4. Notice the display of register values in the lower left
corner. The values are all 4-digit hexadecimal. At the top of
the second column of registers is a sequence of lower case
letters. This is the flags display. Each small letter stands
for a flag whose value is currently TRUE. The flags settings
are those that were handed to D86 by the operating system
starting the program; for MSDOS V3.1, the settings are "i z
e". That display indicates that the interrupt flag "i", the
zero flag "z", and the parity-even flag "e" are all TRUE; the
other flags are FALSE. To the right of the registers are six
lines labelled 1: through 6:. These are the memory window
lines. Since you haven't specified any memory windows yet,
they contain nothing but their numbers. Below the memory
window lines is a line labelled 0:. This is the stack display
line. The number 0: gives the number of words on the stack,
currently zero because nothing has been pushed onto the stack.

5. Observe that the sign-on message tells you to press Alt-F10
for help. Do so (that is, hold down the Alt key while
pressing the F10 key). You are now in help mode, where you
will remain until you press Alt-F10 again. D86 will keep
changing the help window, depending on what it thinks you are
doing. Right now you have a summary of the main function keys,
plus a few other things. Press F10 (without the Alt), and
you'll get a summary of one-letter debugger commands. Press
F10 a second time and you'll get a summary of Ctrl-key
commands. Finally, press F10 a third time to return to the
function-key help screen.
2-2

6. Let's try an immediate assembly language instruction. Press
the "M" key, which is the first letter of the immediate
instruction MOV AX,123. Note that the reverse video block
jumps from the hash sign within the disassembly, down to the
line just above the blinking cursor. The block is the
debugger's cursor; the blinking cursor is the program's
console output cursor. The debugger does not use the blinking
cursor because we do not want the program's output to
interfere with the debugger's output. Also note that the help
window is now telling you that you are typing in an assembly
language line.

7. Complete the line MOV AX,123 followed by the ENTER key (from
now on I'll assume that you know that lines are followed by
the ENTER key, and that any periods at the end of a line are
part of my sentence, and not part of what you type). The
debugger immediately executes the assembly language line you
just typed, setting the register AX. Note that you did not
have to learn a debugger command for setting registers; if you
know A86, you already know how to set registers! The value of
AX is now 007B, which may surprise you if you expected 0123.
A86's default base is 10, so 123 was taken as decimal; which
is hex 7B. Type MOV AX,0123 instead, to get a value of hex
123.

8. Let's now play with the flags display. Type the line ADD
AL,05D, which changes AL (the last two digits of AX) to hex
80, and alters the flags to "o is a ". The interrupt flag is
still on; but zero and parity-even are now off. They have
been replaced by "o" overflow, "s" sign, and "a" auxiliary
carry.

9. Type the line consisting of just CMC. This is the Complement
Carry instruction. Observe that the "c" appears. Notice also
that the CMC that you typed remains on the screen. Notice on
the help window the entry "F3 RepeatCmd". This tells you that
the F3 key will repeat the last line command (not function
key) that you typed. Press F3 several times, to see the carry
flag toggle on and off. Isn't that the cleanest flags display
you've ever seen?

10. Let's single step an instruction. Press the F1 key. This
executes the program instruction, loading the SI register
with TAIL_BUFF. The disassembly cursor moves down to the
next instruction. Observe that SI has changed to 0081, which
is the pointer to the invocation command tail, which should
contain the string typed after HEXOUT: " 41 42 5A" followed
by a carriage return code (hex 0D).
2-3

11. Let's examine memory to verify that last assertion. Press
the "1" key. The cursor jumps to the start of memory window
1, and the help window gives you a huge choice of memory
types to display. The entry "ByteHex 2" tells us that "B"
will cause hex bytes to be displayed. The "2" indicates that
the display occupies a fixed number of display bytes for
every memory unit, namely 2 hex digits. Type B followed by a
comma, to indicate that you want nothing but hex bytes to be
displayed. Now the help window asks for a segment location.
Let's use the DS register: type DS followed by a comma. Now
the help window wants an offset within the segment: type SI.
Before typing the terminating ENTER, backspace out what you
have typed, and watch the help windows regress appropriately.
Isn't that impressive? Now retype the line, "B,DS,SI". Note
that when you press ENTER, the line fills out with hex
values: 20 34 31 20 34 32 20 35 41 0D etc. (61 instead of 41
is OK; it means you typed the invocation in lower case.)

12. Let's look at the same line, displayed as text. Type "2",
moving to memory line 2, then type the line "T,SI". This
time you specified type T for text, and you left out the
segment register specification. D86 uses DS when you leave
out the segment register; so in this case you'll get the same
segment. This time the display starts with "41 42 5AM"; the
"M" is the carriage return, which is control-M, ambiguously
displayed. You can read Chapter 6 later on for descriptions
of all the types, including other text types allowing
non-ambiguous displays.

13. Let's execute the next instruction, CALL GET_HEX. Here we
have a choice, between executing the procedure all at once,
or stepping into the procedure to execute its instructions
one at a time. Let's try stepping in first: type the F1 key.
The cursor jumps to location GET_HEX, on the same disassembly
screen. The SP register decrements from FFFE to FFFC, and a
value 0106 appears on the stack. This is the return address,
pointing to the instruction following CALL GET_HEX.

14. Watch memory lines 1 and 2 as you press F1 again, single
stepping the LODSB instruction. You had set up the lines to
be pointed to by SI. Since SI changes when LODSB is
executed, the memory displays advance to the next byte. Note
that the AL register contains the value hex 20, a blank.

15. In a normal debugging session, we would continue stepping
within GET_HEX, but let's not do that right now. Instead,
press the F6 "TrapRet" key, which starts the program going,
trapping at the return address on top of the stack, which was
0106. The cursor jumps back up to location 0106, the value
is no longer on the stack, and SI and the memory displays
have advanced to 0084.
2-4

16. Let's try the classic "G" command, common to all debuggers.
Type the line "G,0103", noticing the help windows as you go
along. After you press ENTER, the program runs until it gets
back to the trap address you provided, 0103. Note that the
program has called OUT_VALUE to output the "A" that
corresponds to your input hex 41. The "A" appears on the
bottom line, and the blinking cursor advances.

17. Let's execute the next CALL GET_HEX all at once, by pressing
the F2 ProcStep key. SI advances again, and AL is loaded
with the next value 42.

18. Notice that the disassembly is symbolic: the display is CALL
GET_HEX, not CALL 0112 as lesser debuggers might give you.
Let's try symbolic input: type the line "B,HEX_DIGIT?",
causing the debugger to set a fixed trap at location
HEX_DIGIT?. Now set your program running with a simple G
followed by the ENTER key. The program traps at HEX_DIGIT?.
Since this location is not in the disassembly window, the
window is regenerated, and the cursor placed at HEX_DIGIT?.
The memory displays now point to the final number "5A".

19. Press F3 to repeat the G-command. The program traps at
HEX_DIGIT? again, with SI advanced to the "A". Press F3
again; advancing SI to the final carriage return.

20. Press F3 yet again. Since HEX_DIGIT? is never reached again,
the program runs to its completion. D86 automatically traps
at the EXIT instruction: in this case, it is INT 021 with the
AH register set to hex 4C, the function number for EXIT. If
we try to start the program again from here, we will be
frozen here: we must issue the Q command to exit the session.
Don't do it yet, though.

21. Before exiting, let's check out HEX_DIGIT? more thoroughly.
First, we clear the breakpoint we set, by typing "B" followed
by the ENTER key.

22. Type the command line "J 0200", jumping to a scratch-pad
memory area. Then press the F7 key, entering Patch Memory
mode. The cursor moves into the disassembled instruction,
signalling that whatever you type is clobbering it.

23. Type in the lines "INC BL", "MOV AL,BL", and "JMP
HEX_DIGIT?". Press ENTER at the beginning of the fourth
line, exiting Patch Memory mode. The cursor will return to
the left of the 0200 INC BL line.

24. Type the immediate command "MOV BL,'0'-2". The BL register
should change to the evaluated value, hex 2E.
2-5

25. Execute the patch subroutine by typing the line "CALL 0200".
The value BL increments to 2F, which is one less than the
lowest digit, '0'. The Carry flag is set, indicating that
HEX_DIGIT? has correctly judged 2F not to be a hex digit.
Now press F3 repeatedly, executing your patched subroutine
for each decimal digit. The "c" will disappear as the values
advance; and AL will hold the correct binary value for each
hex digit BL. When BL reaches 3A, the "c" comes back on
again, indicating that we are beyond the decimal digits.
When BL reaches 41, "c" goes off, and AL values of 10 through
15 are displayed. When BL reaches "47" "c" comes on yet
again, because G is not a decimal digit. Type "MOV BL,05F",
followed by "CALL 0200", followed by F3 several more times to
verify correct action for the range of lower case 'a' through
'f'. You have, relatively quickly, done a thorough test of
HEX_DIGIT?. How long would that have taken on a lesser
debugger?

26. Type Q followed by ENTER to exit the debugger.



  3 Responses to “Category : Assembly Language Source Code
Archive   : D86V372.ZIP
Filename : D02.DOC

  1. Very nice! Thank you for this wonderful archive. I wonder why I found it only now. Long live the BBS file archives!

  2. This is so awesome! 😀 I’d be cool if you could download an entire archive of this at once, though.

  3. But one thing that puzzles me is the “mtswslnkmcjklsdlsbdmMICROSOFT” string. There is an article about it here. It is definitely worth a read: http://www.os2museum.com/wp/mtswslnk/