<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 3//EN">
<HTML><HEAD>
<TITLE>ICAT Debugger - Java OS/2</TITLE>
<!-- Begin Header Records  ========================================== -->
<!-- ICATJVO SCRIPT A converted by B2H R3.1 (311) (CMS-OS2) by        -->
<!-- ROSELIP at LEXVM2 on 13 Jul 1999 at 14:36:06                     -->
<META HTTP-EQUIV="updated"  CONTENT="Tue, 13 Jul 1999 ">
<META HTTP-EQUIV="review"  CONTENT="Thu, 13 Jul 2000 ">
<META HTTP-EQUIV="expires"  CONTENT="Fri, 13 Jul 2001 ">
</HEAD><BODY TEXT="#000000" BGCOLOR="FFFFFF" LINK="#13519B" VLINK="800000" ALINK="#FF0000">
<!-- End Header Records  ============================================ -->
<A NAME=Top_Of_Page></A>
<H1>ICAT Debugger - Java OS/2</H1>
<HR><H2><A NAME=ToC>Table of Contents</A></H2>
<P><B><A NAME=ToC_1 HREF="#Header_1" >About This Book</A></B><BR>
<P><B><A NAME=ToC_2 HREF="#Header_2" >Introducing the ICAT Debugger</A></B><BR>
<MENU>
<LI><A NAME=ToC_3 HREF="#Header_3" >Before You Begin</A>
<MENU>
<LI><A NAME=ToC_4 HREF="#Header_4" >Minimum Hardware Requirements</A>
<LI><A NAME=ToC_5 HREF="#Header_5" >Minimum Software Requirements</A>
<LI><A NAME=ToC_6 HREF="#HDRENVIRO" >Environment Variables</A>
<LI><A NAME=ToC_7 HREF="#HDRFNDSRC" >Finding Source Files</A>
<LI><A NAME=ToC_8 HREF="#Header_8" >Limitations</A>
</MENU>
<LI><A NAME=ToC_9 HREF="#HDRGETS" >Getting Started</A>
<MENU>
<LI><A NAME=ToC_10 HREF="#Header_10" >Setting up the Target Network Computer</A>
<LI><A NAME=ToC_11 HREF="#Header_11" >Setting up the Host OS/2 Computer</A>
<LI><A NAME=ToC_12 HREF="#HDRDEMO" >Demonstration Session</A>
<LI><A NAME=ToC_13 HREF="#HDRSTRTD" >Starting a Debug Session</A>
<LI><A NAME=ToC_14 HREF="#HDRTOOL" >Using the Tool Buttons</A>
<LI><A NAME=ToC_15 HREF="#Header_15" >Helpful Tips and Hints</A>
<LI><A NAME=ToC_16 HREF="#Header_16" >Troubleshooting</A>
<LI><A NAME=ToC_17 HREF="#HDRUSEDAD" >Using the Drag-and-Drop Function</A>
<LI><A NAME=ToC_18 HREF="#Header_18" >Ending the Debugging Session</A>
</MENU></MENU>
<P><B><A NAME=ToC_19 HREF="#Header_19" >Main Debugging Windows</A></B><BR>
<MENU>
<LI><A NAME=ToC_20 HREF="#Header_20" >Debug Session Control Window</A>
<MENU>
<LI><A NAME=ToC_21 HREF="#Header_21" >Opening a New Source File</A>
<LI><A NAME=ToC_22 HREF="#Header_22" >Loading a Class</A>
<LI><A NAME=ToC_23 HREF="#Header_23" >Opening a Source File to a Function</A>
<LI><A NAME=ToC_24 HREF="#Header_24" >Locating the Execution Point</A>
<LI><A NAME=ToC_25 HREF="#Header_25" >Saving the Contents of the Threads Pane View</A>
<LI><A NAME=ToC_26 HREF="#Header_26" >Saving the Contents of the Components Pane View</A>
<LI><A NAME=ToC_27 HREF="#Header_27" >Opening the Launch or attach Window</A>
<LI><A NAME=ToC_28 HREF="#Header_28" >Setting Breakpoints</A>
<MENU>
<LI><A NAME=ToC_29 HREF="#Header_29" >Setting a Line Breakpoint</A>
<LI><A NAME=ToC_30 HREF="#Header_30" >Setting a Function Breakpoint</A>
<LI><A NAME=ToC_31 HREF="#Header_31" >Setting an Address Breakpoint</A>
<LI><A NAME=ToC_32 HREF="#Header_32" >Setting a Watchpoint</A>
<LI><A NAME=ToC_33 HREF="#Header_33" >Setting a Load Occurrence Breakpoint</A>
</MENU>
<LI><A NAME=ToC_34 HREF="#Header_34" >Viewing a List of Breakpoints</A>
<LI><A NAME=ToC_35 HREF="#HDRSETPROP" >Setting Debugger Properties</A>
<MENU>
<LI><A NAME=ToC_36 HREF="#Header_36" >Remote Page</A>
<LI><A NAME=ToC_37 HREF="#Header_37" >Source Page</A>
<LI><A NAME=ToC_38 HREF="#Header_38" >Modules Page</A>
</MENU>
<LI><A NAME=ToC_39 HREF="#Header_39" >Setting Monitor Properties</A>
<LI><A NAME=ToC_40 HREF="#Header_40" >Setting Exception Filters</A>
<LI><A NAME=ToC_41 HREF="#Header_41" >Viewing Your Source</A>
<MENU>
<LI><A NAME=ToC_42 HREF="#Header_42" >Source Window</A>
<LI><A NAME=ToC_43 HREF="#Header_43" >Disassembly Window</A>
<LI><A NAME=ToC_44 HREF="#Header_44" >Mixed Window</A>
</MENU></MENU>
<LI><A NAME=ToC_45 HREF="#Header_45" >Executing a Program</A>
</MENU>
<P><B><A NAME=ToC_46 HREF="#Header_46" >Monitors Windows</A></B><BR>
<MENU>
<LI><A NAME=ToC_47 HREF="#Header_47" >Viewing Active Functions for a Particular Thread</A>
<MENU><MENU>
<LI><A NAME=ToC_48 HREF="#Header_48" >Menus</A>
</MENU></MENU>
<LI><A NAME=ToC_49 HREF="#Header_49" >Viewing Registers for a Particular Native Thread</A>
<MENU><MENU>
<LI><A NAME=ToC_50 HREF="#Header_50" >Menus</A>
<LI><A NAME=ToC_51 HREF="#Header_51" >Drag-and-Drop Function</A>
</MENU></MENU>
<LI><A NAME=ToC_52 HREF="#Header_52" >Viewing Storage Contents and Addresses</A>
<MENU><MENU>
<LI><A NAME=ToC_53 HREF="#Header_53" >Menus</A>
<LI><A NAME=ToC_54 HREF="#Header_54" >Drag-and-Drop Function</A>
</MENU></MENU>
<LI><A NAME=ToC_55 HREF="#Header_55" >Monitoring Local Variables</A>
<MENU><MENU>
<LI><A NAME=ToC_56 HREF="#Header_56" >Menus</A>
</MENU></MENU>
<LI><A NAME=ToC_57 HREF="#Header_57" >Viewing Memory Usage</A>
<MENU><MENU>
<LI><A NAME=ToC_58 HREF="#Header_58" >Menus</A>
</MENU></MENU>
<LI><A NAME=ToC_59 HREF="#Header_59" >Monitoring Other Variables and Expressions</A>
<MENU><MENU>
<LI><A NAME=ToC_60 HREF="#Header_60" >Drag-and-Drop Function</A>
</MENU></MENU></MENU>
<P><B><A NAME=ToC_61 HREF="#Header_61" >Expressions Supported</A></B><BR>
<MENU>
<LI><A NAME=ToC_62 HREF="#Header_62" >Supported Expression Operands</A>
<LI><A NAME=ToC_63 HREF="#Header_63" >Supported Expression Operators</A>
<LI><A NAME=ToC_64 HREF="#Header_64" >Supported Data Types</A>
<MENU>
<LI><A NAME=ToC_65 HREF="#Header_65" >C/C++</A>
<LI><A NAME=ToC_66 HREF="#Header_66" >Java</A>
</MENU></MENU>
<P><B><A NAME=ToC_67 HREF="#Header_67" >Notices</A></B><BR>
<MENU>
<LI><A NAME=ToC_68 HREF="#Header_68" >Copyright Notices</A>
<LI><A NAME=ToC_69 HREF="#Header_69" >Disclaimers</A>
<LI><A NAME=ToC_70 HREF="#Header_70" >Trademarks</A>
</MENU><HR><P>
<P>
<H1><A NAME="Header_1" HREF="#ToC_1">About This Book</A></H1>
<P>
This document contains information to help you install, get started,
and perform tasks with the Interactive
Code Analysis Tool (ICAT) debugger.
<P>
If you need assistance from any window while using the debugger,
press F1 from any window or choose the Help menu.
<HR>
<H1><A NAME="Header_2" HREF="#ToC_2">Introducing the ICAT Debugger</A></H1>
<P>
The IBM Interactive Code Analysis Tool (ICAT) for OS/2 Warp Java
provides debugging of OS/2 Warp
Java applications and their (potential) native-method calls
(C or C++ code collected in an OS/2 Warp
dynamic load library (DLL) file).
It is designed to work with the IBM Hursley Java Virtual Machine
(JVM) 1.1 port for OS/2 Warp, but currently, no specific JVM support
is expected beyond a pure
implementation of the sun.tools.debug API.
This allows ICAT to be modified quickly to support other
JVMs that run on OS/2 Warp.
<P><B>Note: </B>There are some restrictions on the versions of Warp that the
JVM supports.  ICAT runs on all
OS/2 Warp systems that the JVM supports.
<P>
The ICAT Debugger (hereafter referred to in this document as the
debugger) is a source-level debugger that
runs on an OS/2 Warp system.  It is an OS/2 Warp application; that is,
it uses Presentation Manager (PM)
for its presentation space, and its debug engine runs outside of a JVM.
<P>
The debugger uses a Java debug probe to manipulate the Java application,
and uses TCP/IP to communicate
with the Java debug probe that runs under a JVM.  Note
that this design allows for remote debugging; that
is, the target application and Java debug probe can run on a separate
OS/2 Warp computer from the host
computer of the debugger itself.
<P>
The result is that a user can launch a Java application with the
debugger.
The debugger presents various
windows (Source, Storage, Call Stack, Variable Monitors, and so on)
with PM to reflect the current state of
the debuggee.  The debugger enables you to step, run, catch breakpoints,
and so on.
<P>
The supported debug file formats for the native-method DLLs
(that you may choose to debug) include HLL
(IBM VisualAge) and CodeView.
<HR>
<H2><A NAME="Header_3" HREF="#ToC_3">Before You Begin</A></H2>
<P>
This section lists the hardware and software requirements, options
that can be used when compiling and
linking your program, environment variables, and the search order of
source files and modules.
<P>
<H3><A NAME="Header_4" HREF="#ToC_4">Minimum Hardware Requirements</A></H3>
<UL COMPACT>
<LI>Intel&reg; Pentium&reg; 90MHz processor
<LI>12 MB hard disk space
</UL>
<P>
<H3><A NAME="Header_5" HREF="#ToC_5">Minimum Software Requirements</A></H3>
<P>
There are software requirements for both the target network computer
where the applications are debugged
and run and the host computer where the debugger runs. Both machines
must have OS/2 Warp installed, and
the target machine must have the OS/2 Java runtime and toolkit installed.
It is possible that the target and
host computers are the same computer.
<P>
You can debug with or without the daemon.
Debug without the daemon if you do not want to engage in
remote debugging.
<P>
If you want to debug without the daemon, you only need to set the
CLASSPATH environment variable.
CLASSPATH should be set to all necessary subdirectories (able to locate
&#46;JAVA and .CLASS files or the root of
the package path and \JAVA11\ICATJAVA\javaprob.zip), and
you&#39;re ready
to debug.  For example, assume that
the debugger is located on F:\JAVA11\ICATJAVA and that your application
(MY_APP.CLASS) and its source
(MY_APP.JAVA) are on F:\MY_STUFF. CLASSPATH would be set as follows:
<PRE>
      SET CLASSPATH=F:\MY_STUFF;F:\JAVA11\ICATJAVA\DAEMON\javaprob.zip;%CLASSPATH%
</PRE>
<P>
Then you would debug your application by emitting:
<PRE>
      icatjvo my_app
</PRE>
<P>
This assumes that your LIBPATH or BEGINLIBPATH points to the
F:\JAVA11\ICATJAVA\DLL and
F:\JAVA11\ICATJAVA\DAEMON subdirectories so the DLLs can run.
If any DLLs are used by your application, set
LIBPATH and BEGINLIBPATH to MY_APP&#39;s DLLs.
Your path must include
F:\JAVA11\ICATJAVA\BIN (to
locate ICATJVO.EXE) while your DPATH and HELP must include
F:\JAVA11\ICATJAVA\HELP.  For example:
<PRE>
      SET PATH=F:\JAVA11\ICATJAVA\BIN;%PATH%
      SET BEGINLIBPATH=F:\JAVA11\ICATJAVA\DLL;F:\JAVA11\ICATJAVA\DAEMON;%BEGINLIBPATH%
      SET DPATH=F:\JAVA11\ICATJAVA\HELP;%DPATH%
      SET HELP=F:\JAVA11\ICATJAVA\HELP;%HELP%
</PRE>
<P><B>Note: </B>If you want to halt your application, or you are stepping
String constructor code, make certain that
the OS/2 JVM&#39;s CLASSES.ZIP is in your CLASSPATH.
<P>
If you want to debug with the daemon, software requirements are more
involved.  See <A HREF="#HDRGETS">"Getting Started"</A>
for instructions on
setup for debugging with the daemon.
<P>
<H3><A NAME="HDRENVIRO" HREF="#ToC_6">Environment Variables</A></H3>
<P>
The debugger uses environment variables to manage debugging sessions and
remote communication.  To set
the environment variables, edit the SETICAT.CMD file.  Set the
environment variables carefully.  If you
don&#39;t,
communication with the Java daemon won&#39;t
work or your Java application won&#39;t be found.
Following
is a list of the variables and a description of each:
<P><B>CAT_JAVA_ONLY</B>
<P>
Tells the daemon that you do not want to debug native-method DLL code.
This allows the daemon to
instantiate the target JVM without using DosDebug and enhances
performance considerably. If you leave
this variable as NULL, you can debug native-method DLL code as shown in
<A HREF="#HDRDEMO">"Demonstration Session"</A>.
<P>For example, type the following at the command prompt:
<PRE>
        SET CAT_JAVA_ONLY=ON
</PRE>
<P><B>CAT_MACHINE</B>
<P>
Sets the IP address of the daemon&#39;s
computer and sets the port number to
communicate with the daemon.
You can select the port number for the daemon (use a number &gt; 1024) when
you start it up.
<P>For example, type the following at the command prompt:
<PRE>
        SET CAT_MACHINE=9.51.135.5:1234
</PRE>
<P><B>CAT_HOST_BIN_PATH</B>
<P>
Tells the debugger where to find your debug binaries (the .DLL and
&#46;class files with debug information) on
your host system. If you want to see local Java variables, you must
compile with the -g flag (for example,
javac -g MY_APP.JAVA).
<P>For example, type the following at the command prompt:
<PRE>
        SET  CAT_HOST_BIN_PATH=I:\JAVATEST
</PRE>
<P><B>CAT_COMMUNICATION_TYPE</B>
<P>
Communicates with the Java daemon.  You can run the daemon on a separate
computer that has an ethernet
or token ring connection to the host computer.  You can also run the
daemon on the same computer as the
host computer.  At any rate, the debugger only accepts the value of
TCP for CAT_COMMUNICATION_TYPE.
<P>For example, type the following at the command prompt:
<PRE>
        SET  CAT_COMMUNICATION_TYPE=TCP
</PRE>
<P><B>CAT_HOST_SOURCE_PATH</B>
<P>
Tells the debugger where to find your source (for example, MAIN.JAVA
and FIND.C in the demo). See <A HREF="#HDRFNDSRC">"Finding Source Files"</A>
for more information.
<P>For example, type the following at the command prompt:
<PRE>
        SET CAT_HOST_SOURCE_PATH=I:\JAVATEST
</PRE>
<P><B>CAT_MODULE_LIST</B>
<P>
Tells the debugger which modules to obtain information about.
By default, the debugger obtains information
about every executable module (class, DLL, and so on) running on the
target computer.  As a result, it can
take several minutes to attach to the target computer. If the
CAT_MODULE_LIST environment variable is
defined, the debugger only obtains information about a module if its
name appears in the environment
variable string. This can dramatically reduce the amount of time it
takes for the debugger to initialize.
<P>
For example, type the following at the command prompt:
<PRE>
        SET CAT_MODULE_LIST=MAIN.CLASS PAL.CLASS EXPRTEXT.CLASS PAL.DLL
</PRE>
<P><B>CAT_PATH_RECURSE</B>
<P>
Causes a recursive search of the subdirectories below the subdirectories
listed in CAT_HOST_BIN_PATH
and CAT_HOST_SOURCE_PATH. For example, with the
CAT_HOST_SOURCE_PATH=I:\JAVATEST
variable, the debugger searches the javatest subdirectory and all
subdirectories below javatest as well as
their subdirectories.  The default is NULL, which means the debugger
will not perform a recursive search.
When the variable is set to any non-null value, the recursive search
is performed.
<P>For example, type the following at the command prompt:
<PRE>
        SET CAT_PATH_RECURSE=ON
</PRE>
<P><B>CAT_PACKAGE_PATH</B>
<P>
Searches for both Java source and Java class files.  The debugger uses
CAT_PACKAGE_PATH the same
way that the JVM uses the CLASSPATH environment variable to find Java
class files.  Both source files
and class files are searched according to the package qualification of
the associated class.  In addition to
containing subdirectories, this environment variable may also include
names of zip files in which to search
for Java class files.
<P>
This environment variable is most useful when you are debugging classes
that are contained within a
package.  If you are using this environment variable to find all of your
Java class and source files, then you
will want to set CAT_HOST_BIN_PATH and CAT_HOST_SOURCE_PATH to find your
native-method
binaries and source, respectively, or you will want to set them to null
when you are debugging Java only.
<P>For example, type the following at the command prompt:
<PRE>
        SET CAT_PACKAGE_PATH=F:\PACKAGE_ROOT
</PRE>
<P><B>CAT_OVERRIDE</B>
<P>
Specifies a path that the debugger searches first to find the source
files that were used to build your debug
binaries.  See
<A HREF="#HDRFNDSRC">"Finding Source Files"</A>
for a complete
description of the process.
<P>For example, type the following at the command prompt:
<PRE>
        SET CAT_OVERRIDE=E:\TEMP\UPDATES
</PRE>
<P><B>CAT_TAB</B>
<P>
Specifies the number of spaces between tab stops when source code
containing tabs is displayed in a
debugger window.
<P>For example, type the following at the command prompt:
<PRE>
        SET CAT_TAB=5
</PRE>
<P>
The debugger converts each tab in the source to 5 spaces when the source
is displayed.
<P><B>CAT_TAB_GRID</B>
<P>
Specifies the column positions for the tab stops when source code
containing tabs is displayed in a debugger
window.
<P>
For example, typing the following command at the command prompt sets
tab stops at the 6th position:
<PRE>
        SET CAT_TAB_GRID=6
</PRE>
<P><B>CAT_DEBUG_NUMBER_OF_ELEMENTS</B>
<P>
Represents the default number of elements displayed for a variable or
structure that has a substantial number
of elements.  The last element displayed for such a structure is labeled
<I>more elements</I>.  Clicking on this
entry displays the next N elements of the variable or structure.
<P><B>Note: </B>CAT_DEBUG_NUMBER_OF_ELEMENTS
is an environment variable that is set
to an integer, N.
<P>For example, type the following at the command prompt:
<PRE>
        SET CAT_DEBUG_NUMBEROFELEMENTS=100
</PRE>
<P>
The next 100 elements are displayed.
<P><B>CAT_JVM_ARGS</B>
<P>
Enables you to pass parameters to the JVM.
<P>For example, you may want to set the max heap size for the
JVM for your application under debug:
<PRE>
        SET CAT_JVM_ARGS= -mx 32m
</PRE>
<P><B>Note: </B>The preceding information is for the debugger environment.
You also need to ensure that the
CLASSPATH includes javaprob.zip and that BEGINLIBPATH is set to the
daemon&#39;s subdirectory on the target computer.
<P><B>CAT_DEBUGGER_NAME</B>
<P>
Specifies a name that displays on the title bar of the Debug Session
Control window to identify the debugger session.
<P>For example, type the following at the command prompt:
<PRE>
        SET CAT_DEBUGGER_NAME=target 1
</PRE>
<P>
This is useful if you want to run multiple copies of the debugger from
a single host computer to debug multiple systems.
<P><B>CAT_CLASS_PRELOAD_LIST</B>
<A NAME="SPTPRELOAD"></A>
<P>
Specifies one or more Java classes to be loaded immediately
as the debugger initializes.
This makes the specified classes available for breakpoint setting
when the debugger is at the beginning of your main() method
so that you don&#39;t have to load them manually or wait to step over
the code that loads them.
<P>Do not include the extension when specifying class names.
If more than one class name is specified, names can be separated by
blanks, commas, or semicolons.
<P>For example, to preload Motorcycle.class, type the following
at the command prompt:
<PRE>
        SET CAT_CLASS_PRELOAD_LIST=Motorcycle
</PRE>
<P>
<H3><A NAME="HDRFNDSRC" HREF="#ToC_7">Finding Source Files</A></H3>
<P>
The debugger searches for source files in the following order:
<OL>
<P><LI>CAT_OVERRIDE environment variable.
<P><LI>CAT_PACKAGE_PATH environment variable using package qualification
(only if the source file has a .JAVA extension).
<P><LI>The subdirectory in which the corresponding class file was found.
<P><LI>CAT_HOST_SOURCE_PATH environment variable, descending subdirectories
if the
CAT_PATH_RECURSE environment variable is set.
<P><LI>The current subdirectory.
<P><LI>The path defined in the INCLUDE environment variable (only if the
source file does not have a .JAVA
extension).
<P><LI>Last specified subdirectory from the
&quot;change source file&quot; function.
</OL>
<P><B>Note: </B>The CAT_PATH_RECURSE environment variable, if specified, causes
the debugger to search
recursively all subdirectories of the CAT_HOST_BIN_PATH and
CAT_HOST_SOURCE_PATH
environment variables.
<P>
The debugger searches for java modules in the following order:
<OL>
<P><LI>CAT_PACKAGE_PATH environment variable using package qualification.
<P><LI>CAT_HOST_BIN_PATH environment variable, descending subdirectories
if the
CAT_PATH_RECURSE environment variable is set. (Note: Directories are
searched with the
unqualified name of the class; zip files are searched with the
package-qualified name of the class).
<P><LI>Current subdirectory for the unqualified name of the class.
</OL>
<P>
The debugger searches for native modules in the following order:
<OL>
<P><LI>CAT_HOST_BIN_PATH environment variable, descending subdirectories
if the
CAT_PATH_RECURSE environment variable is set.
<P><LI>Current subdirectory.
</OL>
<P>
<H3><A NAME="Header_8" HREF="#ToC_8">Limitations</A></H3>
<P>
Refer to the README.TXT provided with the debugger for the current JVM
and debugger restrictions.
<HR>
<H2><A NAME="HDRGETS" HREF="#ToC_9">Getting Started</A></H2>
<P>
This section describes how to set up the target and host computers,
start a debugging session,
and end a debugging session.
<P>
<H3><A NAME="Header_10" HREF="#ToC_10">Setting up the Target Network Computer</A></H3>
<P><B>Note: </B>The target computer can be the same computer as the host.
The OS/2 Warp computer you choose as
the target must be able to run IBM Hursley&#39;s JVM 1.1 port.
<P>
To set up the target computer:
<OL>
<P><LI>Place the daemon (JDAEMON.EXE), the utility library (JVO5JUL.DLL),
and the probe/evaluator
(javaprob.zip) on the target computer.  The directory in which you place
JVO5JUL.DLL must
appear in the LIBPATH or in the BEGINLIBPATH environment variable.
The fully-qualified name of
javaprob.zip must appear in the CLASSPATH environment variable.
<P><LI>If you want to debug the demo Java/C application, MAIN.CLASS with
PAL.DLL, you can also place all of the
files included in SAMPLE.ZIP (*.CLASS and PAL.DLL) on the target
computer.  When it is time to run the
demo, the debugger launches MAIN.CLASS through the daemon.
(Note, if you unzip the SAMPLE.ZIP
file, you will get the demo binaries along with the source. You just
need to copy the .CLASS and .DLL files
to the target computer.)
</OL>
<P>
<H3><A NAME="Header_11" HREF="#ToC_11">Setting up the Host OS/2 Computer</A></H3>
<P>
To set up the host OS/2 computer:
<OL>
<P><LI>Use your normal procedures for installing the Java Development Kit
(JDK).
The debugger is part of this JDK.
<P><LI>Set the environment variables.
See <A HREF="#HDRENVIRO">"Environment Variables"</A> for more information.
</OL>
<P>
<H3><A NAME="HDRDEMO" HREF="#ToC_12">Demonstration Session</A></H3>
<P>
This demonstration session demonstrates the debugger manipulating both
Java class files and a native-method (C code) DLL.
<OL>
<P><LI>Inspect the sample subdirectory on your host computer.  This
subdirectory contains the .C and .JAVA
source files and the demo binaries (.CLASS and .DLL files) that icatjvo
needs to see locally on your host
computer. (Note that the files are contained in SAMPLE.ZIP. SAMPLE.ZIP
must be unzipped on an HPFS
drive.)
<P><LI>On the target computer, ensure that you have set the CLASSPATH to
include javaprob.zip (look at the
provided SETPROBE.CMD).  Also ensure that you set BEGINLIBPATH to
include JVO5JUL.DLL and PAL.DLL
(again, look at the provided SETPROBE.CMD).  This enables the daemon to
find the javaprob.zip file and
JVO5JUL.DLL.  It also enables the JVM to find PAL.DLL when needed by
MAIN.CLASS for the demo.
<P><LI>
Run the daemon on the target computer by emitting
<I>jdaemon port_number</I>.
This instantiates the daemon
and establishes a port number.  On the host computer, run the SETICAT.CMD
with the correct port number
for the  CAT_MACHINE environment variable.  Next run
<I>icatjvo</I> and wait for the Launch or attach
dialog box to display.
<P><LI>From the Launch or attach dialog box,
enter Main in the <B>Program</B> field
(for MAIN.CLASS).
Click the <B>Launch</B> button and click <B>OK</B>
to launch the program.
(We may support attaching to a running JVM application later.)
It will take some time, but
your Java source will eventually be displayed,
and the current instruction will be at the class Main entry point.
<P><LI>Select a Mixed view and notice that we mix the Java bytecodes and
disassembly with the Java source.
Switch back to a Source view.
<P><LI>Do a step over to line 5.  Notice in the Debug Session Control
window that PAL.CLASS and PAL.DLL were loaded.
<P><LI>Next do a step into from line 5.  Notice that you are at line 12 of
the testNative method of the PAL.CLASS
module.  Select the Monitors pull-down menu and the Call stack choice.
Notice the Java method calling
sequence.
<P><LI>
From the Debug Session Control window, open PAL.DLL and the part find.
Double-click the function Pal_findPalindrome.
When its source is displayed, set a breakpoint on
line 12 and run.
<P><LI>
When icatjvo hits this breakpoint, display a mixed view.  Single step
the MASM code a couple of times.
Switch back to a source view.  Next, set a breakpoint at line 16, and
run again.  When you hit that
breakpoint, you can double-click variables, do a call stack unwind, show
a register window or a storage
window, and so on.
<P><LI>Set a breakpoint in the Java source for MAIN.CLASS at line 6.
Run until you hit that breakpoint.
<P><LI>From the Debug Session Control window, open PAL.CLASS and the part
Pal. Double-click the testNative method.
When its source is displayed, set a breakpoint on line 13 and run.
You hit the breakpoint at line 12 of your PAL.DLL,
clear the breakpoint at line 16 of PAL.DLL, and run once again.
You then hit line 13 of the Java class Pal.
<P><LI>
Step over the line 13 instruction.  Now perform a step return.
You should be at line 9 of your MAIN.CLASS.
Step over line 9.
<P><LI>Double-click the Java class variable, <I>e</I>,
which is of type ExprTest.
Notice the support for Java class variables.
<P><LI>Step into the testExpressions method.  Once in testExpressions,
double-click each of the arguments
listed on line 42 (s_char, i_byte, and so on).  Notice the support for
Java primitive variables.
</OL>
<P><I>This concludes the demonstration session.</I>
<P>
<H3><A NAME="HDRSTRTD" HREF="#ToC_13">Starting a Debug Session</A></H3>
<P>
To start the daemon on the target computer, from a command prompt in the
subdirectory in which the
daemon has been installed, type:
<PRE>
        jdaemon port_number
</PRE>
<P>
The port number should be &gt; 1024. Ensure that the CLASSPATH includes
javaprob.zip and the
BEGINLIBPATH references the daemon&#39;s subdirectory.
Also, ensure that the
CLASSPATH references your
test case subdirectory and that the BEGINLIBPATH references your test
case subdirectory if the test case
includes DLLs.
<P>
To start the debugger:
<OL>
<P><LI>From the OS/2 command prompt, enter the command
<I>icatjvo</I> followed by one of the following parameters:
<DL>
<P><DT><B><TT>/P+</TT>
</B><DD>
Use program profile information (the default).
<P><DT><B><TT>/P-</TT>
</B><DD>
Do not use any program profile information.
</DL>
<P>
The Launch or attach window is displayed.
<P><B><A NAME="Figure_1">Figure 1. Launch or attach Window</A></B><BR>
<B><BR><CENTER><IMG SRC="jvlnch.jpg" ALT="* Figure jvlnch not displayed."></CENTER><BR></B><BR>
<P><B>Note: </B>It&#39;s usually a good idea to have set up your environment variables
by way of a SETICAT.CMD file before invoking the debugger.
See <A HREF="#HDRENVIRO">"Environment Variables"</A>
for more information.
<P><LI>If you&#39;re going to debug a program more than once, select the
<B>Use Program Profile</B> check box to
reactivate the windows and breakpoints.
<P><LI>Enter the name of the program to be launched in the
<B>Program</B> field.
You can click the <B>File list</B> button
and select a program from the list of files.
<P><LI>Enter any parameters to the application in the
<B>Parameters</B> field.
These parameters are in effect only if
the application is launched.
<P><LI>Click the <B>Launch</B> button.
<P><B>Note: </B>The <B>Attach</B> option is currently unsupported.
<P><LI>Click <B>OK</B>.
The Debug Session Control window opens displaying the
threads and components of your
source.
</OL>
<P>
<B>Reset</B>
returns the window settings to the values you defined upon
initialization of the window.
<P>
The <B>Default</B> button
returns the window settings back to the default
settings.
<P>
The <B>Settings</B> button displays the Debugger Properties window,
which enables you to select how threads and
source files are initially displayed and enables you to set environment
variables.  See
<A HREF="#HDRSETPROP">"Setting Debugger Properties"</A>
for more information.
<P>
<H3><A NAME="HDRTOOL" HREF="#ToC_14">Using the Tool Buttons</A></H3>
<P>
A tool bar has been provided on the debugger windows for easier access
to frequently used features.  To
display buttons in a window, enable the Tool Buttons choice that is
listed under the <B>Options</B> menu.  The
following is a list of features that are provided:
<DL>
<P><DT><B><IMG SRC="icon0.jpg" ALT="* Figure icon0 not displayed."></B>
<DD>
<B>Step over</B>
executes the current line in the program.  If the current
line is a call, execution is halted
when the call is completed.
<P><DT><B><IMG SRC="icon1.jpg" ALT="* Figure icon1 not displayed."></B>
<DD>
<B>Step into</B>
executes the current line in the program.  If the current
line is a call, execution is halted at
the first statement in the called function.
<P><DT><B><IMG SRC="icon2.jpg" ALT="* Figure icon2 not displayed."></B>
<DD>
<B>Step debug</B>
executes the current line in the program.  The debugger
steps over any function for
which debugging information is not available (for example, library and
system routines) and steps
into any function for which debugging information is available.
<P><DT><B><IMG SRC="icon3.jpg" ALT="* Figure icon3 not displayed."></B>
<DD>
<B>Step return</B>
automatically executes the lines of code up to and including
the return statement of the
current function.
<P><DT><B><IMG SRC="icon4.jpg" ALT="* Figure icon4 not displayed."></B>
<DD>
<B>Run</B>
enables you to start and stop the program. When the debugger is
running, the <B>Run</B> button is
disabled and the <B>Halt</B> button
<B><IMG SRC="icon5.jpg" ALT="* Figure icon5 not displayed."></B>
is enabled.  You can click the <B>Halt</B>
button to halt the program
execution.  You can also interrupt the program you are debugging by
selecting the <B>Halt</B> choice from the <B>Run</B> menu.
<P><DT><B><IMG SRC="icon6.jpg" ALT="* Figure icon6 not displayed."></B>
<DD>
<B>View</B>
changes the current source window to one of the other source windows.
For example, you can
switch from the Disassembly window to the Mixed window.
<P><DT><B><IMG SRC="icon7.jpg" ALT="* Figure icon7 not displayed."></B>
<DD>
<B>Monitor Expression</B>
enables you to specify the name of the expression you
want to monitor.
<P><DT><B><IMG SRC="icon8.jpg" ALT="* Figure icon8 not displayed."></B>
<DD>
<B>Call Stack</B>
enables you to view all of the active functions for a
particular thread including the
system calls. The functions are displayed in the order that they were
called.
<P><DT><B><IMG SRC="icon9.jpg" ALT="* Figure icon9 not displayed."></B>
<DD>
<B>Registers</B>
enables you to view all the processor and coprocessor
registers for a particular thread.
This is useful only for native-binary debugging.
<P><DT><B><IMG SRC="icon11.jpg" ALT="* Figure icon11 not displayed."></B>
<DD>
<B>Storage</B>
displays the storage contents and the address of the storage.
This is useful only for native-binary debugging.
<P><DT><B><IMG SRC="memuse.jpg" ALT="* Figure memuse not displayed."></B>
<DD>
<B>Memory usage</B>
displays the amount of free and used memory of your Java
application.
<P><DT><B><IMG SRC="icon12.jpg" ALT="* Figure icon12 not displayed."></B>
<DD>
<B>Breakpoints</B>
enables you to view all the breakpoints that have been set.
<P><DT><B><IMG SRC="icon13.jpg" ALT="* Figure icon13 not displayed."></B>
<DD>
<B>Debug Session Control</B>
displays the Debug Session Control window.
This is the main window for
the debugger and runs during the complete session.
<P><DT><B><IMG SRC="icon14.jpg" ALT="* Figure icon14 not displayed."></B>
<DD>
<B>Growth direction</B>
enables you to change the direction in which items are displayed on
the stack.
<P><DT><B><IMG SRC="icon15.jpg" ALT="* Figure icon15 not displayed."></B>
<DD>
<B>Delete</B> enables you to delete the selected item.
<P><DT><B><IMG SRC="icon16.jpg" ALT="* Figure icon16 not displayed."></B>
<DD>
<B>Delete all</B> enables you to delete all the items in the window.
<P><DT><B><IMG SRC="icon17.jpg" ALT="* Figure icon17 not displayed."></B>
<DD>
<B>32-float</B>
displays the storage contents as a 32-bit floating point number.
<P><DT><B><IMG SRC="icon18.jpg" ALT="* Figure icon18 not displayed."></B>
<DD>
<B>64-float</B>
displays the storage contents as a 64-bit floating point number.
<P><DT><B><IMG SRC="icon19.jpg" ALT="* Figure icon19 not displayed."></B>
<DD>
<B>32-bit unsigned</B>
displays the storage contents as a 32-bit unsigned integer.
<P><DT><B><IMG SRC="icon20.jpg" ALT="* Figure icon20 not displayed."></B>
<DD>
<B>32-bit signed</B>
displays the storage contents as a 32-bit signed integer.
<P><DT><B><IMG SRC="icon21.jpg" ALT="* Figure icon21 not displayed."></B>
<DD>
<B>ASCII</B>
displays the storage contents in ASCII.
<P><DT><B><IMG SRC="icon22.jpg" ALT="* Figure icon22 not displayed."></B>
<DD>
<B>Hex and ASCII</B>
displays the storage contents in Hex and ASCII.
<P><DT><B><IMG SRC="icon23.jpg" ALT="* Figure icon23 not displayed."></B>
<DD>
<B>Change representation</B>
enables you to change the data representation.
</DL>
<P>
<H3><A NAME="Header_15" HREF="#ToC_15">Helpful Tips and Hints</A></H3>
<P>
The following tips and hints might be helpful:
<UL>
<P><LI>You must have OS/2 Warp on your host and target computers.
<P><LI>Put any environment variables that you want set in a command file.
For example, you could put them in
the SETICAT.CMD file or create your own command file.
<P><LI>Any debug stripper utility can be used to strip debug information
from binaries placed on the target
computer but should not be used on DLLs placed in CAT_HOST_BIN_PATH
(if you want to do
source-level debugging of native methods).
<P><LI>
Using C, you can write your program code with stylistic features that
are not supported by the debugger.
For example, multiple statements on the same line are difficult to debug.
None of the individual
statements can be accessed separately when you set breakpoints or when
you use step commands.
</UL>
<P>
<H3><A NAME="Header_16" HREF="#ToC_16">Troubleshooting</A></H3>
<P>
Following are some things to check when the debugger is not doing
what you think it should:
<UL>
<P><LI>If the debugger can&#39;t attach to the target computer:
<OL COMPACT>
<LI>Ensure that the daemon is installed and running on the target
computer.
<LI>Ensure that your CAT_COMMUNICATION_TYPE environment variable is set
to TCP.
<LI>Ensure that the CLASSPATH includes javaprob.zip and BEGINLIBPATH is
set to the
daemon&#39;s subdirectory on the target computer before
running the daemon.
<LI>Ensure that the CAT_MACHINE target IP address matches that of the
target OS/2 Warp computer
and that the port number matches the one chosen for the daemon.
</OL>
<P><LI>If the debugger only displays the disassembly listing of your program
not the source listing:
<OL COMPACT>
<LI>Ensure that the program was compiled with the proper flags to enable
source-level debugging.
<LI>Ensure that the DLLs in the CAT_HOST_BIN_PATH were not processed by a
debug stripper
utility. Debug stripper utilities make the DLLs smaller by removing the
debug information.
<LI>Ensure that your CAT_HOST_SOURCE_PATH or CAT_PACKAGE_PATH is set to
reference your source files.
</OL>
<P><LI>If the daemon issues &quot;Error 10049 occurred on call to bind,&quot;
make sure that the name of the local host as
specified in the TCP/IP settings folder and in the HOSTNAME environment
variable is correct.
If the daemon issues
&quot;Error 10048 occurred on call to bind,&quot;
the port number specified when the daemon was
invoked is (already or still) in use.  Pick a different port number
(or invoke the daemon without a port
number to let the system pick one) and adjust your CAT_MACHINE
environment variable on the host
accordingly.
<P><LI>If the debugger starts to launch an application and hangs for a
very long time (5 to 10 minutes) without
any noticeable activity, make sure you have the loopback interface
enabled.  You can do this from the
TCP/IP settings folder or by issuing the command:
<PRE>
        ifconfig lo 127.0.0.1 up
</PRE>
You can check the status of the loopback interface by issuing the
command:
<PRE>
        ifconfig lo
</PRE>
<P>
Alternatively, if you can use jdb to debug a small Java testcase,
the loopback interface&#39;s current state is fine.
</UL>
<P>
<H3><A NAME="HDRUSEDAD" HREF="#ToC_17">Using the Drag-and-Drop Function</A></H3>
<P>
Drag-and-drop is supported in the Storage, Registers, Private Monitor,
and Program Monitor windows.
Additionally, drag is supported from the Source window.  When you press
and hold the right mouse button
then move the mouse, the drag is in operation.  Move the mouse to the
target location and release the mouse
button to perform a drop.
<P>
<H3><A NAME="Header_18" HREF="#ToC_18">Ending the Debugging Session</A></H3>
<P>
To end the debugging session, click
<B>Close debugger</B> located within the
<B>File</B> menu from any of the debugger
windows.  The Close Debugger window is displayed.  Select one of the
following choices:
<UL>
<P><LI>Click <B>Yes</B> to end your debugging session.
<P><LI>Click <B>No</B> to return to the previous screen without
exiting the debugger.
</UL>
<P>
You can also end the debugging session by pressing F3 in any of the
debugger windows.
<HR>
<H1><A NAME="Header_19" HREF="#ToC_19">Main Debugging Windows</A></H1>
<P>
This section introduces the Debug Session Control window and how to
perform functions from this window.
It also introduces the three source windows that offer different views
of your source code.
<HR>
<H2><A NAME="Header_20" HREF="#ToC_20">Debug Session Control Window</A></H2>
<P>
The Debug Session Control window is the control window of the debugger
and is displayed during the entire
debugging session.  This window is divided into two panes:
<I>Threads</I> and <I>Components</I>.
<UL>
<P><LI>The <I>Threads</I> pane contains the threads and the state of the
threads started by your program.  To display
the state of a thread, click the plus icon to the left of the thread.
<P>
Right-click on a selected item to display the Thread menu and press F1
to view help for this item.
<P><LI>The <I>Components</I> pane shows the path names of the modules
that you are debugging.
<P>
Right-click on a selected item to display the Component menu and press
F1 to view help for this item.
</UL>
<P><B><A NAME="Figure_2">Figure 2. Debug Session Control Window</A></B><BR>
<B><BR><CENTER><IMG SRC="jvdscw.jpg" ALT="* Figure jvdscw not displayed."></CENTER><BR></B><BR>
<P>
From the Debug Session Control window you can select menus that enable
you to:
<UL COMPACT>
<LI>Open a new source file.
<LI>Load a class that is not currently loaded in the JVM.
<LI>Open a source window to a particular function.
<LI>Open a source window containing the next line to be executed.
<LI>Save the contents of the Threads pane or the Components pane into a
file.
<LI>Open the Initialization window to start a debugging session.
<LI>Set line, function, address, watchpoint, or load occurrence
breakpoints.
<LI>Display a list of breakpoints that have been set.
<LI>Monitor the call stack for a particular thread.
<LI>Monitor registers and flags for a particular component or thread.
<LI>Monitor the storage in your application.
<LI>Filter exceptions.
<LI>Display the local variables for your application&#39;s
current function.
<LI>View the amount of free and used memory for your Java program.
<LI>Execute your application or stop execution.
<LI>Modify how the debugger window is displayed.
</UL>
<P>
<H3><A NAME="Header_21" HREF="#ToC_21">Opening a New Source File</A></H3>
<P>
You can open additional source files from the Debug Session Control
window.
<P>
To open a new source file:
<OL>
<P><LI>Click <B>Open New Source</B> (located within the
<B>File</B> menu).
<P><LI>Type the name of the object file you want to open the source for in
the <B>Source</B> field.
<P>
For example, to look for the source used to compile A123.CLASS, type
the following in the <B>Source</B> field:
<PRE>
        A123
</PRE>
<P>
If you are uncertain of the file name, click the
<B>File list</B> button to
view a list of the files that you can select.
<P><LI>Type the name of the executable file in the <B>Executable</B>
field.
The source files for the executable file are
displayed in the <B>Source</B> field.
<P><LI>Select the <B>All executables</B> check box
if you want to search all the executable files.
Clear the
<B>All executables</B> check box
to search for a particular executable file.
<P><LI>Select the <B>Debugging information only</B> check box
if you want to search only the source files that
contain debugging information.
<P><LI>Click the <B>OK</B> button.
</OL>
<P>
<H3><A NAME="Header_22" HREF="#ToC_22">Loading a Class</A></H3>
<P>
You can load a class that is not already loaded in the JVM.
<P>
To load a class:
<OL>
<P><LI>Click <B>Load Class</B>
(located within the <B>File</B> menu).
The Load Class window is displayed.
<P><B><A NAME="Figure_3">Figure 3. Load Class Window</A></B><BR>
<B><BR><CENTER><IMG SRC="jvoload.jpg" ALT="* Figure jvoload not displayed."></CENTER><BR></B><BR>
<P><LI>Type the name of the class you wish to load, without the .CLASS
extension. For example, to load the class
MAIN.CLASS, type the following in the <B>Classes</B> field:
<PRE>
        Main
</PRE>
<P><LI>Click the <B>OK</B> button.
<P>
If the class name you enter is not found, the following message is
displayed:
<PRE>
        Invalid class name
</PRE>
</OL>
<P>
If the class name is valid, the class is loaded and can then be found
in the components section of the Debug
Session Control window.
<P>
You may load multiple classes at once. Type each class name in the
<B>Classes</B> field and use blanks to delimit them.
<P><B>Note: </B>Classes can be loaded immediately as ICAT initializes.
See
<A HREF="#SPTPRELOAD">CAT_CLASS_PRELOAD_LIST</A>
for details.
<P>
<H3><A NAME="Header_23" HREF="#ToC_23">Opening a Source File to a Function</A></H3>
<P>
You can use the Find Function window to open a source window to a
particular function.
<OL>
<P><LI>Click <B>Find Function</B> (located within the
<B>File</B> menu).
<P><LI>Type the name of the function you want to search for in the
<B>Function</B> field.
<P>
If the function that you specify is not found, the following message is
displayed:
<PRE>
No matching function found. Desired function could be static.
</PRE>
<P>
This means it might be a static function or the function you specified
does not exist.
<P>
The debugger searches each object file for global functions that match
the function name specified.  If
an object file contains the global function that was specified, then it
also searches that file for any static
function with the same name.
<P><LI>Select the <B>Debugging information only</B> check box
if you want to search only the object files that
contain debugging information.
<P><LI>Select the <B>Case sensitive</B> check box
if you want to search for the string exactly as typed.
Clear this
check box if you want to search for both uppercase and lowercase
characters.
<P><LI>Click the <B>OK</B> button.
</OL>
<P>
<H3><A NAME="Header_24" HREF="#ToC_24">Locating the Execution Point</A></H3>
<P>
To locate the execution point in your source, click
<B>Where is execution point</B>
(located within the <B>File</B> menu).
A source window is displayed containing the next line to be executed.
<P>
<H3><A NAME="Header_25" HREF="#ToC_25">Saving the Contents of the Threads Pane View</A></H3>
<P>
If you want to save the contents of the Threads pane view in a file,
click <B>Save thread list in file</B> (located
within the <B>File</B> menu).
This saves the view in a file named <I>threads.out</I>.
To change the default file name,
click
<B>Options</B>, <B>Windows settings</B>,
and then <B>Display style</B>
located within
the Debug Session Control window
and type the file name in the <B>Threads output file</B> field.
<P>
<H3><A NAME="Header_26" HREF="#ToC_26">Saving the Contents of the Components Pane View</A></H3>
<P>
If you would like to save the contents of the Components pane view in a
file, click <B>Save component list in file</B>
(located within the <B>File</B> menu).
This saves the view in a file named
<I>comps.out</I>.  To change the default file
name, click
<B>Options</B>, <B>Window Settings</B>,
and then <B>Display Style</B> located
within the Debug Session Control
window and type the file name in the
<B>Components output file</B> field.
<P>
<H3><A NAME="Header_27" HREF="#ToC_27">Opening the Launch or attach Window</A></H3>
<P>
If you want to start a debugging session, click
<B>File</B> and then <B>Launch or attach</B>
(located within the Debug Session Control window).
The Launch or attach window is displayed.
See
<A HREF="#HDRSTRTD">"Starting a Debug Session"</A>
for more information.
<P>
<H3><A NAME="Header_28" HREF="#ToC_28">Setting Breakpoints</A></H3>
<P>
You can control program execution by setting breakpoints.  A breakpoint
stops the execution of your
program at a specific location or when a specific event occurs.
<P>
To set breakpoints, click the <B>Breakpoints</B> menu
(located on the Debug Session Control window or located
on any source window), and then click the appropriate choice for the
type of breakpoint you want to set.
When you set a breakpoint in one source window, it is reflected in the
other source windows. In addition,
you can set a simple line breakpoint in a source window using either the
mouse or the keyboard:
<UL>
<P><LI>To set a breakpoint with the mouse, double-click in the
prefix area of an executable statement (the prefix
area is the area to the left of the source code where line numbers or
addresses are displayed);
the prefix area is displayed in red
to indicate that the breakpoint has been set.
Double-click in the same prefix area to delete the breakpoint.
<P><LI>To set a breakpoint with the keyboard, move the cursor to the prefix
area and then press the Spacebar to
set or delete a breakpoint.
</UL>
<P><B>Note: </B>You can set as many breakpoints as you want.
<P>
You can set either line, function, address, watchpoint, or load
occurrence breakpoints.
<P>
<H4><A NAME="Header_29" HREF="#ToC_29">Setting a Line Breakpoint</A></H4>
<P>
A line breakpoint enables you to stop the execution of your program at a
specific line number.
<P>
You set a line breakpoint from the Line Breakpoint window.
To display the window,
from the <B>Breakpoints</B> menu, click <B>Set line</B>.
<P><B><A NAME="Figure_4">Figure 4. Line Breakpoint Window</A></B><BR>
<B><BR><CENTER><IMG SRC="jvlbw.jpg" ALT="* Figure jvlbw not displayed."></CENTER><BR></B><BR>
<P>
The Line Breakpoint window is divided into two group headings:
<I>Required Parameters</I> and
<I>Optional Parameters</I>.
<P><I>Required Parameters</I>:
<OL>
<P><LI>Type a component name or click a component located within the
drop-down list in the <B>Executable</B> field.
<P><LI>Select the executable file in which you want to set the breakpoint.
<P><LI>Type the source name or click a source name
located within the drop-down list in the <B>Source</B> field.
<P><LI>Select the source name where you want to set the breakpoint.
<P><LI>If the source you selected has include files with executable
statements, type the name of the file in the
<B>File (optional)</B> field or click the file name located
within the drop-down list.
All the file names
that contain executable lines are displayed in the drop-down list.
<P><LI>Select the file where you want to set the breakpoint.
<P><LI>Type the line number where you want to set the breakpoint in the
<B>Line</B> field.
</OL>
<A NAME="SPTOPTPM"></A>
<P><I>Optional Parameters</I>:
<OL>
<P><LI>Click the drop-down list in the <B>Thread</B> field.
<P><LI>Select the thread where you want to set the breakpoint.
<P>
Click <B>Every</B>,
the default, to set a breakpoint in all of the active
threads in your program.  The Every
choice is thread independent.  Select one of the individual threads to
set a breakpoint in only one thread.
Threads are added to the Thread list as new threads are activated.
Type a number in the <B>From</B> field to
activate the breakpoint the nth time the location is encountered.
<P><LI>Type a number in the <B>To</B> field to stop activating the
breakpoint after the nth time the location is encountered.
<P><LI>Type a number in the <B>Every</B> field to indicate how often the
breakpoint should be activated within the
From and To range.
<P><B>Note: </B>The <B>Frequency</B> fields (From, To, and Every) are used for
location, address, and load occurrence breakpoints.
<P><LI>If you are setting an address, function, or line breakpoint, you can
also type an expression in the <B>Expression</B> field.
The execution of the program stops only if this
condition tests true.  For example,
you could type the following:
<PRE>
        (i==1)   (j==k) && (k!=5)
</PRE>
<P><B>Note: </B>Variables in a conditional expression associated with a function
breakpoint are limited to any
static or global variables that are known to the called function when
the function is called.  The
debugger does not always evaluate local variables and automatic
variables correctly.
The maximum length of the condition is 256 characters.
<P><LI>Select the <B>Defer breakpoint</B> check box if you want to set a
breakpoint in a module that is not currently loaded.
If you set a deferred line breakpoint and the line is located in
a template, the debugger sets the
line breakpoint in all of the templates when the module is loaded.
<P>
When a module is loaded and a deferred breakpoint has been set in the
module, the state of the
breakpoint changes from deferred to active. When a module is freed,
any breakpoints that were set in the
module change from the active state to the deferred state.
<P>
If you enter an invalid source, file, or line number, the debugger is
unable to activate the breakpoint
when the module is loaded. Therefore, the invalid breakpoint remains
in the deferred state even after the
module is loaded.
<P><LI>Click <B>Set</B> to set the breakpoint.
</OL>
<P>
<H4><A NAME="Header_30" HREF="#ToC_30">Setting a Function Breakpoint</A></H4>
<P>
A function breakpoint stops the execution of your application when the
first instruction of the function is
encountered where the breakpoint has been set.
<P>
You set a function breakpoint from the Function Breakpoint window.  To
display the window, click <B>Set function</B>
(located within the <B>Breakpoints</B> menu).
<P>To set a function breakpoint:
<OL>
<P><LI>Type a component name or click a component located within the
drop-down list in the <B>Executable</B> field.
<P><LI>Select the executable file where you want to set the breakpoint.
<P><LI>Type the source name or click a source name
located within the drop-down list in the <B>Source</B> field.
<P><LI>Select the source where you want to set the breakpoint.
<P><LI>Type the name of the function in the <B>Function</B> field
where you want to set the breakpoint or click a
function located within the Function list.
<P>
If a function is overloaded, a window is displayed with a list of all
the overloaded function names.
Click the appropriate function from the list.
<P><LI>Select the <B>Debugging information only</B> check box
if you want to search only the object files that
contain debugging information.
<P><LI>Select the <B>Case sensitive</B> check box
if you want to search for the string exactly as typed.
Clear this check box if you want to search for both uppercase and
lowercase characters.
<P><LI>Click or type optional parameters (if any).
<P>
For a description of the fields under the Optional Parameters group
heading, see
<A HREF="#SPTOPTPM">Optional Parameters</A>.
<P><LI>Click <B>Set</B> to set the breakpoint.
</OL>
<P>
<H4><A NAME="Header_31" HREF="#ToC_31">Setting an Address Breakpoint</A></H4>
<P>
An address breakpoint enables you to stop the execution of your
application at a specific address.
<P>
You set an address breakpoint from the Address Breakpoint window.
To display the window, click <B>Set
address</B> (located on the <B>Breakpoints</B> menu).
<P>
To set an address breakpoint:
<OL>
<P><LI>Type the name of the address or expression where you want to set the
breakpoint in the Address field.
<P>
For example, to set an address breakpoint for the address 0x000A1FCC,
you would type one of the
following:
<PRE>
0x000A1FCC or A1FCC
</PRE>
The <TT>0x</TT> is optional.
<P><LI>Click or type optional parameters (if any).
<P>
For a description of the fields under the Optional Parameters group
heading, see
<A HREF="#SPTOPTPM">Optional Parameters</A>.
<P><LI>Click <B>Set</B> to set the breakpoint.
</OL>
<P>
<H4><A NAME="Header_32" HREF="#ToC_32">Setting a Watchpoint</A></H4>
<P>A watchpoint stops the execution of your application when the
contents of
memory at a given address are referenced or when an instruction is
fetched from a particular address.
<P>You set a watchpoint from the <B>Watchpoint</B> window.
To display the window, click <B>Set watchpoint</B> (located within
the <B>Breakpoints</B> menu).
<P>To set a watchpoint:
<OL>
<P><LI>Type a hexadecimal address or port or an expression that can be
evaluated to a hexadecimal address in the <B>Address (or
expression)</B> field.
<P><B>Note: </B>If you type <TT>ABC</TT> in the <B>Address (or
expression)</B> field, and there is a variable named ABC, the value of
the variable is used instead of the hex value ABC.
Also, you can type <TT>&a</TT> in the field to set the watchpoint on
the address of variable <I>a</I>.
<P>For example, type the following in the field to set a watchpoint for
the address <I>&variable</I>.
<P><TT>&variable</TT>
<P><LI>Click the Watchpoint Type.
<P>The debugger supports four types of watchpoints.
They are as follows:
<DL>
<P><DT><B>Read
</B><DD>Causes a break when the address is read.
<P><DT><B>Write
</B><DD>Causes a break when the address is written to.
<P><DT><B>Read or write
</B><DD>Causes a break when the address is read from or written to.
<P><DT><B>Instruction fetch
</B><DD>Causes a break when the instruction at that address is fetched.
</DL>
<P><B>Attention:</B>
If you set a watchpoint that is on the call stack, you should remove the
watchpoint before leaving the routine associated with the watchpoint.
Otherwise, when you return from the routine, the routine&#39;s stack
frame is removed from the stack leaving the watchpoint intact.
Any other routine that gets loaded on the stack then contains the
watchpoint.
You can set up to four watchpoints.
<P><LI>Click or type optional parameters (if any).
<P>For a description of the Optional Parameters group heading, see
<A HREF="#SPTOPTPM">Optional Parameters</A>.
<P><LI>Click <B>Set</B> to set the watchpoint.
</OL>
<P><B>Note: </B>The debugger monitors 1, 2, or 4 bytes for the type of watchpoint
operation that you select.
This choice is made for you on the <B>Instruction fetch</B> type.
Watchpoints only work for your native code.
There is no support for Java watchpoints.
<P>
<H4><A NAME="Header_33" HREF="#ToC_33">Setting a Load Occurrence Breakpoint</A></H4>
<P>
A load occurrence breakpoint stops the execution of your application
when a specific module is loaded.
<P>
You set a load occurrence breakpoint from the
Load Occurrence Breakpoint window.
To display this window, click
<B>Set load occurrence</B> (located within the
<B>Breakpoints</B> menu).
<P>
To set a load occurrence breakpoint:
<OL>
<P><LI>Type the name of the module in the <B>Module name</B> field.
<P>
Execution stops when the module is loaded.
<P>
To set a load occurrence breakpoint when MY_APP.CLASS is loaded,
type one of
the following in the
<B>Module name</B> field:
<PRE>
        MY_APP or MY_APP.CLASS
</PRE>
<P><B>Note: </B>If the CAT_MODULE_LIST environment variable has been defined and
the module&#39;s name is
not contained in the CAT_MODULE_LIST, the module is not reported.  If
the module cannot be found
in the module search path, the module name is not accepted.  See
<A HREF="#HDRSETPROP">"Setting Debugger Properties"</A>
for information on identifying modules.
<P><LI>Click or type optional parameters (if any).
<P>
For a description of the fields under the Optional Parameters group
heading, see
<A HREF="#SPTOPTPM">Optional Parameters</A>.
<P><LI>Click <B>Set</B> to set the breakpoint.
</OL>
<P>
<H3><A NAME="Header_34" HREF="#ToC_34">Viewing a List of Breakpoints</A></H3>
<P>
The Breakpoints List window lists all the breakpoints that have been
set in your application.  It also displays
the state of each breakpoint.
<P>
To display the Breakpoints List window, click <B>List</B>
(located within the
<B>Breakpoints</B> menu of the Debug Session Control window).
<P><B><A NAME="Figure_5">Figure 5. Breakpoints List Window</A></B><BR>
<B><BR><CENTER><IMG SRC="jvblw.jpg" ALT="* Figure jvblw not displayed."></CENTER><BR></B><BR>
<P>
The following information is provided for each breakpoint:
<UL COMPACT>
<LI>The type of breakpoint
<LI>The position of the breakpoint
<LI>The enablement state
<LI>The conditions under which the breakpoint is activated
</UL>
<P>
From the menu on this window you can:
<UL COMPACT>
<LI>Close your current debugging session.
<LI>Delete, disable, and modify breakpoints.
<LI>Set line, function, address, watchpoint, and load occurrence
breakpoints.
<LI>Modify how the information in the window is displayed.
<LI>View a list of open windows and select any open window to display
that window.
<LI>Display help.
</UL>
<P>
<H3><A NAME="HDRSETPROP" HREF="#ToC_35">Setting Debugger Properties</A></H3>
<P>
From the Debug Session Control window click
<B>Options</B>, <B>Debugger settings</B>, and then
<B>Debugger properties</B>
to select how the threads and source files are initially
displayed.
The Debugger Properties window contains three tabs:
<UL>
<P><LI>Remote
<P><LI>Source
<P><LI>Modules
</UL>
<P>
<H4><A NAME="Header_36" HREF="#ToC_36">Remote Page</A></H4>
<P>
When you click the <B>Remote</B> tab located on the
Debugger Properties window, the following page is displayed:
<P><B><A NAME="Figure_6">Figure 6. Debugger Properties Window - Remote Page</A></B><BR>
<B><BR><CENTER><IMG SRC="jvdpwr.jpg" ALT="* Figure jvdpwr not displayed."></CENTER><BR></B><BR>
<P>From the Remote page you can:
<UL COMPACT>
<LI>Set the IP address and the port number of the daemon.
<LI>Set the path where the debugger finds the source.
<LI>Set the path where the debugger finds the debug binary modules.
<LI>Set the package path where the debugger finds class package
and source files.
<LI>View the communication mode (TCP is all that is currently available
unless daemonless debugging is
being used. NO_DAEMON is displayed in this case).
<LI>Provide arguments to the JVM.
<LI>Set the option for recursive subdirectory searching of the source and
binary paths.
<LI>Set the option for debugging Java code only (no native-method
debugging).
</UL>
<P><B>Note: </B>The values for this window are dithered and cannot be changed
after communication has been
established with the target computer.
<P>
To change your communication setting paths dynamically before
communication is established with the
target computer, adjust any of the Environment Variables Group Heading
fields.  See
<A HREF="#HDRENVIRO">"Environment Variables"</A>
for detailed information on environment variables.
<P>
These fields correspond, respectively, to the following environment
variables:
<UL COMPACT>
<LI>CAT_MACHINE (first two fields)
<LI>CAT_HOST_SOURCE_PATH
<LI>CAT_HOST_BIN_PATH
<LI>CAT_PACKAGE_PATH
<LI>CAT_COMMUNICATION_TYPE
<LI>CAT_JVM_ARGS
<LI>CAT_PATH_RECURSE (check box)
<LI>CAT_JAVA_ONLY (check box)
</UL>
<P>
If you select the <B>Recursive file searching</B> check box,
the debugger searches all source and binary path
subdirectories recursively.
<P>
The <B>Java code only</B> check box tells the debugger to debug
Java class files and to ignore DLL files (no
native-method debugging).
<P>
<H4><A NAME="Header_37" HREF="#ToC_37">Source Page</A></H4>
<P>
When you click the <B>Source</B> tab located on the
Debugger Properties window, the following page is displayed:
<P><B><A NAME="Figure_7">Figure 7. Debugger Properties Window - Source Page</A></B><BR>
<B><BR><CENTER><IMG SRC="jvdpws.jpg" ALT="* Figure jvdpws not displayed."></CENTER><BR></B><BR>
<P>Use this page to determine:
<UL COMPACT>
<LI>When a source window is displayed during a debugging session.
<LI>How to process a source window from which execution has just left.
The window can remain displayed, be turned into an icon, or be discarded.
</UL>
<P>
To display the source view of all threads or a particular thread when
execution stops, choose any selection
located under the <B>Display at stop</B> group heading.
<P>
In the course of debugging, the <B>Old Source Disposition</B>
selections enable you to control the behavior of
source windows following command execution.
These radio buttons control the behavior of source
windows within a thread.
<P>
The dispositions that the views can take are:
<DL>
<P><DT><B>Keep
</B><DD>
Leaves open the source windows that contain the components and threads
that you select with <B>Display at stop</B>.
<P><DT><B>Minimize
</B><DD>
Changes into icons the views that contain the components and threads
that you select with <B>Display at stop</B>.
<P><DT><B>Discard
</B><DD>
Disposes of the views that contain the components and threads that you
select with
<B>Display at stop</B>.
</DL>
<P>
You can choose to display more than one source window for a particular
source file.  Enable the
<B>Multiple views</B>
check box located under the <B>Settings</B> group heading if you want
to have multiple source windows
open at the same time.
<P>
To select functions you want to perform with the right mouse button,
choose the radio button that represents
the action located under the
<B>Mouse Button 2 Behavior</B> group heading.
<P>
<H4><A NAME="Header_38" HREF="#ToC_38">Modules Page</A></H4>
<P>
When you click the <B>Modules</B> tab located on the
Debugger Properties window, the following page is displayed:
<P><B><A NAME="Figure_8">Figure 8. Debugger Properties Window - Modules Page</A></B><BR>
<B><BR><CENTER><IMG SRC="jvdpwm.jpg" ALT="* Figure jvdpwm not displayed."></CENTER><BR></B><BR>
<P>
From this page you can add a module name to or delete a module name
from the CAT_MODULE_LIST
environment variable.  See <A HREF="#HDRENVIRO">"Environment Variables"</A> for detailed
information on this environment
variable.
<P>
The Modules list box displays a list of the modules that the debugger
obtains information about if or when
they are loaded.  If a module is loaded and it is not in the list, the
debugger ignores the module.
<P>
To add a new module, type the name of the new module in the
<B>New module</B>
field and click the <B>Add</B> button.
<P>
You can delete a module or a group of modules in the list.
Select the modules in the
Modules list box that you would
like to delete and click either the
<B>Delete</B> button or the <B>Delete all</B>
button.
<P>From this page you can also add or delete a class name from the
CAT_CLASS_PRELOAD_LIST environment variable.
See <A HREF="#HDRENVIRO">"Environment Variables"</A> for detailed information on this environment
variable.
<P>The Preload classes list box displays a list of classes that the
debugger loads for you once your main() method has been reached on
initialization.
This forces the classes listed to be present in the Debug Session
Control window,
which enables you to view the source code for these
classes, set breakpoints, and so on without manually loading the classes
or stepping over code that loads the classes.
<P>To add a new class, type the name of the new class in the
<B>New class</B> field and click the <B>Add</B> button.
<P>
You can delete a class or a group of classes in the list.
Select the classes in the Preload classes list box that you want
to delete and click either the <B>Delete</B> button or the
<B>Delete all</B> button.
<P>
<H3><A NAME="Header_39" HREF="#ToC_39">Setting Monitor Properties</A></H3>
<P>
To select the settings for monitoring variables or expressions:
<OL>
<P><LI>From the Debug Session Control window
click <B>Options</B>, <B>Debugger settings</B>, and then
<B>Monitor properties</B>.
The Monitor Properties window is displayed.
<P><B><A NAME="Figure_9">Figure 9. Monitor Properties Window</A></B><BR>
<B><BR><CENTER><IMG SRC="jvmonp.jpg" ALT="* Figure jvmonp not displayed."></CENTER><BR></B><BR>
<P>
From this window you can set the window into which the variable or
expression being monitored is
placed or for expression windows, how long the monitor windows are
displayed.
<P><LI>Define the monitor window that opens when you select a variable or
expression to monitor.  Following
are the selections you can make and the corresponding windows:
<DL>
<P><DT><B>Popup monitor
</B><DD>Display the variable or expression in an expression window.
<P><DT><B>Private monitor
</B><DD>Display the variable or expression in the Private Monitor window.
<P><DT><B>Program monitor
</B><DD>Display the variable or expression in the Program Monitor window.
<P><DT><B>Storage monitor
</B><DD>Display the variable or expression in the Storage window.
</DL>
<P><LI>If you click <B>Popup monitor</B>,
click one of the following radio buttons
to specify how long the expression window is displayed:
<DL>
<P><DT><B>Step/run
</B><DD>The monitor window closes when the next step command or
Run is executed.
<P><DT><B>New source
</B><DD>The monitor window closes when execution stops in a new source file.
<P><DT><B>Permanent
</B><DD>This monitor window is associated with a specific source window and
closes when the associated source window closes.
</DL>
<P><LI>Type a file name and extension in the
<B>Save File</B> field to identify
where all monitor windows will save
their contents.
<P><LI>The <B>Number of elements to show</B> field identifies the
maximum number of structure or class elements
that are displayed at one time for a given variable in the monitors.
<P><LI>Select the <B>Enable bubble variables</B> check box
if you want a bubble value for the contents of a variable
to appear as you place the mouse pointer or the variable in the Source,
Disassembly, and Mixed view
windows.
</OL>
<P>
<H3><A NAME="Header_40" HREF="#ToC_40">Setting Exception Filters</A></H3>
<P>
Java exceptions that occur during execution of a Java program are
unconditionally reported to you unless the
code containing the fault is contained within a &quot;try&quot; block.
In that case, you can select whether or not you
want to have a particular Java exception reported to you. If not
reported, execution continues with the
associated &quot;catch&quot; block.
The default is <I>not</I> to report Java exceptions
that occur within a &quot;try&quot; block.
<P>
To filter out exceptions, from the source view or Debug Session Controls
window:
<OL>
<P><LI>Click <B>Options</B>, <B>Debugger Settings</B>,
and then <B>Exception Filtering</B>.
The Exception Filtering window is displayed.
<P><B><A NAME="Figure_10">Figure 10. Exception Filtering Window</A></B><BR>
<B><BR><CENTER><IMG SRC="jvoxfil.jpg" ALT="* Figure jvoxfil not displayed."></CENTER><BR></B><BR>
<P><LI>Click any exceptions you want reported if the fault occurs
in a &quot;try&quot; block.
<P><LI>Click <B>OK</B>.
<P><LI>Click <B>Default</B> if you would like to set all exceptions to
the default state.
<P><LI>Click <B>Reset</B> if you would like to undo any
changes you have made since the last time you clicked the
<B>OK</B> button.
</OL>
<P>
If you are debugging native code, native exceptions are also shown in
the Exception Filtering window.
Native exceptions are unconditionally filtered unless you select to have
them reported.
<P>
<H3><A NAME="Header_41" HREF="#ToC_41">Viewing Your Source</A></H3>
<P>
A source window enables you to view the program you are debugging.  You
can view your source in one of
the following windows:
<UL>
<P><LI>Source
<P><LI>Disassembly
<P><LI>Mixed
</UL>
<P>
<H4><A NAME="Header_42" HREF="#ToC_42">Source Window</A></H4>
<P>
A source window is thread specific.  Executable lines are initially
displayed in blue, and nonexecutable lines
are initially displayed in black.  Lines with breakpoints have a red
prefix, and lines with disabled
breakpoints have a green prefix.
<P>
The Source window displays the source code for the current function of
the program being debugged.  If
source is available, the Source window is displayed with the Debug
Session Control window when the
debugging session starts; otherwise, the Disassembly window is displayed.
<P><B><A NAME="Figure_11">Figure 11. Source Window</A></B><BR>
<B><BR><CENTER><IMG SRC="jvsrc.jpg" ALT="* Figure jvsrc not displayed."></CENTER><BR></B><BR>
<P><B>Drag-and-Drop Function</B>
<P>
The Source window can be used only to drag values.  Drop is not
supported in the Source window.
<P>
To drag an item in the Source window, press and hold the right mouse
button on the string that you want to
drag while moving the mouse.  If you want to drag an extended line,
select the line using the left mouse
button and then press and hold the right mouse button to move the
selected text.
<P>
When an item is dragged from the Source window, its context is dragged
with it.  However, only the
Monitors windows (Private and Program) use this context on the drop
operation.  So only values that have
global context can be dropped from the Source window onto the Storage
window or the Registers window.
<P>
See
<A HREF="#HDRUSEDAD">"Using the Drag-and-Drop Function"</A>
for more information about the drag-and-drop function.
<P>
<H4><A NAME="Header_43" HREF="#ToC_43">Disassembly Window</A></H4>
<P>
The Disassembly window displays the assembler or bytecode instructions
for your program without
symbolic information.
<P><B><A NAME="Figure_12">Figure 12. Disassembly Window</A></B><BR>
<B><BR><CENTER><IMG SRC="jvdisw.jpg" ALT="* Figure jvdisw not displayed."></CENTER><BR></B><BR>
<P>
<H4><A NAME="Header_44" HREF="#ToC_44">Mixed Window</A></H4>
<P>
The Mixed window displays your program as follows:
<UL COMPACT>
<LI>Each line of source code is prefixed by its line number as in the
Source window.
<LI>Each disassembled line is prefixed by an address as in the
Disassembly window.
<LI>Source comment lines are also displayed.
<LI>The lines of source code are treated as comments within the lines of
disassembly code.  You can only set
breakpoints or run your program on lines of disassembly code.
</UL>
<P><B>Note: </B>The Mixed window cannot be opened if the source code is not
available.
<P><B><A NAME="Figure_13">Figure 13. Mixed Window</A></B><BR>
<B><BR><CENTER><IMG SRC="jvmixw.jpg" ALT="* Figure jvmixw not displayed."></CENTER><BR></B><BR>
<P>
Each of the source windows has menus.  The menus are the same as the
Debug Session Control window
menus with the following exceptions:
<UL>
<P><LI><B>File</B> menu--<B>Save window in file</B>
<P>
This choice enables you to save the current source view to a named file.
<P><LI>From the <B>View</B> menu, you can:
<UL>
<P><LI>Locate strings of text:
<UL COMPACT>
<LI>Alphabetic and numeric
<LI>A maximum of 256 characters
<LI>Uppercase and lowercase characters
</UL>
<P><LI>Scroll to a particular line.
<P>
You can also use the Scroll to Line Number window to set a breakpoint.
In the Line field, enter the
line number and then click the Breakpoint button.
<P><LI>View include files.
<P><LI>Change the text file name (specify a file name to be used as the
source in the current view).
<P><LI>Select a different view of your application.
</UL>
<P><LI><B>Breakpoints</B> menu--<B>Toggle at current line</B>
choice.
<P>
<B>Toggle at current line</B> sets a breakpoint on the current line
or deletes an existing breakpoint from the current line.
<P><LI><B>Monitors</B> menu--Monitor expression
<P>
Enables you to monitor expressions or variables and add them to various
monitor windows.
</UL>
<P><B>Note: </B>If you need help with any of the menus, press F1 while the menu is
selected.
<HR>
<H2><A NAME="Header_45" HREF="#ToC_45">Executing a Program</A></H2>
<P>
You can execute a program from any of the source windows (Source, Mixed,
or Disassembly) using step
commands or the Run command.
<DL>
<P><DT><B>Step commands
</B><DD>
Step commands control the execution of the program.
The step commands are located on the tool bar of the source windows and
under the
<B>Run</B> menu of the source windows.
<P><DT><B>Run command
</B><DD>
The Run command runs the program until a breakpoint is encountered, the
program is
halted, or the program ends.
You can start the Run command from the
<B>Run</B> button located on the tool bar or the
<B>Run</B> menu of the source windows.
<P>
When you execute a program, a clock icon is displayed to indicate that
the program is running and that the
program might require input to continue to the next breakpoint or
termination of the program.
</DL>
<HR>
<H1><A NAME="Header_46" HREF="#ToC_46">Monitors Windows</A></H1>
<P>
To open Monitors windows, from the
<B>Monitors</B> menu of the Debug Session
Control window, click any of the following choices:
<UL COMPACT>
<LI>Call stack
<LI>Registers
<LI>Storage
<LI>Local variables
<LI>Memory usage
</UL>
<P>
These windows are also accessible from the tool bar of the source
windows.
See <A HREF="#HDRTOOL">"Using the Tool Buttons"</A>
for information about the tool bar.
<HR>
<H2><A NAME="Header_47" HREF="#ToC_47">Viewing Active Functions for a Particular Thread</A></H2>
<P>
You can view all of the active functions for a particular thread
including system calls from the Call Stack
window.
<P>
To display the Call Stack window, click Call stack (located within the
<B>Monitors</B> menu) or click the <B>Call Stack</B>
button
<B><IMG SRC="icon8.jpg" ALT="* Figure icon8 not displayed."></B>
located on the tool bar.
<P><B><A NAME="Figure_14">Figure 14. Call Stack Window</A></B><BR>
<B><BR><CENTER><IMG SRC="jvcstk.jpg" ALT="* Figure jvcstk not displayed."></CENTER><BR></B><BR>
<P>
Each Call Stack window displays call stack information for only one
thread. When the state of the program
changes, such as when you execute the program or you update displayed
data, the Call Stack window
changes to reflect the current state.  You can double-click any call
stack entry to display the source code for
that entry.  The line that calls the next stack entry is selected.
The remaining stack size shows the bytes left
in the stack for the thread.
<P><B>Note: </B>The stack might not be displayed correctly if the code does not
follow standard calling conventions, or
if you step into optimized code.
<P>
<H4><A NAME="Header_48" HREF="#ToC_48">Menus</A></H4>
<P>
From the menus of the Call Stack window you can:
<UL COMPACT>
<LI>Save the contents of the Call Stack window in a file.
Choose the file name by clicking <B>Options</B> and
then <B>Display style</B>.
Enter the file name in the <B>Save file</B>
field.
<LI>End the debugging session.
<LI>Select the type of information displayed in the window and choose how
items are displayed.
<LI>Reset all your window settings to their original settings.
<LI>Enable or disable the tool bar.
<LI>Select whether you want hover help to be shown.
<LI>Select to display the information area in the window.
<LI>View a list of open windows and select a window from the list to
display it.
<LI>Display help.
</UL>
<P><B>Note: </B>If you need help with any of the menus, press F1 while the menu
is selected.
<HR>
<H2><A NAME="Header_49" HREF="#ToC_49">Viewing Registers for a Particular Native Thread</A></H2>
<P>
You can view all the processor registers for a particular native thread
from the Registers window. Registers
can not be viewed for a Java thread.
<P>
To display the processor registers and flags, click
<B>Registers</B> (located
within the <B>Monitors</B> menu) or click the
<B>Registers</B> button
<B><IMG SRC="icon9.jpg" ALT="* Figure icon9 not displayed."></B>
located on the tool bar.
<P><B><A NAME="Figure_15">Figure 15. Registers Window</A></B><BR>
<B><BR><CENTER><IMG SRC="jvregw.jpg" ALT="* Figure jvregw not displayed."></CENTER><BR></B><BR>
<P>
The contents of all of the registers except floating-point registers are
displayed in hexadecimal.
Registers that change after a run or a step are highlighted.
To update a
register, double-click the register and a multiple-line field is
displayed.  Type over the contents and press
<B>Enter</B>. If you decide not to change the value,
press <B>Esc</B>.
<P>
In the Registers window, floating-point registers are displayed as
floating-point decimal numbers.  They can
be updated with a floating-point decimal number or with a hexadecimal
string that represents a
floating-point number.
<P>
<H4><A NAME="Header_50" HREF="#ToC_50">Menus</A></H4>
<P>
From the menus of the Registers window you can:
<UL COMPACT>
<LI>End the debugging session.
<LI>Select the font to be displayed in the window, select the items you
want displayed in the window, restore
the defaults, and enable or disable the tool bar.
<LI>Reset all your window settings to their original settings.
<LI>Enable or disable the tool bar.
<LI>Select whether you want hover help to be shown.
<LI>Select to display the information area in the window.
<LI>View a list of open windows and select any open window to display
that window.
<LI>Display help.
</UL>
<P><B>Note: </B>If you need help with any of the menus, press F1 while the menu is
selected.
<P>
<H4><A NAME="Header_51" HREF="#ToC_51">Drag-and-Drop Function</A></H4>
<P>
The Registers window can be used as a source or a target for
drag-and-drop operations.  All register values
that are dragged and dropped are treated as hex numbers.
The register will be updated with the value from the drag operation.
<P>
See <A HREF="#HDRUSEDAD">"Using the Drag-and-Drop Function"</A> for more information
about the drag-and-drop
function.
<HR>
<H2><A NAME="Header_52" HREF="#ToC_52">Viewing Storage Contents and Addresses</A></H2>
<P>
The Storage window shows the storage contents and the address of the
storage.
<P>
To display the Storage window, click <B>Storage</B>
(located within the <B>Monitors</B> menu)
or click the <B>Storage</B> button
<B><IMG SRC="icon11.jpg" ALT="* Figure icon11 not displayed."></B>
located on the tool bar of the source view for a native thread.
<P><B>Note: </B>Storage can not be viewed for a Java thread.
<P><B><A NAME="Figure_16">Figure 16. Storage Window</A></B><BR>
<B><BR><CENTER><IMG SRC="jvstgw.jpg" ALT="* Figure jvstgw not displayed."></CENTER><BR></B><BR>
<P>
Multiple storage windows can display the same storage.  When you run a
program or update displayed data,
the Storage window is updated to reflect the change.
<P>
To update the storage contents and all affected windows, double-click in
the multiple-line field that is
displayed.  Type over the contents of the field. If you decide not to
make the change, press <B>Esc</B>.
<P>
To specify a new address location, type over the address field in the
Storage window.  The window scrolls to
the appropriate storage location.
<P>
<H4><A NAME="Header_53" HREF="#ToC_53">Menus</A></H4>
<P>
From the menus of the Storage window you can:
<UL COMPACT>
<LI>Save the contents of the Storage window in a file.
Choose the file name by clicking <B>Options</B>
and then <B>Display style</B>.
Type the file name in the <B>Save file</B> field.
<LI>End the debugging session.
<LI>From the <B>Options</B> menu you can:
<OL COMPACT>
<LI>Select the font to be displayed in the window.
<LI>Select the items you want displayed in the window.
<LI>Restore the defaults.
<LI>Enable or disable the tool bar.
<LI>Fill memory with a specific character or hexadecimal pattern.
<LI>Identify the expression you want to monitor.
<P>
The expression evaluator used is based on the context.  For example,
if you display the Storage
window by clicking <B>Monitor expression</B> located
within the <B>Monitors</B> menu,
the evaluator used is
based on the context in the Monitor Expression window.  However,
if you display the Storage
window first and then click <B>Monitor expression</B>
located within the
<B>Options</B> menu of the Storage
window, the evaluator used is based on the context of the stopping
thread.
<P><B>Note: </B>You cannot look at variables that have been defined using the
#DEFINE preprocessor
directive.  If the variable is not in scope when the monitor is opened,
the default address is
displayed.  If the variable goes out of scope, the address is changed
to a hex constant.
<P>
If you select the <B>Enabled monitor</B> check box,
the monitor updates the
stop value of the program to
the actual value in storage.  However, a disabled monitor suspends this
updating and reflects the
stop value or the value held when the monitor was disabled.
</OL>
<LI>Reset all your window settings to their original settings.
<LI>Enable or disable the tool bar.
<LI>Select whether you want hover help to be shown.
<LI>Select to display the information area in the window.
<LI>View a list of open windows and select any open window to display
that window.
<LI>Display help.
</UL>
<P><B>Note: </B>If you need help with any of the menus, press F1 while the menu
is selected.
<P>
<H4><A NAME="Header_54" HREF="#ToC_54">Drag-and-Drop Function</A></H4>
<P>
The Storage window can be used as a source or a target for drag-and-drop
operations.  The item that is
dragged is the item in the column under the mouse.  You cannot drag a
portion of the column.  When items
are dropped in the address portion of the Storage window, the Storage
window adjusts to show memory at
this new address.  When items are dropped in the content fields of the
Storage window, the item in the
column under the mouse is updated. Columns that display hex values can
have only hex values dropped on
them. Columns that display strings can have only strings dropped on them.
<P>
See <A HREF="#HDRUSEDAD">"Using the Drag-and-Drop Function"</A> for more information
about the drag-and-drop
function.
<HR>
<H2><A NAME="Header_55" HREF="#ToC_55">Monitoring Local Variables</A></H2>
<P>
You can monitor the local variables (static, automatic, and parameter)
for the current execution point in the
program from the Local Variables window. The contents of the
Local Variables window change each time
your program enters or leaves a function.
<P>
To display the Local Variables window, click <B>Local variables</B>
(located within the <B>Monitors</B> menu).
<P><B><A NAME="Figure_17">Figure 17. Local Variables Window</A></B><BR>
<B><BR><CENTER><IMG SRC="jvlvw.jpg" ALT="* Figure jvlvw not displayed."></CENTER><BR></B><BR>
<P>
<H4><A NAME="Header_56" HREF="#ToC_56">Menus</A></H4>
<P>
From the menus of the Local Variables window you can:
<UL COMPACT>
<LI>End the debugging session.
<LI>Delete, select, deselect, show other elements,
or change representation of the variables.  You can copy
the selected local variable data to the clipboard.
You can also save the Local Variables window contents in a file.
Select <B>Options</B>, <B>Debugger settings</B>,
and then <B>Monitor properties</B> from the Debug Session
Control window or any of the source windows
and enter the file name in the <B>Save file</B> field.
<LI>Control how the contents of variables display and set debugger options.
<LI>View a list of open windows and select any open window to display that
window.
<LI>Display help.
</UL>
<P><B>Note: </B>If you need help with any of the menus, press F1 while the menu is
selected.
<HR>
<H2><A NAME="Header_57" HREF="#ToC_57">Viewing Memory Usage</A></H2>
<P>
The Memory Usage window is used to display a summary of memory usage for
your Java program being
debugged.  This window shows the amount of free and used memory for the
Java program.
<P>
To display the Memory Usage window, select <B>Memory usage</B>
(located within the <B>Monitors</B> menu) or select the
Memory Usage button
<B><IMG SRC="memuse.jpg" ALT="* Figure memuse not displayed."></B>
from the tool bar.
<P><B><A NAME="Figure_18">Figure 18. Memory Usage Window</A></B><BR>
<B><BR><CENTER><IMG SRC="jvmemu.jpg" ALT="* Figure jvmemu not displayed."></CENTER><BR></B><BR>
<P>
<H4><A NAME="Header_58" HREF="#ToC_58">Menus</A></H4>
<P>From the menus of the Memory Usage window you can:
<UL COMPACT>
<LI>End the debugging session.
<LI>Select the font to be displayed in the window, restore the defaults,
and enable or disable the tool bar.
<LI>Reset all your window settings to their original settings.
<LI>Enable or disable the tool bar.
<LI>Select whether you want hover help to be shown.
<LI>Select to display the information area in the window.
<LI>View a list of open windows and select any open window to display that
window.
<LI>Display help.
</UL>
<P><B>Note: </B>If you need help with any of the menus, press F1 while the menu is
selected.
<HR>
<H2><A NAME="Header_59" HREF="#ToC_59">Monitoring Other Variables and Expressions</A></H2>
<P>
The debugger has four other windows that enable you to monitor variables
and expressions.  These windows are as follows:
<UL>
<P><LI>Popup Monitor
<P><LI>Program Monitor
<P><LI>Private Monitor
<P><LI>Storage Monitor
</UL>
<P>
A Popup Monitor window monitors single variables or expressions.  This
window is associated with a
specific source window and closes when the associated window closes.
<P>
The Program Monitor, Private Monitor, and Storage Monitor windows are
used as collectors for individual
variables or expressions that might be of interest to you.
<P>
The difference between the Private Monitor window and the Program Monitor
window is the length of time
that each remains open.  The Program Monitor window remains open for the
entire debugging session.  The
Private Monitor window is associated with the source window from which
it was opened and closes when its
associated view is closed.
<P>
<H4><A NAME="Header_60" HREF="#ToC_60">Drag-and-Drop Function</A></H4>
<P>
Monitor windows can be used as a source or a target for the
drag-and-drop operations.  You can drag either
the variable/expression or the value of a monitor.
<P><B>Note: </B>The context is not dragged with the monitor, so some
variables/expressions might not be accepted in
other windows.  When an item is dropped on a monitor item, that monitor
item is updated with the new
value.  When an item from the Source window is dragged onto a monitor in
white space, that
variable/expression is added to the monitor.  Adding
variables/expressions this way is supported only in the
Private and Program monitors.
<P>
See <A HREF="#HDRUSEDAD">"Using the Drag-and-Drop Function"</A> for more information
about the drag-and-drop
function.
<HR>
<H1><A NAME="Header_61" HREF="#ToC_61">Expressions Supported</A></H1>
<P>
This section describes the expressions supported by the debugger,
which is a subset of C++ and Java.
This includes the operands, operators, and data types.
<P><B>Note: </B>You can display and update bit fields for C++ code only.  You
cannot look at variables that have been
defined using the #DEFINE preprocessor directive.
<HR>
<H2><A NAME="Header_62" HREF="#ToC_62">Supported Expression Operands</A></H2>
<P>
You can monitor an expression that uses the following types of operands
only:
<BR>
<TABLE>
<TR>
<TD ALIGN=LEFT VALIGN=TOP WIDTH=2%><B>Operand</B>
</TD><TD ALIGN=LEFT VALIGN=TOP WIDTH=98%><B>Definition</B>
</TD></TR><TR>
<TD ALIGN=LEFT VALIGN=TOP WIDTH=2%><B>Variable</B>
</TD><TD ALIGN=LEFT VALIGN=TOP WIDTH=98%>A variable used in your program.
</TD></TR><TR>
<TD ALIGN=LEFT VALIGN=TOP WIDTH=2%><B>Constant</B>
</TD><TD ALIGN=LEFT VALIGN=TOP WIDTH=98%>
The constant can be one of the following types:
<UL>
<P><LI>Fixed or floating-point constant.
<P><B>Note: </B>The largest floating-point constant in C++ is 1.79E308.  The
smallest floating-point is 2.23E-308.
<P><LI>A string constant enclosed in quotation marks (" ").
<P><LI>A character constant enclosed in single quotation marks (' ').
</UL>
<BR></TD></TR><TR>
<TD ALIGN=LEFT VALIGN=TOP WIDTH=2%><B>Registers</B>
</TD><TD ALIGN=LEFT VALIGN=TOP WIDTH=98%>In the case of conflicting names, the program variable names take
precedence over the
register names.  For conversions that are done automatically when the
registers are
displayed in mixed-mode expressions, general-purpose registers are
treated as unsigned
arithmetic items with a length appropriate to the register.
</TD></TR></TABLE>
<P>
If you monitor an enumerated variable, a comment is displayed to the
right of the value.  If the value of the
variable matches one of the enumerated types, the comment contains the
name of the first enumerated type
that matches the value of the variable.  If the length of the enumerated
name does not fit in the monitor, the
contents are displayed as an empty field.
<P>
The comment (empty or not) lets you distinguish between a valid
enumerated value and a value that is not
valid.  A value that is not valid does not have a comment to the right
of the value.
<P>
You <I>cannot</I> update an enumerated variable by
entering an enumerated type.
You must enter a value or
expression.  If the value is a valid enumerated value, the comment to
the right of the value is updated.
<P>
Bit fields are supported for C++ compiled code only.  You can display
and update bit fields, but you cannot
use them in expressions.  You cannot look at variables that have been
defined using the #DEFINE preprocessor directive.
<HR>
<H2><A NAME="Header_63" HREF="#ToC_63">Supported Expression Operators</A></H2>
<P>
You can monitor an expression that uses the following operators only:
<BR>
<P><B><A NAME="Table_1">Table 1. Supported Expression Operators</A></B><BR>
<TABLE BORDER>
<TR>
<TH ALIGN=LEFT VALIGN=TOP WIDTH=50%><B>Operator</B>
</TH><TH ALIGN=LEFT VALIGN=TOP WIDTH=50%><B>Coded as</B>
</TH></TR><TR>
<TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><B>Subscripting</B>
</TD><TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><I>a</I>&#91;b&#93;
</TD></TR><TR>
<TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><B>Member selection</B>
</TD><TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><I>a.b</I> or <I>a-&gt;b</I>
(<I>a-&gt;b</I> for C/C++ only)
</TD></TR><TR>
<TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><B>Size</B>
</TD><TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><I>sizeof (a)</I> or <I>sizeof (type)</I>  (C++ only)
</TD></TR><TR>
<TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><B>Logical not</B>
</TD><TD ALIGN=LEFT VALIGN=TOP WIDTH=50%>!<I>a</I>
</TD></TR><TR>
<TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><B>One&#39;s complement</B>
</TD><TD ALIGN=LEFT VALIGN=TOP WIDTH=50%>&#126;<I>a</I>
</TD></TR><TR>
<TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><B>Unary minus</B>
</TD><TD ALIGN=LEFT VALIGN=TOP WIDTH=50%>-<I>a</I>
</TD></TR><TR>
<TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><B>Unary plus</B>
</TD><TD ALIGN=LEFT VALIGN=TOP WIDTH=50%>+<I>a</I>
</TD></TR><TR>
<TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><B>Dereference</B>
</TD><TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><I>*a</I>  (C/C++ only)
</TD></TR><TR>
<TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><B>Type cast</B>
</TD><TD ALIGN=LEFT VALIGN=TOP WIDTH=50%>(<I>type</I>) <I>a</I>
</TD></TR><TR>
<TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><B>Multiply</B>
</TD><TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><I>a</I> * <I>b</I>
</TD></TR><TR>
<TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><B>Divide</B>
</TD><TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><I>a</I> / <I>b</I>
</TD></TR><TR>
<TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><B>Modulo</B>
</TD><TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><I>a</I> % <I>b</I>
</TD></TR><TR>
<TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><B>Add</B>
</TD><TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><I>a</I> + <I>b</I>
</TD></TR><TR>
<TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><B>Subtract</B>
</TD><TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><I>a</I> - <I>b</I>
</TD></TR><TR>
<TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><B>Left shift</B>
</TD><TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><I>a</I> &lt;&lt; <I>b</I>
</TD></TR><TR>
<TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><B>Right shift</B>
</TD><TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><I>a</I> &gt;&gt; <I>b</I>
</TD></TR><TR>
<TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><B>Instance of</B>
</TD><TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><I>a</I> instanceof <I>b</I> (Java only)
</TD></TR><TR>
<TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><B>Less than</B>
</TD><TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><I>a</I> &lt; <I>b</I>
</TD></TR><TR>
<TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><B>Greater than</B>
</TD><TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><I>a</I> &gt; <I>b</I>
</TD></TR><TR>
<TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><B>Less than or equal to</B>
</TD><TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><I>a</I> &lt;= <I>b</I>
</TD></TR><TR>
<TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><B>Greater than or equal to</B>
</TD><TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><I>a</I> &gt;= <I>b</I>
</TD></TR><TR>
<TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><B>Equal</B>
</TD><TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><I>a</I> == <I>b</I>
</TD></TR><TR>
<TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><B>Not equal</B>
</TD><TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><I>a</I> != <I>b</I>
</TD></TR><TR>
<TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><B>Bitwise AND</B>
</TD><TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><I>a</I> &amp; <I>b</I>
</TD></TR><TR>
<TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><B>Bitwise OR</B>
</TD><TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><I>a</I> &#124; <I>b</I>
</TD></TR><TR>
<TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><B>Bitwise exclusive OR</B>
</TD><TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><I>a</I> &#94; <I>b</I>
</TD></TR><TR>
<TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><B>Logical AND</B>
</TD><TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><I>a</I> &amp;&amp; <I>b</I>
</TD></TR><TR>
<TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><B>Logical OR</B>
</TD><TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><I>a</I> &#124;&#124; <I>b</I>
</TD></TR><TR>
<TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><B>Unsigned Right Shift</B>
</TD><TD ALIGN=LEFT VALIGN=TOP WIDTH=50%><I>a &gt; &gt; &gt; b</I>  (Java only)
</TD></TR></TABLE>
<HR>
<H2><A NAME="Header_64" HREF="#ToC_64">Supported Data Types</A></H2>
<P>
<H3><A NAME="Header_65" HREF="#ToC_65">C/C++</A></H3>
<P>
You can monitor an expression that uses the following data types:
<UL COMPACT>
<LI>8-bit signed byte
<LI>8-bit unsigned byte
<LI>16-bit signed integer
<LI>16-bit unsigned integer
<LI>32-bit signed integer
<LI>32-bit unsigned integer
<LI>32-bit floating-point number
<LI>64-bit floating-point number
<LI>128-bit floating-point number
<LI>Pointers
<LI>User-defined types
<LI>Structures/unions
<LI>Arrays
<LI>Classes (C++ only)
<LI>Enums
</UL>
<P>
<H3><A NAME="Header_66" HREF="#ToC_66">Java</A></H3>
<P>
You can monitor an expression that uses the following data types:
<UL COMPACT>
<LI>Boolean
<LI>8-bit signed byte
<LI>16-bit character
<LI>16-bit signed integer
<LI>32-bit signed integer
<LI>32-bit floating-point number
<LI>64-bit floating-point number
<LI>Null reference
<LI>Object reference
<LI>Array reference
</UL>
<HR>
<H1><A NAME="Header_67" HREF="#ToC_67">Notices</A></H1>
<P>
Second Edition (July, 1999)
<P>
The following paragraph does not apply to the United Kingdom or any
country where such provisions are
inconsistent with local law:
<P>
INTERNATIONAL BUSINESS MACHINES CORPORATION PROVIDES THIS PUBLICATION
"AS
IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING,
BUT
NOT  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS
FOR A
PARTICULAR PURPOSE.
<P>
Some states do not allow disclaimer of express or implied warranties in
certain transactions, therefore, this
statement may not apply to you.
<P>
This publication could include technical inaccuracies or typographical
errors.  Changes are periodically
made to the information herein; these changes will be incorporated in
new editions of the publication.  IBM
may make improvements and/or changes in the product(s) and/or the
program(s) described in this
publication at any time.
<P>
This publication was developed for products and services offered in the
United States of America.  IBM
may not offer the products, services, or features discussed in this
document in other countries, and the
information is subject to change without notice.  Consult your local
IBM representative for information on
the products, services, and features available in your area.
<P>
Requests for technical information about IBM products should be made
to your IBM reseller or IBM
marketing representative.
<HR>
<H2><A NAME="Header_68" HREF="#ToC_68">Copyright Notices</A></H2>
<P>&copy; Copyright International Business Machines Corporation 1997, 1999.
All rights reserved.
<P>
Note to U.S. Government Users: Documentation related to restricted
rights - use, duplication or disclosure is
subject to restrictions set forth in GSA ADP Schedule Contract with
IBM Corp.
<HR>
<H2><A NAME="Header_69" HREF="#ToC_69">Disclaimers</A></H2>
<P>
References in this publication to IBM products, programs, or services do
not imply that IBM intends to
make these available in all countries in which IBM operates.  Any
reference to an IBM product, program or
service is not intended to state or imply that only that IBM product,
program, or service may be used.
Subject to IBM&#39;s valid intellectual property or other legally
protectable rights, any functionally equivalent
product, program, or service may be used instead of the IBM product,
program, or service.  The evaluation
and verification of operation in conjunction with other products,
except those expressly designated by IBM,
are the responsibility of the user.
<P>
IBM may have patents or pending patent applications covering subject
matter in this document.  The
furnishing of this document does not give you any license to these
patents.  You can send license inquiries,
in writing, to:
<PRE>
IBM Director of Licensing
IBM Corporation
North Castle Drive
Armonk, NY  10504-1785
U.S.A.
</PRE>
<P>
Asia-Pacific users can inquire, in writing, to the IBM Director of
Intellectual Property and Licensing, IBM
World Trade Asia Corporation, 2-31 Roppongi 3-chome, Minato-ku, Tokyo
106, Japan.
<P>
Licensees of this program who wish to have information about it for the
purpose of enabling: (i) the
exchange of information between independently created programs and other
programs (including this one)
and (ii) the mutual use of the information which has been exchanged,
should contact IBM Corporation,
Department LZKS, 11400 Burnet Road, Austin, TX 78758 U.S.A.  Such
information may be available,
subject to appropriate terms and conditions, including in some cases,
payment of a fee.
<HR>
<H2><A NAME="Header_70" HREF="#ToC_70">Trademarks</A></H2>
<P>
The following terms are trademarks of the IBM Corporation in the United
States or other countries or both:
<PRE>
IBM
OS/2
</PRE>
<P>
Intel and Pentium are registered trademarks of the Intel Corporation.
<P>
Java is a trademark or registered trademark of Sun Microsystems, Inc.
in the United States and other
countries, and is used under license.
<P>
Other company, product, and service names may be trademarks or service
marks of others.
<A NAME=Bot_Of_Page></A>
</BODY></HTML>
