Simple A DEBUG Tutorial Details of each Command
NOTE: In the Examples below, commands which are entered by a user are shown in bold type; data displayed in response by DEBUG is in normal type. DEBUG (from MS-DOS 5.0 or later (which is true for the DEBUG version used by Windows XP) will display the following usage message, if you enter debug /? at a DOS prompt:
C:\WINDOWS>debug /? Runs Debug, a program testing and editing tool. DEBUG [[drive:][path]filename [testfile-parameters]] [drive:][path]filename testfile-parameters Specifies the file you want to test. Specifies command-line information required by the file you want to test.
Quit:
Q
Immediately quits (exits) the Debug program! No questions ever asked... should be the first command you remember along with the "?" command.
Hex:
H
value1
value2
A very simple (add and subtract only) Hex calculator. Never forget that all numbers inside of DEBUG are always Hexadecimal. Enter two Hex values (no more than four digits each) and DEBUG shows first the SUM, then the DIFFERENCE of those values. Examples:
-h aaa 531 0FDB 0579 -
-h fff 3 1002 0FFC -
-h dbf ace 188D 02F1 -
Differences are always the second value subtracted from the first; AAA - 531 = 579. There are no carries past four digits. Two's Complement arithmetic is always used in this calculator, so think of it as being limited to a maximum of plus 7FFFh (+ 32,767) or a minimum of minus 8000h (- 32,768). Positive values are represented by exactly the same digits as their numbers for 0000h through 7FFFh. A minus 7FFFh, however, is represented by the Hex digits 8001, and a minus 1h (-1) is represented by the Hex digits FFFF. Thus, the output of DEBUG after entering "h 4 fffc" would be a zero and an 8, because FFFC represents a minus 4h (-4) and 4 - (-4) = 8. Examples:
-h 4 fffc 0000 0008 -
-h 100 123 0223 FFDD -
-h 7fff 8000 FFFF FFFF 1
Notice that the difference between 100h and 123h is FFDD; what does that represent? To find the numerical value of a Two's Complement number, first invert every bit (or find its logical inverse); that would be 0022, then add 1. So, this represents a negative 23h. Both the sum and the difference of 7FFFh and 8000h are a negative 1 (or FFFF). You can, of course, think of the sums as having nothing to do with a Two's Complement notation; thus 7FFFh + 8000h = FFFFh (32,767 + 32,768 = 65,535). This will even hold true for the differences if the second value is less than the first. But as soon as the difference produces a negative number, it must be represented in Two's Complement.
Dump:
D D
[range] [address]
[length]
Displays the contents of a block of memory. The Memory locations near the beginning of Segment C000 (even under Windows 2000/XP) should display information about the kind of video card installed on your PC. The first example below shows what a Matrox video card on our system displayed.
Examples:
-d c000:0010 C000:0010 24 C000:0020 4D C000:0030 52 C000:0040 2F C000:0050 29 C000:0060 50 C000:0070 40 C000:0080 E8 -d 100 130 xxxx:0100 EB xxxx:0110 69 xxxx:0120 61 xxxx:0130 21 12 20 4F 56 00 43 00 26 FF 43 58 42 87 49 12 56 FF 4F 2F 45 DB 52 10 8B 00 4D 4D 20 87 2B 00 D8 00 50 47 42 DB 10 80 E8 00 41 41 49 87 01 00 C6 00-60 54-49 2D-47 4F-53 DB-87 10-00 00-38 56-74 00 42 31 20 DB 00 37 22 00 4C 30 28 87 18 34 8C 00 45 30 56 DB 00 2D C8 00 20 20 31 87 00 32 3D 20 4D 56 2E DB 00 00 00 49 41 47 32 87 00 FF C0 42 54 41 20 DB 03 FF 74 $.......`.... IB M COMPATIBLE MAT ROX/MGA-G100 VGA /VBE BIOS (V1.2 )............... PCIR+........... @.......874-2... .&V....Vt"..=..t
24 0D 0A 54 68 69 73-20 69 73 20 6D 79 20 66 72 73 74 20 44 45 42-55 47 20 70 72 6F 67 72 6D 21 0D 0A 24 B4 09-BA 02 01 CD 21 B4 00 CD
.$..This is my f irst DEBUG progr am!..$......!... !
The last example above, is what you'd see after entering the code under the Assemble command. We could just as easily have used the length option with the command 'd 100 l31' (that's an 'L' in front of the "31") to produce the same results above. The following example shows only the '$'-terminated display string, which has a length of 24h bytes (remember numbers in DEBUG are always hexadecimal); so, that's 36 in decimal:
-d 102 l24 xxxx:0100 0D 0A 54 68 69 73-20 69 73 20 6D 79 20 66 xxxx:0110 69 72 73 74 20 44 45 42-55 47 20 70 72 6F 67 72 xxxx:0120 61 6D 21 0D 0A 24 -
..This is my f irst DEBUG progr am!..$
Search:
S
range
list
Searches within a range of addresses for a pattern of one or more byte values given in a list. The list can be comprised of numbers or character strings enclosed by matching single or double quote marks. [ NOTE: In the examples below, if you do find the same data on your computer, the locations could easily vary from ours! ]
2
Examples:
-s fe00:0 ffff "BIOS" FE00:0021 FE00:006F -d fe00:0 FE00:0000 FE00:0010 FE00:0020 FE00:0030 FE00:0040 FE00:0050 FE00:0060 FE00:0070
41 4D 20 41 6E 41 1B 49
77 20 42 77 63 77 41 4F
61 43 49 61 2E 03 77 53
72 4F 4F 72 6F 0C 61 20
64 4D 53 64 66 04 72 76
20 50 20 20 74 01 64 34
53 41 43 53 77 01 20 2E
6F-66 54-49 4F-50 6F-66 61-72 6F-66 4D-6F 35-31
74 42 59 74 65 74 64 50
77 4C 52 77 20 77 75 47
61 45 49 61 49 E9 6C 00
72 20 47 72 6E 12 61 DB
65 34 48 65 63 14 72 32
49 38 54 20 2E 20 20 EC
42 36 20 49 20 43 42 33
Award SoftwareIB M COMPATIBLE 486 BIOS COPYRIGHT Award Software I nc.oftware Inc. Aw.....oftw... C .Award Modular B IOS v4.51PG..2.3
-s 0:0 dff 'A20' 0000:0C42 -d 0:c40 0000:0C40 0000:0C50 0000:0C60 0000:0C70 0000:0C80
0D 72 65 20 20
0A 72 63 74 70
41 6F 68 6F 72
32 72 6E 20 6F
30 2E 69 69 62
20 20 63 64 6C
68 20 61 65 65
61-72 43-6F 6C-20 6E-74 6D-2E
64 6E 73 69 0D
77 74 75 66 0A
61 61 70 79 24
72 63 70 20 1A
65 74 6F 74 00
20 20 72 68 BA
65 74 74 65 F6
..A20 hardware e rror. Contact t echnical support to identify the problem...$....
-s 0:0 dff 43 4f 4d 0000:0774 0000:07C2 0000:07D4 0000:07E6 -d 0:770 0000:0770 0000:0780 0000:0790 0000:07A0 0000:07B0 0000:07C0 0000:07D0 0000:07E0
7A C0 70 2D 20 AC 7A 00
02 A0 00 01 20 02 02 80
A6 7A C0 70 11 43 B2 7A
02 02 A0 00 EA 4F 02 02
43 91 7A C0 27 4D 43 B8
4F 02 02 A0 27 32 4F 02
4D 4C 98 7A 3F 20 4D 43
31-20 50-54 02-4C 02-9F FD-CA 20-20 33-20 4F-4D
20 31 50 02 00 20 20 34
20 20 54 4C 70 DC 20 20
20 20 32 50 00 00 20 20
8E 20 20 54 00 70 00 20
00 20 20 33 80 00 00 20
70 A0 20 20 7A 00 6B E8
00 00 20 20 02 80 03 D2
z...COM1 ..p. ..z...LPT1 .. p...z...LPT2 -.p...z...LPT3 ..''?...p...z. ..COM2 ..p... z...COM3 ..k. ..z...COM4 ..
Compare:
-c 140 148 127D:0143 127D:0146 127D:0148
C
340 30 6D 10 63 49 30
range
127D:0343 127D:0346 127D:0348
address
Compares two blocks of memory. If there are no differences, then DEBUG simply displays another prompt (-). Here's an example of what happens when there are differences:
The bytes at locations 140 through 148 are being compared to those at 340 ( through 348, implied ); the bytes are displayed side by side for those which are different (with their exact locations, including the segment, on either side of them).
3
Fill:
-f 100 12f -d 100 12f xxxx:0100 xxxx:0110 xxxx:0120
F
range
list
This command can also be used to clear a whole segment of Memory as well as filling smaller areas with a continuously repeating phrase or single byte. Examples:
'BUFFER' 42 55 46 46 45 52 42 55-46 46 45 52 42 55 46 46 BUFFERBUFFERBUFF 45 52 42 55 46 46 45 52-42 55 46 46 45 52 42 55 ERBUFFERBUFFERBU 46 46 45 52 42 55 46 46-45 52 42 55 46 46 45 52 FFERBUFFERBUFFER
-f 100 ffff 0
This last example fills almost all of the assigned Segment with zero bytes (which can also be thought of as clearing the Segment). You should use this command whenever you want to be sure that the bytes you'll be looking at in DEBUG's Segment are those you've manually entered or loaded; not just previously used code in memory! If you want to examine a file from a disk in a 'clean' Segment, you'll first have to start DEBUG without any filename, clear the Segment using: f 100 ffff 0 and then finally load the file using the Name (n) and Load (L) commands in that order. NOTE: Filling (clearing) any bytes in the area from 00h through FFh of the Segment used by DEBUG can sometimes lead to problems; especially when file I/O is involved. DEBUG stores data for its own use in those locations, so we recommend that you never overwrite bytes in that area; unless you know for sure they won't be necessary! Example: A student in an Assembly class was told to enter a string of commands under DEBUG, the last one being: JMP 0 which he was supposed to Trace (T) to the next command and then execute it. He was told it would be an INT 20 instruction. Well in most cases this is true, because DEBUG always sets the first two bytes of its working segment to "CD 20" for just this purpose. Let's test this out. First, open a new instance of DEBUG, then enter the following commands:
-f 100 ffff 0 [Zero-out 100 through FFFF] -e 100 e9 fd fe [Enters a 'JMP 0' at 100] -u 100 102 [Check for correct entry] xxxx:0100 E9FDFE JMP 0000 -r AX=0000 BX=0000 CX=0000 DX=0000 SP=FFEE BP=0000 SI=0000 DI=0000 DS=xxxx ES=xxxx SS=xxxx CS=xxxx IP=0100 NV UP EI PL NZ NA PO NC xxxx:0100 E9FDFE JMP 0000 -u 0 1 xxxx:0000 CD20 INT 20
If you don't see "INT 20" after entering "u 0 1", then restart DEBUG and try again.
-t [The "T"(Trace) command]
AX=0000 BX=0000 CX=0000 DX=0000 SP=FFEE BP=0000 SI=0000 DI=0000 DS=xxxx ES=xxxx SS=xxxx CS=xxxx IP=0000 NV UP EI PL NZ NA PO NC xxxx:0000 CD20 INT 20 -p [Always make sure you use a "P"(Proceed) command for Interrupts!] Program terminated normally -q [Quit]
Well, this never worked for those students. Why? Because the teacher had mistakenly told them to Fill the whole segment with zero bytes (f 0 ffff 0), in essence telling them to delete the very instruction he'd wanted them to execute! 4
Enter:
-e ffcb d2
E
address
[list]
Used to enter data or instructions (as machine code) directly into Memory locations. Example. First we'll change a single byte at location CS:FFCB from whatever it was before to D2 : The next two examples show that either single(') or double(") quote marks are acceptable for entering ASCII data. By allowing both forms, you can include the other type of quote mark within your entry string:
-e 200 'An "ASCII-Z string" is always followed by ' -e 22a "a zero-byte ('00h')." 00
Now let's examine a string of 11 hex bytes that you can enter into Memory at locations CS:0100 and following:
-e 100 B4 09 BA 0B 01 CD 21 B4 00 CD 21
This is actually machine code for a program that will display whatever ASCII characters it finds at locations CS:010B and following, until it encounters a byte value of 24h (a $ sign). If you really want to run this program, you should at least enter a 24h in the last byte of the Segment; that will make sure the program finally terminates there, if necessary! Just do the following:
-e ffff 24 -g =100
NOTE: You can save this program to your hard drive, by first giving it a path and filename (such as, C:\TEMP\ASCIIDSP.COM; see 'N' Name command) and writing the bytes (see 'W' Write command) to a file like this:
-n c:\temp\asciidsp.com -rcx CX0000 [ Program Length = 220h - 100h + 1 = 121h ] :121 -w
Go:
G
[=address]
[addresses]
Go is used to run a program and set breakpoints in the program's code. As we saw in an Example for the ENTER command, the '=address' option is used to tell DEBUG a starting location. If you use 'g' all by itself, execution will begin at whatever location is pointed to by the CS:IP registers. Optional breakpoints ( meaning the program will HALT before executing the code at any of these locations) of up to any ten addresses may be set by simply listing them on the command line. Requirements: Breakpoints can only be set at an address containing the first byte of a valid 8088/8086 Opcode. So don't be surprised if picking some arbitrary address never halts the program; especially if you're trying to DEBUG a program containing opcodes DEBUG can't understand (that's anything 'requiring' a CPU above an 8088/8086)! CAUTION: DEBUG replaces the original instructions of any listed breakpoint addresses with CCh (an INT 3). The instructions at these locations are restored to their originals ONLY if one of the breakpoints is encountered... If DEBUG does not HALT on any breakpoint, then all your breakpoints are still enabled! So, don't ever save the code as is, unless you're sure that DEBUG has hit one of your breakpoints! ( Saving to a backup copy before ever using breakpoints is often a better way. )
Assemble:
A
[address]
5
Creates machine executable code in memory beginning at CS:0100 (or the specified address) from the 8086/8088 (and 8087) Assembly Language instructions which are entered. Although no Macro instructions nor
labels are recognized, you can use the pseudo-instructions 'DB' and 'DW' (so you can use the DB opcode to enter ASCII data like this: DB 'This is a string',0D,0A ). The 'A' command remembers the last location where any data was assembled, so successive 'A' commands (when no address is specified) will always begin at the next address in the chain of assembled instructions. This aspect of the command is similar to the Dump command which remembers the location of its last dump (if no new address is specified). The assembly process will stop after you ENTER an empty line. Example; you ENTER the characters in bold type; you do not need to enter the comments after the semicolon ( ; ) symbols :
-a 100 xxxx:0100 xxxx:0102 xxxx:0123 xxxx:0126 xxxx:0128 xxxx:012B xxxx:012D xxxx:012F xxxx:0131 -g =100 jmp 126 ; db 0d,0a,"This db 0d,0a,"$" mov ah,9 ; mov dx,102 ; int 21 ; mov ah,0 ; int 21 ; Jump over data that follows: is my first DEBUG program!" Function 09 of Int 21h: DS:DX -> $-terminated string. Write String to STD Output. Function 00 of Int 21h: Terminate Program.
This is my first DEBUG program! Program terminated normally -
NOTE: You can pipe simple 8086/8088 Assembly Language "scripts" into DEBUG (You can even include a semi-colon ';' followed by comments on most of its lines. For some odd reason though, these comments are not allowed on DB/DW lines!). For example, you can copy and paste the following into the DEBUG program (after entering the "a" command) and obtain the same results as above:
jmp 126 ; Jump over data that follows: db 0d,0a,"This is my first DEBUG program!" db 0d,0a,"$" ; End of string marker above: "$"=24h mov ah,9 ; Function 09 of Int 21h: mov dx,102 ; DS:DX -> $-terminated string. int 21 ; Write String to STD Output. mov ah,0 ; Function 00 of Int 21h: int 21 ; Terminate Program.
DEBUG uses the convention of enclosing operands which refer to Memory locations in square brackets '[ ]' (as opposed to an immediate value as an operand). DEBUG may require you to explicitly tell it whether or not an operand refers to a word or byte in Memory! In such cases, the data type must be stated using the prefixes 'WORD PTR' or 'BYTE PTR'
For all 8087 opcodes, the WAIT or FWAIT prefix must be explicitly specified.
6
Unassemble:
U
[range]
Disassembles machine instructions into 8086 Assembly code. Without the optional [range], it uses Offset 100 as its starting point, disassembles about 32 bytes and then remembers the next byte it should start with if the command is used again. ( The word 'about' was used above, because it may be necessary to finish with an odd-number of bytes greater than 32, depending upon the last type of instruction DEBUG has to disassemble. ) NOTE: The user must decide whether the bytes that DEBUG disassembles are all 8086 instructions, just data or any of the newer x86 instructions (such as those for the 80286, 80386 on up to the lastest CPU from Intel; which are all beyond the ability of DEBUG to understand)! Example:
-u 126 12F xxxx:0126 B409 xxxx:0128 BA0201 xxxx:012B xxxx:012D CD21 B400 xxxx:012F CD21 -
MOV MOV INT MOV INT
AH,09 DX,0102 21 AH,00 21
Input:
I
port
The use of I/O commands while running Windows9x/Me is just plain unreliable! This is especially true when trying to directly access hard disks! Under Win NT/2000/XP, the I/O commands are only an emulation; so don't trust them. Though the example below still works under Win2000/XP, it's most likely using some WinAPI code to show what's in the Windows clock area; not directly from an RTC chip. Long ago (when DOS was the only OS for PCs), there were dozens of BASIC programs that used I/O commands for handling tasks through parallel and serial ports (e.g., to change the font used by a printer or values in a modem's control registers). Under real DOS, they can still be used for direct communications with keyboards or a floppy drive's control chips along with many other hardware devices. Here's an example of how to read the hours and minutes from a computer's "real time clock" (RTC):
-o -i 18 -o -i 52
70 04 <-- Check the hours. 71 <----- 18 hours (or 6 p.m.) 70 02 <-- Check the minutes. 71 <----- 52 minutes
The first space isn't necessary under most versions of DEBUG; so you can try to get away with just "o70" and "i71" instead.
Output:
O
port
byte
See comments under the Input command.
7
Load: L [address] [drive] [firstsector] [number] or program! (See the N command for more on this)
This command will LOAD the selected number of sectors from any disk's Logical Drive under the control of MS-DOS or Windows into Memory. The address is the location in Memory the data will be copied to (use only 4 hex digits to keep it within the memory allocated to DEBUG), the drive number is mapped as: 0=A:, 1=B:, 2=C:, etc., firstsector counts from ZERO to the largest sector in the volume and finally number specifies in hexadecimal the total number of sectors that will be copied into Memory (so a floppy disk with 0 through 2,879 sectors would be: 0 through B3F in Hex). The terms 'Volume' or 'Logical Drive' used in the definition above mean that you can not use the 'L' command to load or examine the MBR, or any other sectors outside of the Primary Volumes or Logical Drive Letters assigned by DOS or Windows! For example (under Windows 9x/ME), if you enter the command: L 100 2 0 1 in DEBUG, instead of seeing the very first sector on that hard disk (the MBR), you'll see the first sector of the Boot Record for the Logical drive C: instead (the first partition that can accessed by a compatible MS-DOS or Windows OS). This and the following comments about diskettes, show that DEBUG has always been quite limited compared to a good disk editor or the UNIX 'dd' program. Load can still be useful in examining Floppy Disks even under Windows 2000/XP, but (unfortunately), only if the disk can be read by MS-DOS or Windows. Once again, this shows how limited DEBUG is compared to any utility that can view the raw data on either a hard drive or diskette. Unlike hard disks, the very first sector on a floppy disk is an OS Boot sector. Here's what you might see from a Logical disk sector and some dumps from a couple floppy disks.
Examples:
-l 100 2 0 -d 100 10f xxxx:0100 -d 280 2ff xxxx:0280 xxxx:0290 xxxx:02A0 xxxx:02B0 xxxx:02C0 xxxx:02D0 xxxx:02E0 xxxx:02F0 -l 100 0 0 -d 100 13d xxxx:0100 xxxx:0110 xxxx:0120 xxxx:0130 -l 100 0 0 -d 100 13d xxxx:0100 xxxx:0110 xxxx:0120 xxxx:0130 1 [ the C: drive. ] .X.MSWIN4.1... . .'..Invalid syst em disk...Disk I /O error...Repla ce the disk, and then press any key.....IO SYSMSDOS SYS~. .WINBOOT SYS..U.
EB 58 90 4D 53 57 49 4E-34 2E 31 00 02 08 20 00 01 65 2F 63 20 6B 53 00 1 EB 02 00 4D 1 EB 02 00 20 27 6D 4F 65 74 65 59 57 0D 20 20 20 68 79 53 49 0A 64 65 74 65 0D 4D 4E 49 69 72 68 6E 0A 53 42 6E 73 72 65 20 00 44 4F 76 6B 6F 20 70 00 4F 4F 61-6C FF-0D 72-FF 64-69 72-65 00-49 53-20 54-20 69 0A 0D 73 73 4F 20 53 64 44 0A 6B 73 20 20 59 20 69 52 2C 20 20 53 53 73 73 65 20 61 20 59 00 79 6B 70 61 6E 20 53 00 73 20 6C 6E 79 20 7E 55 74 49 61 64 20 20 01 AA
[ a floppy in the A: drive. ] 3C E0 00 45 90 00 00 20 29 40 00 20 47 0B 00 20 38 F0 00 20 71 09 29 46 33-49 00-12 40-16 41-54 48 00 D8 31 43 02 13 32 00 00 4E 20 02 00 4F 20 01 01 00 00 00 00 20 4E 41 20 .<.)G8q3IHC..... ...@............ ......)@...NO NA ME FAT12
[ a different floppy in the A: drive. ] 3C E0 00 20 90 00 00 20 53 40 00 20 59 0B 00 20 53 F0 00 20 4C 09 29 46 49-4E 00-12 7E-CF 41-54 55 00 55 31 58 02 3C 32 00 00 20 20 02 00 20 20 01 01 00 00 00 00 20 20 20 20 .<.SYSLINUX..... ...@............ ......)~.U< FAT12
8
-d 2d0 2ff xxxx:02D0 42 3B 16 1A 7C 72 03 40-31 D2 29 F1 EB A7 42 6F xxxx:02E0 6F 74 20 66 61 69 6C 65-64 0D 0A 00 00 00 00 4C xxxx:02F0 44 4C 49 4E 55 58 20 53-59 53 F4 3C 82 3A 55 AA
B;..|r.@1.)...Bo ot failed......L DLINUX SYS.<.:U.
Note that the Linux Boot disk above (note the word: SYSLINUX) is the kind formatted as an MS-DOS diskette and not with a true Linux file system (such as ext2 or ext3). If it had been formatted with some other kind of file system, or had a faulty boot sector, then MS-DEBUG would not be able to read it! Instead you'd see that old "General failure reading drive A / Abort, Retry, Fail?" error message! And when you had finally cleared away that error message, you'd be greeted by DEBUG's "Disk error reading drive A" error message. This makes DEBUG almost worthless as far as trying to fix an error in a floppy disk's boot sector! However, if you keep a binary copy of a good floppy disk Boot Sector somewhere, you could use DEBUG to overwrite whatever's on a faulty floppy disk's first sector (see Write command). But if you really want to see what's in such a Boot sector (that keeps DEBUG from recognizing it as valid), you'll need to use a disk editor such as Symantec's Norton DiskEdit (in Physical disk Mode only). NOTE: Just because a floppy disk can't be read by DOS or opened in DEBUG does NOT necessarily mean it's defective. It might simply have been formatted with a file system it cannot recognize (such as Linux's ext2) and could easily boot-up on its own; this is a very good reason for labeling your disks! (CAUTION: Never try booting your system with a disk you're not 100% sure of; unless you disconnect all hard disks and don't have any flash BIOS, since it might contain a nasty boot virus! )
Move:
Examples:
M
range
address
This command should really be called: COPY (not Move) as it actually copies all the bytes from within the specified range to a new address.
1) 2)
-m 7c00 7cff 600 -m 100 2ff 70
Copies all the bytes between Offset 7C00 and 7CFF (inclusive) to Offset 0600 and following... This second example shows that it's very easy to overwrite most of the source you're copying from using the Move command. Apparently, DEBUG stores the source bytes elsewhere before writing them; otherwise, this example would cause a problem when it started overwriting what it hadn't copied yet! This copies the 512 bytes between Offsets 100h and 2FFh (inclusive) to Offset 0070 overwriting the first 368 bytes in the process.
Name:
N
[pathname]
[arglist]
This command can be used to load files into DEBUG's Memory after you have started the program, but it's main function is to create a new file under control of the Operating System which DEBUG can WRITE data to. Normally, when you want to 'debug' a file, you'd start DEBUG with a command like this: C:\WINDOWS>debug test.com . But it's also possible to load a file into DEBUG's Memory from within DEBUG itself by using the 'N' command and then the 'L' command (with no parameters) like this:
-n c:\temp\test.com -l
which will load the file test.com into DEBUG's Memory starting at location CS:0100 (you cannot specify any other location when using the L command like this!).
9
The 'N' command makes it quite easy to save data or an Assembly program created in DEBUG to a file on your hard drive! For example, these commands (in bold; along with DEBUG's reponses):
-n c:\temp\doswinok.com -a 100 cs:0100 jmp 138 cs:0102 db 0d,0a,"It's OK to run this " cs:0118 db "program under DOS or Windows!" cs:0135 db 0d,0a,24 cs:0138 mov dx,102 cs:013B mov ah,9 cs:013D int 21 cs:013F mov ax,4c01 cs:0142 int 21 cs:0144 -rcx CX 0000 :44 -w Writing 00044 bytes [ 68 bytes in decimal ] -q
will create a 68-byte file called DOSWINOK.COM in the C:\TEMP folder; even when running DEBUG in a DOS-window. The file names, however, are still limited to DOS's eight characters plus three for the extension (an 8.3 filename as it's often called)! Note: Unlike the other programs listed on this page, this one uses Function 4Ch instead of Function 00 of Interrupt 21h to terminate its execution. This is the preferred termination function for most DOS programs, because it can not only send a "Return Code" (an ERRORLEVEL value; of whatever is in the AL register), but will also close all open files and free all memory belonging to the process. When you use this function to terminate a program running under DEBUG though, it has a tendency to also terminate DEBUG itself; thus our reason for rarely using it here!
Register:
R
[register]
Entering ' r ' all by itself will display all of the 8086 register's contents and the next instruction which the IP register points to in both machine code and an unassembled (Assembly Language) form. For example, if you start DEBUG in a Windows 95B DOS-box with the command line:
>debug c:\windows\command\choice.com
and then enter an ' r ' at the first DEBUG prompt, DEBUG will displa...