User Documentation for XRAY Version 2.00 -- XRAY2



(c) Copyright 1987, John F. Ferguson
All rights reserved world wide

Table Of Contents
-----------------

Chapter 0General Architecture
Chapter 1Main Menu Functions
Chapter 2Window Editing
Chapter 3Command Line Parameters
Chapter 4XRAY Debugger Commands
Chapter 5Warnings
Glossary of Terms

Chapter 0General Architecture


XRAY Version 2

XRAY is a resident program developed to assist in the software
debugging process. It has many features to help programmers
developing intricate systems software, and also those working on
applications software. Further, XRAY has proven useful for simply
snooping into the PC's RAM to watch sections of memory change
dynamically.


Development

The XRAY program consists of several sections, three of which were
developed separately and subsequently merged. These sections are
the XRAY display window, the window editor, and the resident
debugger. Those of you familiar with XRAY version 1.00 will recall
that it consisted only of the display window. The original goal
for version 1.00 was to augment the various debuggers in use at the
time (1985). The extra enhancements were added on suggestions from
users of 1.00


Interrupts

XRAY splices into three major interrupts: the timer (int 08H), the
keyboard (int 09H), and the video support (int 10H). The Unhook
function (discussed in chapter 1) will temporarily attach to the
DOS function dispatcher (int 21H).

The timer is used to periodically update the display window. Timer
interrupts are generated by a peripheral timer/counter called the
8253. The chip divides down the internal crystal, generating an
interrupt type 8 each timer the divisor is satisfied. This chip is
programmed by the ROM support routines which handle the bootup
process in your computer, and the typical divisor is 65536, thus
yielding an interrupt approximately every 1/18 of a second. During
this timer interrupt XRAY moves, converts, and displays the data
from the selected portion of RAM.

The keyboard is used by XRAY to intercept the "hot key"
codes--i.e., those groupings of keys that tell XRAY to awake.
Unlike 1.00 which used the keyboard-queue interface (int 16), 2.00
is attached directly to the keyboard allowing the menu to be popped
up any time, any place, with interrupts enabled being the only
constraint. This feature is particularly useful in the debugger
portion of XRAY.

XRAY intercepts the video support only to protect the display
window. By modifying position cursor and scroll up/down calls, XRAY
maintains its window in fashionable form. Only programs which
write directly to the video regen buffer will corrupt the XRAY
display window.

Chapter 1Main Menu Functions

XRAY contains six main menu options: Sleep, Select Windows,
Window Size, Change Address, Current Location, Unhook Xray.
The main menu is invoked by pressing the Alt and left Shift
keys at the same time. A selection bar will be visible positioned
over the last option selected (initially over Sleep/Wake Up). This
bar can be moved by using the up arrow and down arrow keys on the
number pad (also visible as num pad keys 4 and 6 respectively). To
select an option press return with the selection bar positioned
over the option. Press Esc to put the main menu away. XRAY will
always display a prompt line at the bottom of the screen. This
prompt line documents the valid keys for the current option and the
function of these keys. When the key you are pressing doesn't seem
to be working properly, glance at the prompt line to be sure it is
one of the valid keys.


Sleep/Wake Up

This function is used to wake up XRAY while it is sleeping, or put
XRAY back to sleep if it is awake. To change Sleep to Wake Up, or
Wake Up to Sleep press Return (Enter) while the selection bar is
positioned over this option. If you have selected Wake Up, the
XRAY display window will be printed after you press Esc to put the
menu away.

Select Windows

Select Windows is used to select the number of active XRAY display
windows to be updated while XRAY is awake. The number of windows
can range from one to three. Simply position the selection bar
over this option and press Return (Enter). You will see a smaller
box appear below the main menu, and it will contain the current
number of active windows. You may then use the plus (+) key to add
windows and the minus (-) key to remove windows.

Window Size

The XRAY display windows can vary in size. Windows can be from one
to 20 lines in length, with the restriction that never more than a
total of 20 display lines will be shown at any one time. To adjust
the window size, position the selection bar over the Window Size
option and press return. If you have more than one active XRAY
display window, a smaller box will appear below the main menu. This
box will display the current window to be modified in zero-relative
form (0 for the upper window, 1 for the second window, 2 for the
third window). Using the plus (+) and minus (-) keys, adjust the
displayed number to the window whose size you want adjusted. When
the window number is set, press Return (Enter) to display a second
box over the first small box. This window will contain the current
number of lines the selected window occupies. Use the plus (+) key
to add to the size of the window and the minus (-) key to subtract
from the size of the window. Note that if you have only one active
XRAY display window, the first window selection box will never
appear. If you hold down on the plus key and the window size stops
before 20, you have reached the max size for this window.

Change Address

Any of the up to three XRAY display windows will display the
contents of any address in the one megabyte address space of the
PC. To set that address, the Change Address function has been
provided. Simply position the selection bar over the Change
Address option and press return. If you have multiple windows
active a smaller box will appear below the main menu allowing you
to select in which window (in zero relative form) you want to
change address. Use the plus (+) or minus (-) keys to select the
window to change address, and press Return. This will display two
small boxes with the words Segment above one and Offset above the
other. Inside of these boxes will be the segment and offset
address the selected window is currently configured for. You may
change this address by pressing any hex key (1-9, A-F). The Tab
key will switch you from box to box. The left and right arrow keys
and the backspace key also allow you to move the cursor around in
these boxes. To exit, press Esc, Return, or up arrow. Your
address will be updated after you press Esc to put the main menu
away.

Current Location

XRAY uses the timer interrupt to update the display windows. When
the timer interrupt goes off you PC can be doing everything from
waiting for a key, to printing a directory listing, to running a
program, to you name it. The Current Location is the address in
the machine that the computer was executing code when the timer
interrupt occurred. This address is updated in the upper right
corner of your monitor each time the XRAY timer routine is entered.
Using the Current Location function, you can display only certain
address, all addresses, or no addresses. The certain addresses can
be selected using segment as a key; that is, only addresses
matching the segment you select will be displayed, and addresses
with unmatched segments leave the last matching address in the
upper right corner. All addresses is the default, and this
displays every address on every interrupt. Setting no addresses
will leave the upper right corner blank. To change the Current
Location setting, position the selection bar over this option and
press Return (Enter). A smaller menu will appear below the main
menu with three options: All, None, Mine. All is the default
setting, and is selected by positioning the selection bar over ALL
and pressing Return. None will leave the upper right corner blank,
and it is selected by positioning the selection bar over None and
pressing Return. Mine allows you to enter the segment of addresses
to cause an update of the upper right corner. Position the
selection bar over this option and press return. A small box will
appear to the right of the current three-option menu with the word
Segment written above. You may now enter the hex digits to set the
new segment.

When you have a program hung in an endless loop, use the Current
Location display along with the MAP file to detect the location.
Endless loops usually traverse a rather small set of code, so you
should be able to get a fair idea of which routine is in error;
i.e., the Current Location display should continually print the
same set of addresses. You can then break in with the debugger and
use the Enter command to "patch" the program so it will continue.

Unhook XRAY

Although XRAY should not interfere with any programs in your
machine, there may be times you no longer wish to have it
installed. The Unhook function is here to allow you to disinstall
XRAY without having to reboot your machine. Unhooking XRAY will
cause the following to happen: the interrupt vectors XRAY occupies
will be replaced to their original values, the memory XRAY used by
XRAY will be returned to DOS's free list, XRAY will totally
disappear from your machine. Those of you familiar with XRAY
version 1.00 remember that it was dangerous to Unhook XRAY while
running another program. This is no longer true on version 2.00.
One warning, however, is that any TSR (Terminate Stay Resident)
programs that you loaded after XRAY which use any of the same
interrupt vectors that XRAY uses will lose control of those
vectors. This happens like this: 1) XRAY loads and saves the
timer, keyboard, and video interrupt vectors and places XRAY entry
points in these vectors, 2) the next TSR program saves one of
these vectors (an xray entry point) and places its own entry point
in its place, thus standing at the front of the line for this
interrupt, 3) Unhook is executed and XRAY restores the saved
interrupt vectors back, thereby overlaying the TSR programs entry
points.

Chapter 2Window Editing

The Window Editor

Version 2.00 contains a window editor that allows you to change
values in any of the active display windows. Please note that the
window editor cannot be invoked when the main menu is active. To
invoke the window editor, press the Alt and right Shift keys
simultaneously. This will place the cursor in the upper left
corner of the first active XRAY display window (window 0). You can
now enter hex digits to change the values of the displayed bytes.
Each hex digit will update the nibble of the hex byte over which
the cursor is positioned. If the byte does not change when you
enter a hex digit, this area may be in ROM (Read Only Memory) or
may be getting updated by some kind of interrupt routine as fast as
XRAY can update the display window. The entry of each hex nibble
should move the cursor forward, so you can look for cursor movement
if you suspect something is not working. The cursor can be moved
by using the arrow keys on the number pad to patch a specific hex
byte. To move to a window other than window zero, continually
press (or hold down) the down arrow key until the cursor is in the
window you wish to edit.

The address can also be changed from the window editor. To do
this, use the down or up arrow keys to place the cursor in the
window whose address you want to change. Now you can use PgDn to
advance the window display by one page (a page being the current
size of this window). Use PgUp to retreat the display by one page.
The Home key will place the starting address at zero, and end will
display the last page in the segment. Use the F10 function key to
advance the display by one line and the F9 function key to retreat
the display by one line. You can also use the plus (+) key to
advance the address by one byte or the minus key (-) to retreat by
one byte.

Press Esc when you have completed your editing. This will return
the cursor back to the location before you started window editing.

Chapter 3Command Line Parameters

XRAY can be invoked with command line parameters when necessary.
These parameters let you automatically wake up XRAY, specify that
you have a monitor that "snows," force use of either the monochrome
or color/graphics regen buffer, set the Current Location segment,
set the number of active windows and the addresses of each window.
The command line params can be entered in any combination, and are
processed from left to right so that the rightmost command
overrides a similar command to the left of it (like setting two
different addresses for the same window).

----
HELP
You can print a help screen of the XRAY command parms without
loading XRAY by typing:

XRAY ?

The help screen is an abbreviated form of this chapter, there only
to brush up your memory on syntax and semantics. It in no way
replaces this chapter.

-------
WAKE UP
XRAY is asleep by default. To load and automatically wake up XRAY,
type:

XRAY A

This has the same effect as if you'd run XRAY, popped up the main
menu, selected the Sleep function and pressed return (to Wake Up),
and then hit Esc to put the menu away.

-------------
REMOVING SNOW
If you are using a monitor that "snows" on direct video memory
access, XRAY version 2.00 can be set so that no direct video access
is performed during CRT phases that cause snow. To do this type:

XRAY S

XRAY will be loaded and when running will not cause the screen to
snow. You will notice, however, that the XRAY display window is
not updated as rapidly. With the S (snow) flag set, XRAY updates
one line every 1/18th of a second.

------------------
SPECIFYING MONITOR

XRAY can be set to use a specific monitor. By default, the switch
settings in your computer will determine to which CRT the XRAY
display window will be updated. To change this type:

XRAY C(to use the color/graphics)
or
XRAY M(to use the monochrome)

------------
WINDOW COUNT

XRAY version 2.00 has from 1 to three display windows available.
You can set the current count (it's one by default) by typing:

XRAY W=n

where n is a number from one to three (1-3). There can be no
spaces between the letter W, the equal sign (=), and the window
count.

-----------------
DISPLAY ADDRESSES

The XRAY windows can be set via command line parameters. This is
done by the command:

XRAY n=seg:off
or
XRAY n=seg

where n is a zero-relative window number from zero to two (0-2),
seg is an up to four digit hexadecimal segment number, and off is
an up to four digit optional offset number. If both segment and
offset are to be specified the colon (:) must separate these two
numbers.

----------------
CURRENT LOCATION
XRAY's Current Location segment is set to display all segments by
default. To change this type:

XRAY L=xxxx

where xxxx is a hex number of one to four digits. There must be no
spaces between the letter L, the equal sign (=), and the first and
last hex digit.

Chapter 4XRAY Debugger Commands

XRAY version 2.00 has as one of its features a built-in debugger.
The debugger allows you to set breakpoints, trace instructions,
display memory sections, disassemble code, and do several other
things to help uncover software mysteries and problems. This
chapter explains the commands' syntax and function.

For unfamiliar terms such as breakpoint, trace, dump, etc., refer
to the glossary of terms at the end of this document.

On breakpoints or traces, the following instruction and register
display is printed:

AX=xxxx BX=xxxx CX=xxxx DX=xxxx SI=xxxx DI=xxxx BP=xxxx IP=xxxx
CS=xxxx DS=xxxx ES=xxxx SS=xxxx SP=xxxx FL=(xxxx) f1 f2 f3 f4 f5 f6 f7 f8
ssss:iiii ddddinstruction memory data

The xxxx fields following the instructions contain the hex values
contained in those registers.

The FL register is the flags register, and the value in parenthesis
is the 16 bit value currently in the flags register. f1 is the
overflow flag, f2 is the direction flag, f3 is the interrupt flag,
f4 is the parity flag, f5 is the zero flag, f6 is the auxiliary
flag, f7 is the parity flag, and f8 is the carry flag. The flags
are the status word of the CPU chip. They describe certain aspects
of the current state of the PC, as well as the effects of some of
the instructions on the machine state. The following table shows
the bit-wise breakdown of the flags and the possible values of the
flags display.


15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
U U U U O D I T S Z U A U P U C

PositionDisplay on 0Display on 1
-------------------------------------
U - undefinedNot displayed
O - overflowNVOV
D - directionUPDN
I - interruptDI (disabled)EI (enabled)
T - trapNot displayed
S - signPLNG
Z - zeroNZZR
A - auxiliaryNAAC
P - parityPO (odd)PE (even)
C - carryNCCY

ssss:iiii is the combined value of CS:IP. This is the location of
the current instruction being displayed.

dddd is the data which was disassembled for the current
instruction.

memory data is only displayed if the instruction references memory.

------------------
CREATING ADDRESSES

In many of the following instruction descriptions you will be
instructed to enter a memory address. The XRAY debugger allows you
to specify an address in several ways as follows:

xxxx(xxxx is any hex value for offset)
xxxx:xxxx(xxxx is any hex value for segment:offset)
REG(REG is any 16 bit register)
REG:REG(REG is any 16 bit register for segment:offset)
REG:xxxx(REG is a 16 bit register, xxxx is hex number)
[xxxx](xxxx is a hex number used as indirect pointer)
xxxx:[xxxx](xxxx are hex numbers for seg:off. use off indirect)
REG:[xxxx](REG is a register, xxxx a hex number indirect)
[REG](REG is any register used indirectly as an offset)
REG:[REG](REG are any registers)

Any registers can be be used on either side of the expression. For
instance, AX:BX says use AX for the segment and BX for the offset.
Registers and hex values can be added or subtracted freely to
create an address expression: AX+BX-IP-29:200+DS-SS says add AX
plus BX minus IP minus 29 as a segment, and use 200 plus DS minus
SS as an offset. Evaluation proceeds from left to right, and no
parenthesis are allowed to alter evaluation. Also, the segment
cannot specified with indirection (i.e., the left side of the
colon).

The indirection symbols are [ and ]. Around an expression these
symbols mean take the value within the [] and go to its address to
get the value to use as an address. For example, suppose memory
location 100 contains the value 192. The expression 100 points at
memory location 100 (where the value 192 is located), while the
expression [100] points at memory location 192. The []s can also
be used multiple times. Suppose in the above example the value
C23B is contained at memory location 192. The expression [[100]]
is the same as expression [192] which is the same as expression
C23B. The []s must be matched (for every [ there is a ]), but can
be nested as deeply as the command line is long; that is, the
expression [[[[[[[[[[[[[[[ax]]]]]]]]]]]]]]] is perfectly legal, as
is [[[[[[[[ax+bx+cx+dx-es-ss-22]]]]]]]]. The []s cannot be used in
the following way: AX+[BX]+DX-[[ES]]. They must surround the
entire expression.


------------------
STICKY BREAKPOINTS

A sticky breakpoint is one that stays in effect each time start the
machine running. Sticky breakpoints only need to be specified
once; thereafter they are always in effect until released. If no
segment is specified, the current CS is used.

To set sticky breakpoints at addresses 123:90 and 70:153, enter:

b 123:90,70:53

Now each time the instruction at these addresses is reached, a
break will be executed.

example:
b CS:250,1921:75,[DI]

--------------
DUMPING MEMORY

Dumping memory is the process of creating a hexadecimal and ASCII
display of the contents of a memory location. The display is the
same as that of the XRAY display windows, as shown below:

ssss:oooo xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx bbbbbbbbbbbbbbbb

ssss:oooo is the segment and offset of the address being dumped.
Each xx value is one consecutive byte displayed in hexadecimal.
The b values are the corresponding bytes displayed in ASCII. Bytes
which are not displayable in ASCII are printed as dots (.).

Several parameters are valid with the dump command as follows:

d 101 /aDo not align display on paragraph boundary
d 101 /gPrint actual characters not dots
d 101 /nPrint a number line above display

The /a parameter leaves the display on the boundary you've
selected. The default is to print on the first line, all the bytes
up to the next paragraph boundary and then start the new boundary
on the next line. The /a will print 16 bytes, go to the next line,
print 16 bytes, continuing until the dump command is complete.
This makes the examination of tables and structures that fall at
odd address boundaries a little bit easier. If no segment is
specified, the current DS is used.

/g is used to display the graphics characters instead of the dots.
The hex portion of the display remains the same with the /g parm;
only the ASCII portion is different. In place of the dots the
character for the non-ASCII displayable code is printed.

/n Prints a number line over the top of the dumped data. This
makes locating values buried in the dump a little bit easier. The
display looks like this:

0 1 2 3 4 5 6 7 8 9 A B C D E F 0123456789ABCDEF
ssss:oooo xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx bbbbbbbbbbbbbbbb

A range can be set on the amount of data to dump by specifying a
starting and ending address, or by specifying a length in bytes.
In the following two commands for instance, the first specifies a
range and the second specifies a length in bytes:

d DS:100 200
d DS:100 l100

example:
d 200 220/g/n
d 102 l80/a

-----------
ENTER VALUE

You can change the value of memory by using the e command. Simply
type: e address (where address is as explained in the CREATING
ADDRESSES section). The debugger will print the specified address,
the value at this address and wait for your input. To skip over
bytes, press either the spacebar or the tab key. To change a value
enter the new hex value. When you have finished entering new data,
press Return. If no segment is specified, the current DS is used.

example:
e [ax+bx]


-----------
FILL MEMORY

The fill routine is used to fill a section of memory with a value.
The value can be a hex byte or a string enclosed in "s (double
quotes).

example:
f 100 200 "MY STACK",0
f 100 1000 88,AB,25


------------------
GO/START EXECUTION

The go command is used to resume execution from the current
instruction. If the go command is entered alone, the program will
continue execution with no breakpoints set (exception is "sticky"
breakpoints). If you specify one or more breakpoints, these will
be set and the program will continue execution. Version 2.00
allows up to six breakpoints, not including the sticky breaks.

When breakpoints are selected, XRAY replaces the first byte of the
instruction located at the breakpoint address with an interrupt
three (CC hex). Interrupt three is then pointed to a special
handler in XRAY. When the breakpoint is reached, its byte and the
bytes of all the specified breakpoints are restored to their
original values.

example:
g AX:[BX],CS:253,1099:1752


--------
HEX MATH

XRAY allows two hex values to be added and subtracted. To do this
type H val1 val2, where val1 and val2 are two hex values or two
registers (no indirection allowed).

example:
h AX BX
h 100 293


----------
PORT INPUT

You have access to ports with XRAY version 2.00. To read data from
a port, use the in (i) command. This command reads a byte from the
specified port and displays it in hex.

example:
i AX
i 21


---------
MOVE DATA

You can move sections of memory around using the move command.
Simply specify a starting address, a length, and a destination
address, and XRAY will move the data from the starting address to
the destination address for the specified length. On possible
overlaps (where the destination is greater than the source), the
data is moved starting from the end of the source to the end of the
destination and proceeding toward the start; in other words, from
end to start.

example:
m DS:[AX] 100 CS:200


-----------
PORT OUTPUT


You have access to ports with XRAY version 2.00. To write data to
a port, use the out (o) command. This command writes the specified
byte to the specified port.

example:
o AX FF
0 21 BC


--------------

SKIP PROCEDURE

It is often an inconvenience to skip over interrupt, call, and loop
instructions while single step tracing. The procedure command
gives you a convenient way to do this. This command is the
equivalent of the trace command if the next instruction is not a
loop, call, or int. Otherwise, it is the equivalent of setting a
break immediately after the loop, call, or int instruction.

example:
p


---------------------
REGISTER MODIFICATION

The register command can be used to modify the contents of any of
the CPU registers, or to simply redisplay the current values and
the current instruction. The register command can also be used to
adjust the value of the flags. For instance, if the current
setting of the zero flag is not zero (NZ), it can be set to zero
by executing: R F ZR. Registers can be duplicated by issuing the
command: R reg1 reg2, where reg1 and reg2 are registers.
Indirection is allowed, and any of the eight-bit registers can be
specified: AL, AH, BL, BH, CL, CH, DL, DH. To display the current
registers and instruction just type r and Return. You can either
type r reg and then Return, or r reg newval and then Return. If
you do not enter the new value on the command line, XRAY will
display the register's current contents and prompt you for the new
contents. If you enter the new contents on the command line, XRAY
will modify the register and display its old contents.

The following table shows the valid flag modification values:

FlagYou enter:1 (set)0 (off)
-----------------------
CarryCY carryNC no carry
ParityPE parity evenPO parity odd
Aux carryAC aux carryNA no aux carry
ZeroZR zeroNZ not zero
SignNG negativePL positive
InterruptEI enabled intsDI disabled ints
DirectionDN direction downUP direction up
OverflowOV overflowNV no overflow

example:
r
r AX [[AX]]
r AH 33
r f ov ei zr nc


-------------
SEARCH MEMORY

You can search memory for a specified value using the search
command. The search argument can be either a string enclosed in
double quotes ("), or a series of hex bytes separated by commas
(,). You also have the option to search the entire RAM space of
your machine with the /a parameter. /a will start at location
0000:0000 in your machine and proceed to the end of you RAM space.
In either search 64k or search all mode, when the string is found
the location address is printed in absolute 20-bit address form,
CS:offset form (if within the 64k CS space), DS:offset form (if in
the 64k DS space), ES:offset (if within 64k), and SS:offset (if in
the 64k SS space). In the /a form, the segments are searched
starting at 0000:0 to 0000:FFFF, then 1000:0 to 10000:FFFF, to the
last 64k segment (each 1000 segment bytes is 64k). A byte length
to search can also be specified.

example:
s "COMMAND" /a
s 0:0 8700 "IBMBIO"
s CS:100 FFFF 0D,0A,"Hello World!",0
s DS:0 l 100 "MYPROG.COM"


-----------------
TRACE INSTRUCTION

The trace command allows you to execute one instruction and break.
This lets you follow the execution of a program, and allows you to
find bugs in your or, hopefully, someone else's code. Because of
the way the trace routine is written, you can even trace into DOS
to find out how the internals of the operating system work! You
can also enter a trace count with the trace command, and this count
tells the trace routine how many instructions to trace before
breaking. For example, t 10 would execute 10 hex (16)
instructions, each being displayed along with register contents,
and then break on the current instruction + 10 instruction.

example:
t
t 3


---------------
UNASSEMBLE CODE

Unassemble allows you to disassemble sections of code to see what
instructions are contained there. The address, instruction data,
and instruction are displayed as follows:

isegment:ioffset idata instruction

where isegment:ioffset is the segment:offset of this instruction,
idata is the instruction in its RAM format, and instruction is the
disassembled form of idata. Instructions which do not make sense
to the XRAY disassembler are printed as either DB ? or DW ? and a
comment is displayed saying Unimplemented instruction. XRAY
version 2.00 will not disassemble protected mode instructions of
the 80286 or any of the 32 bit instructions of the 80386. Like the
dump command, unassemble allows you to set a range and a length,
the length being number of instructions rather than bytes:

u CS:200 255(unassemble from CS:200 up to CS:255)
u CS:200 l10(unassemble from CS:200 for 10 hex instructions).

example:
u CS:100 300
u [[[AX]]]
u 100 l 5


------------
HELP COMMAND

You can get help while in the debugger by typing ? and then Return.
To get more specific help on a specific command, type ? c, where c
is the command.

example:
?
? t


-------------
SPEED CONTROL

For commands like dump (d), unassemble (u), and trace (t) with a
range specified, sometimes the display moves too fast to read.
XRAY 2.00 allows you to control the speed of these ranged commands
using the plus (+) and minus (-) keys. The minus key subtracts a
constant value from a delay counter and the plus key adds the same
constant to the delay counter--the delay counter is by default set
to zero. Hold down on the plus key to slow the screen down
progressively. Subsequently use the minus key to speed the speed
up. The delay stays in effect until you reset it, even on single
commands. The maximum slowdown is achieved by pressing the minus
key once when currently operating with the default counter set at 0
(the max speed). You can clear the speed back to zero by pressing
the c key. Pressing Ctrl and the Break keys simultaneously will
stop a multicommand from running.

NOTE: the plus, minus, c, and Ctrl/Break keys are only active
during the processing of a command. That is, while a dump display
is running, multi trace is running, etc. Pressing these keys at
the command line and pressing return does not affect the delay
counter.

Chapter 5Warnings

A few last warnings are in order before finishing the
documentation.

1) Do not Unhook XRAY with XRAY-debugger breakpoints and/or sticky
breakpoints set. Always bring up the XRAY debugger and remove
any sticky breakpoints before the Unhook function. Failing to
do this can cause your system to hang if a breakpoint is hit
at a later time when XRAY is no longer in memory.

2) Do not set breakpoints in the hardware interrupt handlers for
timer or keyboard. If you do, you will be unable to enter keys
at the XRAY prompt because of the interrupt priorites.

3) Do not patch XRAY version 2.00. While XRAY 2.00 is not copy
protected (you can make as many backup copies as you need), it
is not shareware. I personalized it for you, and it is meant
for your use only. The name and serial number which print at
load time are embedded in the program and checked periodically.
If you patch XRAY version 2.00, the run-time results are totally
unpredictable.

4) The disassembler does not correctly handle the opcodes of the
8087 numeric data processor. This was brought to my attention
after distribution had already commenced. The next version of
XRAY (3.00) will correctly disassemble these opcodes.

5) Protected mode instructions are not disassembled correctly.
This was intentionally done because XRAY would not work well in
protected mode in the first place; thus, it seemed unnecessary
to waste RAM space with the mnemonics and decoding subroutines.

6) Pressing Ctrl and Break in the debugger sometimes places one
invalid, unprintable character on the next command line. For
instance, if you are doing a dump command and press Ctrl/Break
the next command you enter will sometimes be invalid (fixed in
3.00).

Glossary of Terms

ASCII - a form of encoding all the computer characters into seven
bits.

breakpoint - An address which when reached will generate an interrupt
3 invoking the XRAY debugger.

byte - One character of data.

disassemble - see unassemble.

display window - An active XRAY window which displays in real time a
section of memory in both hexadecimal and ASCII.

dump - Printing a section of memory in hexadecimal and ASCII.

hexadecimal (hex) - A numbering system based on a radix of 16.

interrupt - A hardware or software generated event which transfers
control to a special software subroutine.

offset - A value from 0 to 65536 decimal (FFFF hexadecimal) which
represents a byte location in a 64kbyte segment (see segment).

patch - Making a manual change to a software instruction or data.

port - An address of a device register accessible only via in and out
commands.

segment - On the 8088 and similar chips a segment is a memory
location on a 16-byte boundary; i.e., it is evenly divisible by 16.
Four segments exist on these chips, and are addressed by the four
registers: CS (code segment), DS (data segment), ES (extra segment),
SS (stack segment).

trace - The process of executing one instruction and then breaking
(coming to a stop).

unassemble (disassemble) - The process of taking a program's code in
raw data form and converting it into the assembly language
mnemonics.

word - Two bytes of data (see byte).