\?
Syntax: ? [<function><sub-function>]

This command displays the debugger commands by function and sub-function if
the on-line help file has been loaded. If the help file is not available, a
command summary is displayed.
\A
Syntax: A [<address>]

This command assembles instructions to memory. If no address is specified,
CS:IP is used. Enter the instructions to be assembled and press return after
each line. To terminate the assembly, press return when the cursor is at the
beginning of a new line. If a prefix instruction such as a segment override
or a repeat prefix is used, it must be on a separate line preceding the
instruction it affects. Various forms of the opcodes are supported, including
synonyms such as JE and JZ, etc. There are two special cases -- string
primitives such as MOVS must explicitly reference a byte or word (MOVSB or
MOVSW) and a far return must be entered as RETF. When referencing memory, be
sure to use brackets around the address field to differentiate it from a
direct reference. When using symbols, the symbol name must be preceded by @
or a period. If you are referencing the contents of a symbol, be sure to put
the symbol name in brackets. To get the offset of a symbol into a register, do
not use the brackets. For instructions that require the phrase byte ptr or word
ptr to specify the width of the operation, use b or w, in upper or lower case,
instead.
\AU
Syntax: AU [<address>]

This command is the same as the assemble command, except that it disassembles
an instruction immediately after assembling it.
\BA
Syntax: BA ? or BA * or BA + or BA -

BA ? displays all breakpoints, BA * clears all breakpoints, BA + enables all
breakpoints, and BA - disables all breakpoints.
\BB
Syntax: BB ? or * or + or - or <address> <test> <byte> [...]

This command is used to set a breakpoint when a byte of memory meets a test.
Up to eight breakpoints may be set at one time. If a segment is not specified
in the address, the current data segment is used. If any of the tests pass, a
breakpoint is taken. To trace execution with this breakpoint enabled, the GT
command must be used. This breakpoint stops execution of a program on the
instruction following the instruction that changed the specified byte of
memory. Multiple breakpoints may be set on a single input line. The
breakpoint clear, display, enable, and disable functions may also be present
on the line.
\BC
Syntax: BC ? or * or + or - or <address> [...]

This command is used to set a breakpoint when an instruction is executed. It
performs the same function as addresses entered after the Go command, except
that these breakpoints are remembered or sticky. If a segment is not
specified in the address, CS is presumed. The G or GT command may be used to
enable code breakpoints. This breakpoint stops execution of a program before
the instruction at the specified address is executed. Multiple breakpoints
may be set on a single input line. The breakpoint clear, display, enable, and
disable functions may also be present on the line. See the Go command for
more information.
\BI
Syntax: BI ? or * or + or -

This command is used to set a breakpoint when a software interrupt is
performed. This capability is used to watch the software interrupts performed
by a program. After setting the Interrupt breakpoint, use GT to execute to
the next interrupt.
\BL
Syntax: BL ? or * or + or -

This command is used to set a breakpoint when a source code line is executed.
This breakpoint is used to get to the next instruction that corresponds to a
source line of a high-level language program. If your program is executing
and you press the break-out switch, chances are very good that the program
will be stopped in DOS, BIOS, or in a library routine. This breakpoint is a
convenient method of getting back to the source program. It requires source
line numbers to be in the symbol table -- symbols added with the ES command
will not suffice. After setting the line breakpoint, use GT to execute to the
next source line.
\BM
Syntax: BM ? or * or + or - or <address> <address> C and/or R and/or W [...]

This command is used to set a breakpoint when a range of memory will be
executed, read and/or written. The two addresses may have different segments,
but the second address must not be lower in memory than the first address. If
a segment is not specified in the address, the current data segment is used.
Up to eight breakpoints may be set at one time. The C breakpoint will occur
only if CS:IP is in the specified range. The read or write breakpoints will
occur only if read or write starts in the specified range. If any of the
tests pass, a breakpoint is taken. To trace execution with this breakpoint
enabled, the GT command must be used. This breakpoint stops execution of a
program on the instruction that will execute, read or write the specified
range of memory. Multiple breakpoints may be set on a single input line. The
breakpoint clear, display, enable, and disable functions may also be present
on the line.
\BP
Syntax: BP ? or * or + or - or <port> <port> I and/or O [...]

This command is used to set a breakpoint when a range of I/O ports will be
read and/or written as the result of an instruction. The second port must be
greater than or equal to the first port. Up to eight breakpoints may be set
at one time. A breakpoint will occur only if an IN or an OUT occurs to a port
in the specified range. If any of the tests pass, a breakpoint is taken. To
trace execution with this breakpoint enabled, the GT command must be used.
This breakpoint stops execution of a program on the instruction that will read
or write the specified range of ports. Multiple breakpoints may be set on a
single input line. The breakpoint clear, display, enable, and disable
functions may also be present on the line.
\BR
Syntax: BR ? or * or + or - or <register> <test> <number> [...]

This command is used to set a breakpoint when a register meets a test. Up to
one test per register may be set at one time. If any of the tests pass, a
breakpoint is taken. To trace execution with this breakpoint enabled, the GT
command must be used. This breakpoint stops execution of a program on the
instruction following the instruction that changed the specified register.
Multiple breakpoints may be set on a single input line. Any of the 16-bit or
8-bit registers may be used. The breakpoint clear, display, enable, and
disable functions may also be present on the line.
\BU
Syntax: BU ? or * or + or - or <number> [...]

This command is used to enable a user-written breakpoint. The user
breakpoints provide a user exit for breakpoint tests not provided by
Periscope. The number may vary from 1 to 8, indicating one of eight possible
user breakpoints. To use this breakpoint, a program similar to USEREXIT.ASM
as described in Chapter VIII must be installed before PS.COM is run. Also,
the /I installation option must be used when PS.COM is run. On return from
the user routine, register AL is set to 1 if a breakpoint is to be taken. Any
other value causes no breakpoint to be taken.
\BW
Syntax: BW ? or * or + or - or <address> <test> <number> [...]

This command is used to set a breakpoint when a word of memory meets a test.
Up to eight breakpoints may be set at one time. If a segment is not specified
in the address, the current data segment is used. If any of the tests pass, a
breakpoint is taken. To trace execution with this breakpoint enabled, the GT
command must be used. This breakpoint stops execution of a program on the
instruction following the instruction that changed the specified word of
memory. Multiple breakpoints may be set on a single input line. The
breakpoint clear, display, enable, and disable functions may also be present
on the line.
\C
Syntax: C <range> <address>

This command is used to compare two blocks of memory a byte at a time. If any
differences are found, the address and value of the first byte and the value
and address of the second byte are displayed. Nothing is displayed for bytes
that match. Since this command accepts two addresses as input, the two blocks
of memory may be in different segments. If no segment is input, the current
data segment is used. The length parameter indicates how much memory is to be
compared.
\D
Syntax: D [<range>]

This command is used to display a block of memory in the current display
format. When Periscope is first started, this display defaults to a byte
format. Subsequent Display commands use the most recent explicit format. See
the help for the various display formats as well as information applicable to
all display formats below.

The syntax for all of the Display commands except DE and DR is very flexible.
If you enter Dx, where x is the sub-function, memory is displayed starting
where the last D command left off. If you enter Dx <number>, the number is
presumed to be an offset, the segment is presumed to be DS, and the length is
presumed to be 80H. If you enter Dx <number> <length> the number is presumed
to be an offset, and the segment is presumed to be DS.
\DA
Syntax: DA [<range>]

This command is used to display a block of memory in ASCII. Each line of the
display shows the starting segment and offset and up to 64 bytes of ASCII
characters. All characters are displayed as is, except for the control
characters NUL, backspace, carriage return, and line feed. Nuls are converted
to spaces and the other three control characters are converted to a period. A
new line is started when a CR/LF is found. If TAB characters are found, the
output position is moved to the next tab stop.
\DB
Syntax: DB [<range>]

This command is used to display a block of memory in hex and ASCII. Each line
of the display shows the starting segment and offset, up to 16 bytes, and
their ASCII representation. A dash is displayed between the eighth and ninth
bytes for readability. If a display is not started on a paragraph boundary
(i.e. the memory address is not evenly divisible by 16), a short line is
displayed for the first line.

For the ASCII display, the high-order bit is ignored, i.e. a byte whose value
is greater than 80H has 80H (128) subtracted from it before being displayed.
Also, any bytes from zero to 1FH are displayed as a period.
\DD
Syntax: DD [<range>]

This command is used to display a block of memory in double word format. This
format is useful for examining data that is stored as a word offset followed
by a word segment. Each line of the display shows the starting segment and
offset and up to four pairs of segments and offsets.
\DE
Syntax: DE

This command is used to display the effective address of any reads or writes
performed by the current instruction (CS:IP). The display is always in byte
format. This command has no arguments. If the current instruction reads
memory, the effective address of the read is shown. If the instruction writes
memory, the effective address of the write is shown. If the instruction reads
and writes memory, only the read address is shown.
\DI
Syntax: DI [<range>]

This command is used to display a block of memory in unsigned integer (word)
format. Each line of the display shows the starting segment and offset and up
to 8 decimal numbers. The number displayed may be from zero to 65535.
\DN
Syntax: DN [<range>]

This command is used to display a block of memory in signed integer (word)
format. Each line of the display shows the starting segment and offset and up
to 8 decimal numbers. The decimal numbers shown may vary from zero to 32767
(0H to 7FFFH) and from -32768 to -1 (8000H to FFFFH).
\DR
Syntax: DR <address> <symbol>

This command is used to display a block of memory by fields as defined by a
record definition. This format is useful for examining data that is part of a
record, such as the PSP or a FCB. Each line of the display shows a field name
and the data for the field in any format supported by Periscope. Any area of
memory can be displayed using any record definition.

To define a record format, a record definition file must exist. The program
loader, RUN.COM, reads this DEF file when loading the program and loads the
record definitions into the record table. See the sample file PS.DEF and the
description of RS.COM in Chapter VIII.

The syntax for this command is less flexible than the other display commands.
You must enter an address and a record name. The address must have an offset
and must not include a length.
\DW
Syntax: DW [<range>]

This command is used to display a block of memory in word format. This format
is useful for examining data that is stored as words rather than bytes. It
reverses out the back-words style of storage used by the 8086 family. Each
line of the display shows the starting segment and offset and up to 8 words.
\E
Syntax: E <address> [<list>]

This command is used to modify memory. The segment and offset must be
specified for the address, since this command modifies memory. If the
optional list is present, the specified memory is modified and the command
terminates. If the list is not present, an interactive mode is started. This
mode allows you to examine and optionally modify individual bytes starting at
the specified address.
\ES
Syntax: ES <address> <symbol>

This command is used to define or redefine symbol table entries. A segment
and offset must be specified for the address. The symbol name must 16
characters or less and must be preceded by @ or a period. The symbol table is
searched for a symbol of the same name. If an existing symbol is found, the
segment and offset associated with it are updated. If no match is found, a
new symbol is added at the end of the symbol table.
\F
Syntax: F <range> <list>

This command is used to fill a block of memory with a byte/string pattern. A
segment and offset must be specified for the address, since this command
modifies memory. The length specifies the number of bytes to be affected.
The list is the pattern that is copied into the specified range of memory. If
the length of the list is less than the length of the range specified, the
list is copied as many times as needed to fill the range. Conversely, if the
length of the list is greater than the length of the range, the extra bytes
are not copied.
\G
Syntax: G [<address>] [...]

The Go command is used to set sticky and temporary code breakpoints and
execute the program being debugged. If any addresses are specified on the
command line, the byte at each of the addresses is replaced with a CCH, the
single-byte breakpoint. When control is returned to Periscope via any method,
the original byte is restored. The addresses entered on the command line are
referred to as temporary code breakpoints. Up to four of these breakpoints
may be used. If the address does not contain a segment, the current code
segment is used.

To set sticky code breakpoints, use the BC command. This method allows you to
set up to 16 sticky code breakpoints. If G with no addresses is entered, the
sticky breakpoints, if any, are used. If there are no sticky breakpoints,
program execution continues until the break-out switch is pressed. The sticky
breakpoints are remembered until cleared or PS.COM is rerun. If you have code
and/or monitor breakpoints set and want to continue program execution without
using any of the breakpoints, you can disable all breakpoints or use the QC
command to exit Periscope.
\GT
Syntax: GT [<address>] [...]

The Go using Trace command is the same as the normal Go command, except that
it also invokes the non-code or monitor breakpoints. These breakpoints are
byte (BB), interrupt (BI), line (BL), memory (BM), port (BP), register (BR),
user (BU), and word (BW). Using these breakpoints puts the system into a mode
where every instruction executed by your program is analyzed to see if a
breakpoint has been reached. This analysis can slow down the execution by a
factor of 100 or more, but in many cases is the only way to find an elusive
bug.

The monitor breakpoints are remembered until cleared or PS.COM is rerun. If
you have code and/or monitor breakpoints set and want to continue program
execution without using any of the breakpoints, you can disable all
breakpoints or use the QC command to exit Periscope.
\H
Syntax: H <number> <arithmetic operator> <number>

This command is used to perform hexadecimal arithmetic. Addition,
subtraction, multiplication, and division are available. The standard symbols
are used for each function. The numbers must be in hex and may be from one to
four bytes. If a register name is entered in place of one of the numbers, its
current value is used for the number.

Multiplication returns two words separated by spaces. The first word is the
high-order part. Division returns two words separated by the letter R. The
first word is the quotient and the second is the remainder.
\I
Syntax: I <port>

This command is used to read an I/O port. The port number may be from zero to
FFFFH, although the IBM PC only supports ports from zero to 3FFH -- any larger
number is effectively ANDed with 3FFH. The byte value retrieved by reading the
port is displayed on the line following the command.
\J
Syntax: J

This command is used as a shorthand form of Go -- to jump to the next
instruction. It enables you to skip over the current instruction and go to
the next instruction. It is used to skip over instructions that will return
to the next instruction, such as CALL and INT. It is also useful for quickly
moving through REP prefixes and LOOPs.

This command performs the same function as a temporary code breakpoint set on
the next instruction -- the difference is that you don't have to stop and
compute the address and then enter a Go command -- Jump does it for you. If
the current instruction is any form of a RET, IRET, or JMP (including
conditional jumps) Periscope traces one instruction instead of using a
temporary code breakpoint.
\JL
Syntax: JL

This command is used to jump from one source code line to the next source code
line. It is usable only when the current instruction corresponds to a
high-level language source code line. The JL command sets a temporary code
breakpoint on the next source code line in the same module. This is a quick
method of moving through a high-level language program, keeping to the source
code lines.
\JN
Syntax: JN

This command is used to jump to the next instruction without swapping screen
displays. It is the same as the Jump command, except that it does not save
and restore the screen display. On a single-monitor system, Periscope
normally saves and restores the program's screen during each Jump command.
This variant of the Jump command is provided so users of single-monitor
systems can elect not to save the screen for instructions that do not change
the program's screen. If this command is used for an instruction that
modifies the screen, the screen output will be directed to Periscope's screen,
possibly garbling it. If this occurs, use the K command to clear the screen
or F10 to swap to the program's screen and back.
\K
Syntax: K

This command clears the debugger screen. It has no arguments.
\LA
Syntax: LA <address> <drive> <sectors>

This command is used to load absolute disk sectors into memory. The segment
defaults to CS if no segment is specified in the address. The drive is a
single-digit number indicating the disk drive (0=A, 1=B, etc.). The sectors
parameter is the starting sector number and the number of sectors to be read.
The maximum number of sectors that can be read in one operation is 80H or 64K
bytes.

To use this command, DOS must be available. See the description of the Name
command for more information. This command uses DOS interrupt 25H. See the
DOS manual for information on the numbering of the absolute disk sectors.
\LF
Syntax: LF [<address>]

This command is used to load a file from disk into memory. The optional
address specifies where the file is to be loaded. If the address is not
specified, CS:100 is used. To use this command, DOS must be available. See
the description of the Name command for more information. Before this command
can be used the Name command must be used to specify a file name.

This command can be used to load any type of file into memory. After the file
has been loaded, BX and CX indicate the size of the file in bytes. After the
file is loaded into memory no other processing occurs -- EXE files are not
relocated or stripped of their headers. RUN.COM should generally be used to
load and execute a program, since it loads the symbol table and performs
relocation for EXE files. This command is useful for loading a file into
memory for examination or modification.
\M
Syntax: M <range> <address>

This command is used to copy a block of memory to another location in memory.
The segment and offset must be specified for both addresses, since this
command modifies memory. If the source block and target block overlap, the
move into the target block is performed without loss of data. The source
segment and target segment may be different.
\N
Syntax: N <name>

This command is used to enter data into the PSP for disk I/O and for use by
Periscope in loading and writing files. The name parameter is copied to a
Periscope buffer for use with the Load and Write commands. It is then copied
to the unformatted parameter area in the Program Segment Prefix (PSP),
starting at 80H. Next, the DOS parsing function is used to parse the first
two file names in the command line into the File Control Blocks (FCBs) at 5CH
and 6CH. If an invalid drive id is found on a file, a message is generated
and register AL or AH is set to FF, indicating the first or second file,
respectively.

Since the Name, Load, View, Unassemble Source, and Write commands use DOS
calls, a check is performed to be sure that DOS is available. DOS sets a
special flag to zero when DOS is available. Also hardware interrupts must be
enabled and the vector for interrupt 21H must equal a value saved by PS.COM
and RUN.COM. The Name command also requires that the PSP's address has been
set by RUN.COM and that the first four bytes of the PSP contain the bytes CD
20 followed by the top of memory size in paragraphs.
\O
Syntax: O <port> <byte>

This command is used to output a byte to an I/O port. The port number may be
from zero to FFFFH, although the IBM PC only supports ports from zero to 3FFH
-- any larger number is effectively ANDed with 3FFH. The byte value output to
the port may be from zero to FFH.
\Q
Syntax: Q [<sub-function>]

This command is used to exit the debugger and display Periscope's quit
options. The optional sub-function is used to pre-answer the quit option
prompt. The possible combinations are QB, QC, QD, QR, and QS to quit and
Boot, Continue, Debug, Return to DOS, or perform a Short boot, respectively.
\R
Syntax: R [<register>] or [F]

This command is used to display and modify the current values of the registers
and flags. If you enter 'R' and press return, the current values of the
registers and flags are displayed. If the current instruction performs a
memory read and/or write, the effective address of the read/write is
displayed, along with the current value of memory at the effective
address(es). Finally, the current instruction is disassembled. The effective
address and current instruction are shown in the U window if one is used.

To modify a register, enter 'R <register>'. Periscope displays the current
value of the register, followed by a colon. If you enter a one- to four-digit
hex number or another register name and press return, the register is changed.
If you press return without entering a number, the register is not changed.
Any 8- or 16-bit registers may be used.

To modify a flag, enter 'R F'. Periscope displays the current values of the
flags followed by a hyphen. To change the flags, enter the desired mnemonics
and press return. If you press return without entering any flag mnemonics, no
flags are changed. The flags may be entered in any order, in upper or lower
case, and with or without spaces between the entries.
\RR
Syntax: RR

This command is used to restore the registers to a previously saved state.
This command is usable only after a RS command has been used to save the
registers. After a restore has been performed, restore is disabled until
another save has been performed. See the RS command for more information.
\RS
Syntax: RS

This command is used to save the registers for later restoration. The
Register Save command saves the current state of the machine's registers and
flags in case you need to restore the registers to that state at some later
point. To use this command, enter RS when the Periscope prompt is displayed.
Later, you can restore the registers to their saved state by using the RR
command. This command does not restore any data areas modified by your
program.
\S
Syntax: S <range> <list>

This command is used to search memory for a byte/string pattern. The block of
memory specified by the range is searched for the pattern specified by the
list. If a match is found, the starting address of the match is displayed and
the search for matches continues at the next byte. If no matches are found,
nothing is displayed. If no segment is specified in the address, the current
data segment is used.
\SA
Syntax: SA <range> <address>

This command is used to search memory for references to a specified address.
It can be thought of as a disassembly that only shows instructions that
reference an address of interest. To use it, specify an address range that is
to be searched and the address reference that is to be searched for. If
you're not using a symbol name for the address reference, be sure to specify
the segment register that is to be used. For example, if you're searching for
a procedure reference, specify CS.

You can use this command to find JMPs and CALLs to a procedure or to find
locations in your program where a data variable is accessed. Any instruction
that references the specified address is displayed.
\SU
Syntax: SU <range> <list>

This command is used to search memory for instructions that match a pattern.
This command can be thought of as a disassembly that only shows instructions
that match a specified pattern. To use it, specify an address range that is
to be searched and the pattern that is to be searched for. For example, to
find all MOVSB instructions, enter MOVSB in quotes as the list argument.

Be sure to enter the search list as a quoted string in upper case letters.
Note that there are eight spaces from the start of the mnemonic field to the
start of the operand field -- to find all occurrences of MOV SP, you'd enter
five spaces after the MOV and before the SP.
\T
Syntax: T [<number>]

This command is used to execute the current program one instruction at a time.
If the optional number is not entered, one instruction is executed and control
is returned to Periscope. If the number is entered, that number of
instructions is executed. Unlike the Go command, the Trace command can be
used to trace through ROM, since it works by changing the trap flag and not by
modifying the code to be traced.
\TB
Syntax: TB * or F or L and [< +/- number>]

This command is used to display previously-executed instructions. The
traceback buffer is used to save the state of the machine each time Periscope
is exited. This circular buffer can contain zero to 512 entries, depending on
the PS.COM option /B:nn (32 entries per KB). Each entry contains the machine
registers and an ascending sequence number. When displayed, the buffer shows
the registers, sequence number, and a symbolic disassembly of the instruction.

To position in the buffer, use TB L to display the last entry or TB F to
display the first entry. The L or F may be followed by a number to display
multiple entries. The buffer and sequence number may be cleared by using TB
*. Since Periscope adds to the buffer each time it is exited, watch out for
possible discontinuities in the traceback buffer. If you're using the T or GT
commands, there's no problem. If you're using the G or J commands, not all
instructions will be seen by Periscope -- they'll leave gaps in the traceback
buffer. The disassembly uses the current contents of memory at the saved
CS:IP so it may be incorrect.
\TN
Syntax: TN [<number>]

This command is used to execute the current program one instruction at a time
without swapping screen displays. It is the same as the Trace command, except
that it does not save and restore the screen display. On a single-monitor
system, Periscope normally saves and restores the program's screen during each
Trace command. This variant of the Trace command is provided so users of
single-monitor systems can elect not to save the screen for instructions that
do not change the program's screen. If this command is used for an
instruction that modifies the screen, the screen output will be directed to
Periscope's screen, possibly garbling it. If this occurs, use the K command
to clear the screen or F10 to swap to the program's screen and back.
\U
Syntax: U [<range>]

This command is used to disassemble memory into the 8088, 8086, 80186, and
80286 real-mode instructions. Memory is disassembled in either the ASM or
Source/ASM mode as set by the UA and US commands respectively. The default
mode is the ASM mode.

The syntax for this command is very flexible. If you enter U, the disassembly
starts where the last U command left off. The commands G, J, R, and T reset
the starting point to CS:IP. If you enter U <number>, the number is presumed
to be an offset, the segment is presumed to be CS, and the length is presumed
to be 20H. If you enter U <number> <length>, the number is presumed to be an
offset, and the segment is presumed to be CS.
\UA
Syntax: UA [<range>]

This command is used to disable source disassembly and to disassemble memory
into the 8088, 8086, 80186, and 80286 real-mode instructions. Use this
command to turn off source-level debugging of a high-level language.
\US
Syntax: US [<range>]

This command is used to enable source disassembly and to disassemble memory
into the 8088, 8086, 80186, and 80286 real-mode instructions. Use this
command to turn on source-level debugging of a high-level language.

When needed, Periscope prompts for the file name corresponding to the module
being disassembled. Enter the file name and press return to display the
high-level language source code along with the disassembled instructions. If
the file is not found, the prompt is displayed again. If you press return
without entering a file name, source disassembly is disabled.

To use this command, the following conditions must be met: DOS must be
available (see the description of the Name command for more information); a
file buffer must be available -- if PS.COM was started with either /E:0 or /Z,
this command is not available; line symbols must be found for Periscope to be
able to associate an instruction with a source code line. Any disk I/O errors
will cause an incomplete source display or none at all.
\V
Syntax: V <name>

This command is used to view a source file from within Periscope. The name is
any legal file name, including drive, path, file, and extension. To use this
command, DOS must be available. See the description of the Name command for
more information. A file buffer must be available -- if PS.COM was started
with either /E:0 or /Z, this command is not available.

The file is displayed in the un-windowed area of the screen. Use the PgUp and
PgDn keys to page up and down through the file. Use the up and down arrow
keys to move up or down one line at a time. Use the Home and End keys to move
to the start and end of the file. When you're finished viewing the file,
press the Esc key to return to the debugger prompt.
\WA
Syntax: WA <address> <drive> <sectors>

This command is used to write memory to absolute disk sectors. The segment
defaults to CS if no segment is specified in the address. The drive is a
single-digit number indicating the disk drive (0=A, 1=B, etc.). The sectors
parameter is the starting sector number and the number of sectors to be
written. The maximum number of sectors that can be written in one operation
is 80H. To use this command, DOS must be available. See the description of
the Name command for more information. This command uses DOS interrupt 26H.
See the DOS manual for information on the numbering of the absolute disk
sectors.

When using this command, be very careful! An absolute disk write can very
easily destroy a file allocation table or a disk directory! Usually, you will
want to perform a Load Absolute, change a few bytes of memory, and then
perform a Write Absolute of the data back to disk. If this is the case, be
sure that the parameters used with the Load and Write commands are the same.
\WF
Syntax: WF [<address>]

This command is used to write a file from memory to disk. The optional
address specifies where the memory image of the file begins. If the address
is not specified, CS:100 is used. To use this command, DOS must be available.
See the description of the Name command for more information. Before this
command can be used the Name command must be used to specify a file name.

This command can be used to write any type of file to disk. Before the file
is written, be sure that BX and CX indicate the size of the file in bytes. Do
not attempt to write an EXE file that was not loaded with the LF command -- an
EXE file loaded by RUN.COM is missing its header and cannot be written to
disk.
\X\XH
Syntax: X <number> or XH <number>

This command is used to translate a one- to four-digit hexadecimal number or a
register to its decimal, binary, and ASCII equivalents.
\XA
Syntax: XA <address>

This command is used to translate an address (segment and offset) into its
equivalent five-byte absolute address. The absolute address is calculated by
multiplying the segment by 10H and adding the offset to the result.
\XD
Syntax: XD <decimal number>

This command is used to translate a one- to five-digit decimal number to its
hexadecimal, binary, and ASCII equivalents. The number must be from zero to
65535. The number may not have any punctuation, such as commas or periods.
Numbers larger than 65535 can be translated, but the high order part is lost.
\/S
Syntax: /S <segment> <segment>

This command is used to make global changes to the values of segments in the
symbol table. The entire symbol table is searched for symbols having a
segment that matches the first segment entered. If a match is found, the
symbol's segment is changed to the second segment entered and the symbol name
is displayed. This command is used to adjust the segments of symbols when a
program relocates its data areas, such as in Microsoft BASIC, FORTRAN, and
Pascal.
\/U
Syntax: /U <byte> [<address>]

This command is used to perform user-written code from Periscope. To use this
exit, a program similar to USEREXIT.ASM as described in Chapter VIII must be
installed with the /I option before PS.COM is run. The byte parameter must be
from nine to FFH. It is passed to the user-written program in register AH.
See Chapter VIII for more information.
\/W
Syntax: /W D[<:nn> R S[<:nn>] U[<:nn>]

This command is used to change Periscope's windows from within Periscope.
Periscope can window data, stack, register, and/or disassembly information.
Once windows are established, the windowed data is displayed at a constant
location on the screen and is updated after each command. The tokens D, R, S,
and U indicate the type of data to be windowed. The tokens are optional and
may be in any order. If a token is omitted, the corresponding type of
information will not be windowed. The windows are displayed in the same order
as the tokens are encountered in the input line.

The :nn parameter defines the length of the window, where nn is the number in
hex. If no length is specified, a default will be used. The maximum length
for any one window is 10H (16) lines and the total area that can be windowed
is 21 lines, including a separator line following each window. When a length
specification is used, at least one space must follow the number.
\
