home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / icat.zip / HTM.ZIP / icat.inf (.txt) < prev    next >
OS/2 Help File  |  2001-02-03  |  88KB  |  3,241 lines
  1.  
  2. ΓòÉΓòÉΓòÉ 1. The ICAT Debugger ΓòÉΓòÉΓòÉ
  3.  
  4. The IBM Interactive Code Analysis Tool (ICAT) Debugger is used for debugging 
  5. OS/2 device drivers, kernel code, Installable File Systems (IFS), and 
  6. applications that are running on an OS/2 Warp Version 4 remote machine. The 
  7. debugger helps you detect and diagnose errors in code written in C, C++, and 
  8. assembler languages at the source level. 
  9.  
  10.  
  11. ΓòÉΓòÉΓòÉ 1.1. What is the ICAT Debugger ΓòÉΓòÉΓòÉ
  12.  
  13. The ICAT Debugger (hereafter referred to in this document as the debugger) is a 
  14. source-level debugger which uses OS/2 Warp 3.0, OS/2 Warp Connect, or OS/2 Warp 
  15. Version 4 to assist in detecting and diagnosing errors in an OS/2 Warp Version 
  16. 4 system. It provides a graphical user interface and debugs PM and non-PM 
  17. (single- or multi-threaded) applications as well as device drivers and other 
  18. system-level binaries. 
  19.  
  20. This debugger has been designed to debug remotely an OS/2 Warp Version 4 
  21. system. The Kernel Debugger (KDB) runs on a victim OS/2 Warp Version 4 machine 
  22. and replies to debug service requests that are sent from the debugger while 
  23. running on an Intel-based OS/2 Warp 3.0, OS/2 Warp Connect, or OS/2 Warp 
  24. Version 4 machine. The supported communication mode between machines is serial. 
  25.  
  26. Supported debug file formats include HLL (which is IBM VisualAge C++ (VACPP)) 
  27. and CodeView (CV). 
  28.  
  29.  
  30. ΓòÉΓòÉΓòÉ 1.2. Before You Begin ΓòÉΓòÉΓòÉ
  31.  
  32. This section lists the hardware and software requirements, considerations you 
  33. need to be aware of, compiling and linking options, environment variables, 
  34. limitations, helpful tips, and a demo to help get you started. 
  35.  
  36.  
  37. ΓòÉΓòÉΓòÉ 1.2.1. Hardware Requirements ΓòÉΓòÉΓòÉ
  38.  
  39. The debugger must be run on an Intel-based system capable of running OS/2 Warp 
  40. 3.0, OS/2 Warp Connect, or OS/2 Warp Version 4. Slightly less than 11 megabytes 
  41. of disk space is required to install the debugger.  We recommend that you run 
  42. with at least a 486SX processor for performance reasons. 
  43.  
  44.  
  45. ΓòÉΓòÉΓòÉ 1.2.2. Software Requirements ΓòÉΓòÉΓòÉ
  46.  
  47. There are software requirements for both the victim machine where the programs 
  48. are debugged and run and the host machine where the debugger runs. 
  49.  
  50. To set up the victim OS/2 machine: 
  51.  
  52.    1. Obtain or build an OS2KRNLD that has the debugger packet-handling code. 
  53.       This code is now part of the regular KDB builds. 
  54.    2. OS2KRNL is in the root directory of the victim system's boot drive but is 
  55.       hidden.  Use the following command to make it visible: 
  56.  
  57.                attrib -r -s -h os2krnl
  58.  
  59.       Use the following commands to back up the file and replace it with its 
  60.       debug equivalent: 
  61.  
  62.                copy os2krnl  os2krnl.bak
  63.                copy os2krnld os2krnl
  64.  
  65.  To set up the host OS/2 machine: 
  66.  
  67.    1. Unzip the ICATMERL.ZIP file into the directory where you want to run the 
  68.       debugger.  This file contains the debugger, the victim sample binaries, 
  69.       and the original source files. 
  70.    2. Set the environment variables.  Refer to Setting Environment Variables 
  71.       for more information. 
  72.  
  73.  
  74. ΓòÉΓòÉΓòÉ 1.2.3. Compiling and Linking Your Program ΓòÉΓòÉΓòÉ
  75.  
  76. Before using the debugger, you need to compile and link your program. 
  77.  
  78. For VACPP programs, use the following options: 
  79.  
  80.  /Ti+        Compiles your program to produce an object file that includes line 
  81.              number information and a symbol table in addition to the source 
  82.              code. 
  83.  
  84.  /O-         Compiles your program with optimization off. This is the default. 
  85.  
  86.  /Oi-        Compiles your program with inlining off.  This is the default. 
  87.  
  88.  /DEbug      Links your program to produce an executable file that includes 
  89.              line number information and a symbol table in addition to the 
  90.              executable code. 
  91.  
  92.              Note:  When you specify the /Ti+ option with the /DEbug option, 
  93.              icc passes this option to the linker automatically, so you only 
  94.              need to use it if you link separately from the compile. 
  95.  
  96.  For more information about compiling and linking your program, refer to IBM 
  97.  C++ Tools Programming Guide. 
  98.  
  99.  For Microsoft CL, CL386, MASM, and MASM386 programs, use the following 
  100.  options: 
  101.  
  102.  /Zi         Compiles your program to produce an object file that includes line 
  103.              number information and a symbol table, in addition to the source 
  104.              code. 
  105.  
  106.  /Od         Compiles your program with optimization off. 
  107.  
  108.  /CO         Links your program to produce an executable file that includes 
  109.              line number information and a symbol table in addition to the 
  110.              executable code. 
  111.  
  112.  For Watcom wpp386 programs, use the following options: 
  113.  
  114.  -d2         Compiles your program with full debugging information. 
  115.  
  116.  -hc         Compiles your program emitting CodeView debug format (currently, 
  117.              the debugger only supports Watcom's CodeView debug format). 
  118.  
  119.  -od         Compiles your program with optimization off. 
  120.  
  121.  For the Watcom linker, wlink, use this option: 
  122.  
  123.  d codeview  Links your program with CodeView debug format. 
  124.  
  125.  The debugger supports a separate debug file (from your created application) 
  126.  for the Watcom compiler.  For the Watcom linker, wlink, use this option to 
  127.  create a separate debug file if desired: 
  128.  
  129.  op symf 
  130.  
  131.  This will create a .sym file.  Be careful not to confuse this file with a KDB 
  132.  .sym file.  The debugger looks for debug information first in the application 
  133.  file.  If it doesn't find it, it looks for the debug information in a .dbg 
  134.  file and then in a .sym file as a last resort.  Most users rename the separate 
  135.  Watcom .sym file to a .dbg file. 
  136.  
  137.  
  138. ΓòÉΓòÉΓòÉ 1.2.4. Setting Environment Variables ΓòÉΓòÉΓòÉ
  139.  
  140. The debugger uses environment variables to manage debugging sessions and remote 
  141. communications. To set the environmental variables, you will need to edit the 
  142. SETICAT.CMD file. The environment variables should be set in the OS/2 session 
  143. where the debugger is to be run.  The environment variables are as follows: 
  144.  
  145.  CAT_MACHINE 
  146.            Specifies which host com port the debugger uses to communicate with 
  147.            KDB and the baud rate for communications.  This variable has the 
  148.            following form: 
  149.  
  150.                          COMx:nnnn
  151.            where x identifies the port (for example, 1 for COM1) and nnnn 
  152.            specifies the baud rate.  The following rates are supported: 
  153.  
  154.                9600 (the default) 
  155.                19200 
  156.                38400 
  157.                57600 
  158.                115200 
  159.  
  160.            For speeds above 19200, you need buffered UARTs on both the host and 
  161.            victim machines.  For speeds above 57600, you need customized serial 
  162.            drivers such as SIO.SYS or the COM.SYS that ships with Warp Version 
  163.            4 (which can also be used with earlier versions of Warp). 
  164.  
  165.            For example, type the following at the command prompt: 
  166.  
  167.                          set CAT_MACHINE=COM2:57600
  168.  
  169.            Note:  Ensure that your communication port is enabled if you use a 
  170.            ThinkPad. 
  171.  
  172.  CAT_SETUP_RATE 
  173.            When the debugger first attempts to communicate with KDB, it does so 
  174.            at the baud rate specified by this environment variable or at 9600 
  175.            baud if this variable is not defined.  If the communication 
  176.            succeeds, the debugger changes the baud rate to the rate specified 
  177.            by the CAT_MACHINE environment variable and proceeds.  Otherwise, 
  178.            the debugger tries to  initiate contact at the rate specified by the 
  179.            CAT_MACHINE environment variable.  If neither attempt succeeds, the 
  180.            debugger issues an error message. 
  181.  
  182.            In most cases, you do not need to set CAT_SETUP_RATE.  It is 
  183.            primarily useful if you have been communicating with the victim 
  184.            system directly (for example, using ZOC or T) and have left the 
  185.            serial line running at a rate other than 9600 baud that does not 
  186.            match the rate specified by the CAT_MACHINE environment variable. 
  187.  
  188.            Additionally, if this environment variable is set, the debugger will 
  189.            reset KDB to this rate when the debugger is closed. 
  190.  
  191.            For example, type the following at the command prompt: 
  192.  
  193.                          set CAT_SETUP_RATE=9600
  194.  
  195.  CAT_HOST_BIN_PATH 
  196.            Tells the debugger where to find your debug binaries (the .SYS and 
  197.            .EXE files with debug information) on your host system. 
  198.  
  199.            For example, type the following at the command prompt: 
  200.  
  201.                          set CAT_HOST_BIN_PATH=I:\SDE\SAMDETW
  202.  
  203.  CAT_COMMUNICATION_TYPE 
  204.            Allows asynchronous communications. Currently, this must be set to 
  205.            ASYNC_SIGBRK in subsequent releases it is planned to support other 
  206.            forms of communication. 
  207.  
  208.            For example, type the following at the command prompt: 
  209.  
  210.                          set CAT_COMMUNICATION_TYPE=ASYNC_SIGBRK
  211.  
  212.  CAT_HOST_SOURCE_PATH 
  213.            Tells the debugger where to find the source files that were used to 
  214.            build your debug binaries. See Finding Source Files for more 
  215.            details. 
  216.  
  217.            For example, type the following at the command prompt: 
  218.  
  219.                          set CAT_HOST_SOURCE_PATH=I:\SDE\SAMDETW;E:\icat\testcases\src
  220.  
  221.  CAT_PATH_RECURSE 
  222.            Causes a recursive search of the subdirectories below the 
  223.            subdirectories listed in CAT_HOST_BIN_PATH and CAT_HOST_SOURCE_PATH. 
  224.            For example, with the CAT_HOST_SOURCE_PATH=i\sde\samdetw variable, 
  225.            the debugger will search the samdetw subdirectory and all 
  226.            subdirectories below samdetw as well as their subdirectories.  The 
  227.            default is NULL, which means the debugger will not perform a 
  228.            recursive search. When the variable is set to any non-null value, 
  229.            the recursive search is performed. 
  230.  
  231.            For example, type the following at the command prompt: 
  232.  
  233.            set CAT_PATH_RECURSE=ON 
  234.  
  235.  CAT_MODULE_LIST 
  236.            By default, the debugger obtains information about every executable 
  237.            module (DLL, EXE, device driver, and so on) running on the victim 
  238.            system.  As a result, it can take several minutes to attach to the 
  239.            victim system.  If the CAT_MODULE_LIST environment variable is 
  240.            defined, the debugger only obtains information about a module if its 
  241.            name appears in the environment variable string.  (The debugger 
  242.            always obtains information about the kernel itself.)  This can 
  243.            dramatically reduce the amount of time it takes for the debugger to 
  244.            come up. 
  245.  
  246.            For example, type the following at the command prompt: 
  247.  
  248.                           set CAT_MODULE_LIST=SAMPLEDD.SYS SAMPLE.EXE
  249.  
  250.            The debugger will only obtain information on the kernel and the two 
  251.            modules listed in CAT_MODULE_LIST.  (If a program named LE.EXE were 
  252.            running, the debugger would also obtain information on it since 
  253.            LE.EXE is a substring of SAMPLE.EXE.) 
  254.  
  255.  CAT_RESUME 
  256.            During debugger initialization, the debugger stops the victim system 
  257.            in order to establish the desired baud rate.  The debugger then 
  258.            continues its initialization and eventually allows the user to 
  259.            attach to the victim system.  By default, the debugger does not 
  260.            allow the victim system to resume execution during this interval. 
  261.            This behavior is necessary to debug a system that has already 
  262.            reached a failure or that contains a hardcoded INT3 instruction (as 
  263.            device drivers often do). 
  264.  
  265.            There could be situations where you want to initialize the debugger, 
  266.            but somehow time your attach to the victim system using the Attach 
  267.            push button.  In this case, define CAT_RESUME, and then the debugger 
  268.            will resume the victim system waiting for your attach command to 
  269.            stop it again. 
  270.  
  271.            For example, type the following at the command prompt: 
  272.  
  273.                          set CAT_RESUME=ON
  274.  
  275.  CAT_DIAL and CAT_MODEM_INIT 
  276.            The host and victim machines can be connected directly (with a null 
  277.            modem serial cable) or by way of modem.  If either of these 
  278.            variables is defined, the debugger sets up the COM port specified by 
  279.            the CAT_MACHINE environment variable so that the debugger can talk 
  280.            to a modem. The debugger then issues the modem attention string 
  281.            (+++) followed by the string specified by the CAT_MODEM_INIT 
  282.            variable (if any) to initialize the modem.  The debugger then issues 
  283.            the string specified by the CAT_DIAL variable (if any) and waits 500 
  284.            seconds for the remote modem to answer. 
  285.  
  286.            The CAT_MODEM_INIT environment variable should be based on the 
  287.            string your terminal emulator uses to initialize the modem. This 
  288.            string presumably doesn't change very often.  Once you have 
  289.            determined the correct AT commands, you can keep the CAT_MODEM_INIT 
  290.            environment variable constant and change CAT_DIAL when you need to 
  291.            place calls to different numbers. 
  292.  
  293.            For example, type the following at the command prompt: 
  294.  
  295.                          set CAT_MODEM_INIT=ATZ
  296.                          set CAT_DIAL=ATDT4840
  297.  
  298.  CAT_OVERRIDE 
  299.            Specifies a path that the debugger searches first to find the source 
  300.            files that were used to build your debug binaries.  See "Finding 
  301.            Source Files" below for a complete description of the process. 
  302.  
  303.            For example, type the following at the command prompt: 
  304.  
  305.                          set CAT_OVERRIDE=e:\temp\updates
  306.  
  307.  CATTAB 
  308.            Specifies the number of spaces between tab stops when source code 
  309.            containing tabs is displayed in a debugger window. 
  310.  
  311.            For example, type the following at the command prompt: 
  312.  
  313.                          set CATTAB=5
  314.  
  315.            The debugger will convert each tab in the source to 5 spaces when 
  316.            the source is displayed. 
  317.  
  318.  CATTABGRID 
  319.            Specifies the column positions for the tab stops when source code 
  320.            containing tabs is displayed in a debugger window. 
  321.  
  322.            For example, typing the following command at the command prompt sets 
  323.            tab stops at the 6th position: 
  324.  
  325.                          set CATTABGRID=6
  326.  
  327.  DEBUG_NUMBEROFELEMENTS 
  328.            DEBUG_NUMBEROFELEMENTS is an environment variable that is set to an 
  329.            integer, n. This integer represents the default number of elements 
  330.            displayed for a variable or structure that has a substantial number 
  331.            of elements. The last element displayed for such a structure is 
  332.            labeled "more elements." Clicking on this entry will display the 
  333.            next n elements of the variable or structure. 
  334.  
  335.            For example, type the following at the command prompt: 
  336.  
  337.                          set DEBUG_NUMBEROFELEMENTS=100
  338.  
  339.            The next 100 elements are displayed. 
  340.  
  341.  
  342. ΓòÉΓòÉΓòÉ 1.2.5. Finding Source Files ΓòÉΓòÉΓòÉ
  343.  
  344. The search path tells the debugger where to find the source file used in the 
  345. source windows. The debugger searches for the source files in the following 
  346. order: 
  347.  
  348.    1. The path defined by the CAT_OVERRIDE environment variable, if specified. 
  349.  
  350.    2. The directory where the object file was compiled. 
  351.  
  352.    3. The path defined by the CAT_HOST_BIN_PATH environment variable, if 
  353.       specified. 
  354.  
  355.    4. The directory where the executable file is located. 
  356.  
  357.    5. The path defined by the CAT_HOST_SOURCE_PATH environment variable, if 
  358.       specified. 
  359.  
  360.    6. The current directory. 
  361.  
  362.    7. The path defined in the INCLUDE environment variable. 
  363.  
  364.    8. The directory of the last source file found in this debug session. 
  365.  
  366.  Note:  The CAT_PATH_RECURSE environment variable, if specified, will cause the 
  367.  debugger to search recursively all subdirectories of the CAT_HOST_BIN_PATH and 
  368.  CAT_HOST_SOURCE_PATH environment variables. 
  369.  
  370.  
  371. ΓòÉΓòÉΓòÉ 1.2.6. Limitations ΓòÉΓòÉΓòÉ
  372.  
  373. The debugger has the following restriction: 
  374.  
  375.      You can not launch an application with the debugger.  You can only attach 
  376.       to the OS/2 Warp Version 4 system. 
  377.  
  378.  The victim system communicates over COM2 if COM2 exists and over COM1 
  379.  otherwise.  The COM port the victim system uses must not be usurped by an 
  380.  application.  For example, if the victim system is using COM2 and you issue 
  381.  the following command: 
  382.  
  383.      mode com2
  384.  
  385.  you may disrupt communications.  The device driver and executables associated 
  386.  with the IBM LAN Management Utilities (for example, LMUIPL.SYS) can also 
  387.  prevent the victim system from communicating. 
  388.  
  389.  Similarly, the COM port the host system uses must be dedicated to the 
  390.  debugger.  If the debugger fails to attach, make sure you're not running a 
  391.  terminal emulator (for example, T or ZOC) in the background that has the COM 
  392.  port tied up. 
  393.  
  394.  Currently, there are limitations with C++ support for the Watcom compiler. 
  395.  The debugger does not support mangled names from the Watcom compiler.  This 
  396.  can show up when the debugger can not find certain functions (external 
  397.  functions and overloaded member functions) or sets function breakpoints. 
  398.  
  399.  
  400. ΓòÉΓòÉΓòÉ 1.2.7. Helpful Tips and Hints ΓòÉΓòÉΓòÉ
  401.  
  402. The following are tips and hints that may be helpful: 
  403.  
  404.      You must have OS/2 WARP 3.0, OS/2 Warp Connect, or OS/2 Warp Version 4 on 
  405.       your host machine. 
  406.  
  407.      If CAT_HOST_BIN_PATH points to a remote-mounted drive, the drive must be 
  408.       mounted in binary mode. 
  409.  
  410.      Put any environment variables that you want set in a command file. For 
  411.       example, you could put them in the SETICAT.CMD file or create your own 
  412.       command file. 
  413.  
  414.      The DBGSTRIP utility can be used to strip debug information from binaries 
  415.       placed on the victim machine but should not be used on binaries placed in 
  416.       CAT_HOST_BIN_PATH (if you want to do source-level debugging). 
  417.  
  418.      Using C and C++, you can write your program code with stylistic features 
  419.       that are not supported by the debugger. For example, multiple statements 
  420.       on the same line are difficult to debug. None of the individual 
  421.       statements can be accessed separately when you set breakpoints or when 
  422.       you use step commands. 
  423.  
  424.  ICAT allows you to manipulate any thread running on the victim machine. 
  425.  Because certain portions of the address space are not shared by all threads, 
  426.  you must be sure that you are in the proper context when you set breakpoints, 
  427.  display storage, etc.  The title of a thread-specific window includes the 
  428.  thread's identifier as shown in the Debug Session Control window (see Using 
  429.  the Debug Session Control Window). To ensure you are in the context of the 
  430.  proper thread, select the thread from the Debug Session Control window's 
  431.  Threads pane. 
  432.  
  433.  For example, suppose you attach to the victim system and wish to set a 
  434.  breakpoint.  If the breakpoint is in a shared region (for example, in a device 
  435.  driver, a DLL, or the kernel), it does not matter which context you are in 
  436.  when you set the breakpoint.  But if the breakpoint is not in a shared region 
  437.  such as in an EXE file, you must ensure that you are in the context of a 
  438.  thread that belongs to the process that owns the region before you set the 
  439.  breakpoint.  Because the debugger does not necessarily have information about 
  440.  every EXE file in the system, a window may show source for a module even 
  441.  though the thread listed in the title of the window is not part of the process 
  442.  that is running the EXE file. If you set the breakpoint without first 
  443.  verifying you are in the proper context, you will actually set a breakpoint in 
  444.  a different module entirely. 
  445.  
  446.  
  447. ΓòÉΓòÉΓòÉ 1.2.8. When Things Go Wrong ΓòÉΓòÉΓòÉ
  448.  
  449. Here are some things to check when the debugger is not doing what you think it 
  450. should: 
  451.  
  452.      If the debugger can't attach to the victim system: 
  453.  
  454.         -  Ensure your serial cable is a "null modem" cable (one that connects 
  455.            the transmit data pin of one machine to the receive data pin of the 
  456.            other). 
  457.  
  458.         -  Ensure that your serial cable is securely attached to both the host 
  459.            and victim machines. 
  460.  
  461.         -  Ensure that you have the serial cable connected to the correct COMx 
  462.            port that KDB will use on the victim machine and to the COMx port 
  463.            that you specified with the CAT_MACHINE environment variable on the 
  464.            host machine. 
  465.  
  466.         -  Ensure that KDB is installed on the victim machine, and if 
  467.            necessary, check this by using a terminal emulator from the host 
  468.            machine before running the debugger.  If the terminal emulator is 
  469.            successful, don't forget to shut it down before invoking the 
  470.            debugger. 
  471.  
  472.         -  Ensure that your CAT_HOST_BIN_PATH is set correctly. 
  473.  
  474.         -  Ensure that your CAT_COMMUNICATION_TYPE environment variable is set 
  475.            to ASYNC_SIGBRK. 
  476.  
  477.         -  Ensure that you have buffered UARTs on both host and victim machines 
  478.            if you want to run at baud rates > 19200. 
  479.  
  480.         -  Ensure that your communication port is enabled if you use a 
  481.            ThinkPad. 
  482.  
  483.      If the debugger only displays the disassembly listing of your program and 
  484.       not the source listing: 
  485.  
  486.         -  Ensure that the program was compiled with the proper flags to enable 
  487.            source-level debugging.  See Compiling and Linking Your Program. 
  488.  
  489.         -  Ensure that the executable in the CAT_HOST_BIN_PATH was not 
  490.            processed by the DBGSTRIP utility.  DBGSTRIP makes the executable 
  491.            smaller by removing the debug information. 
  492.  
  493.         -  Ensure that your CAT_HOST_SOURCE_PATH is set to reference your 
  494.            source files. 
  495.  
  496.         -  Ensure that the modules you want to debug are specified by the 
  497.            CAT_MODULE_LIST environment variable. 
  498.  
  499.  
  500. ΓòÉΓòÉΓòÉ 1.2.9. Using the Demo ΓòÉΓòÉΓòÉ
  501.  
  502. This demo shows a very simple set of DevIOCtl calls being made from a sample 
  503. application to a device driver.  It explains some of the actions you could take 
  504. to debug this scenario at the source level. 
  505.  
  506. To run the demo, follow these steps: 
  507.  
  508.    1. Copy SAMPLEDD.SYS to the root directory of the C drive on your victim 
  509.       system. 
  510.    2. On the victim system, edit CONFIG.SYS so that it contains the following 
  511.       line: 
  512.  
  513.                DEVICE=C:\SAMPLEDD.SYS
  514.  
  515.       This loads the sample device driver when you reboot the victim system. 
  516.    3. Copy SAMPLE.EXE to your victim system. 
  517.    4. Reboot your victim machine so that the SAMPLEDD.SYS binary and the debug 
  518.       OS2KRNL and OS2LDR binaries are instantiated. 
  519.  
  520.       You can perform a quick check to see if the victim machine is OK by 
  521.       running your normal terminal emulator (T, ZOC, and so on).  This will 
  522.       show if KDB is communicating at 9600 baud. 
  523.    5. Shut down the terminal emulator before you run the debugger. 
  524.    6. Run the SETICAT.CMD file to set the environment variables on your host 
  525.       system. 
  526.    7. Type icatgam.  The Initialization window displays. 
  527.    8. From the Initialization window, select the Attach push button. 
  528.    9. In the Debug Session Control, make sure you see SAMPLEDD.SYS. Click on 
  529.       the plus sign (+) next to it and notice that one part is displayed. Click 
  530.       on that plus sign (+) and notice eight entries are now displayed. 
  531.   10. Click on STRATEGY. The STRATEGY routine of the sampledd device driver 
  532.       should display in a source window. 
  533.  
  534.       Note:  This is MASM source, so you will see assembler directives, but it 
  535.       is source.  We support both CodeView (CL and CL386) and HLL (IBM VACPP) 
  536.       debug formats for C. 
  537.   11. Set a breakpoint on line 209 inside the STRATEGY routine by 
  538.       double-clicking on the line number.  Run the debugger by selecting the 
  539.       Run button. 
  540.   12. On the victim machine, type sample. SAMPLE.EXE will emit a DevIOCtl to 
  541.       open the SAMPLEDD device driver. 
  542.   13. When the debugger notifies you that the breakpoint has been encountered, 
  543.       open the Registers window and then open the Storage window. Edit one of 
  544.       the addresses in this storage window by double-clicking on the address 
  545.       and change the address value to that of the PC register, which is located 
  546.       at the top of the list of status flags registers in the Registers window. 
  547.       You will see memory that corresponds to the code space. 
  548.   14. From the Source window, select Passthru from the Monitors menu. 
  549.   15. In the Passthru window, type dg cs in the Command entry field and select 
  550.       the Send push button or press the Enter key. This sends the command to 
  551.       KDB and the output is displayed in the response area.  Notice that it 
  552.       provides information about SAMPLEDD's code descriptor.  You can emit most 
  553.       KDB commands from the Passthru window.  Commands that cause the victim 
  554.       machine to resume execution (for example, g and t) should be avoided. 
  555.  
  556.       Note:  If you change the state of the victim machine with KDB commands in 
  557.       the Passthru window, you must select the Resync push button to allow the 
  558.       debugger to reflect the changes. 
  559.   16. Set another breakpoint on line 275 inside the Open subroutine. Run the 
  560.       debugger until the breakpoint is encountered. 
  561.   17. Select the step into choice or button to do a step into on the Ccall 
  562.       macro to SubrWFrame. You are in the SubrWFrame subroutine. Click on the 
  563.       Call Stack icon. 
  564.   18. From the Call Stack window, select the Display style choice from the 
  565.       Options menu. 
  566.   19. From the Display style window, enable the Return Address choice, which is 
  567.       located under the Select items group heading.  Select the OK push button. 
  568.   20. Select the step over choice or button and notice the change in the Call 
  569.       Stack window. 
  570.   21. Look at the Debug Session Control window and find SAMPLE.EXE.  Click on 
  571.       the plus sign (+) and notice that one part is displayed. Click on that 
  572.       plus sign (+) and you will see MAIN. 
  573.   22. Click on MAIN and set a breakpoint at line 44.  Run the debugger by 
  574.       selecting the Run button.  The breakpoint will be encountered in the 
  575.       STRATEGY routine again. 
  576.   23. Run one more time and the breakpoint will be encountered in SAMPLE.EXE in 
  577.       MAIN. 
  578.  
  579.  After you have completed these steps, close the debugger.  At this point, you 
  580.  can use your terminal emulator to communicate with KDB.  If you did not use 
  581.  the CAT_SETUP_RATE environment variable, KDB will be set at the baud rate you 
  582.  used to communicate with the debugger. 
  583.  
  584.  
  585. ΓòÉΓòÉΓòÉ 1.3. Getting Started ΓòÉΓòÉΓòÉ
  586.  
  587. This section describes how to start a debugging session from the OS/2 command 
  588. prompt, attach to a process you want to debug, and how to end a debugging 
  589. session. 
  590.  
  591.  
  592. ΓòÉΓòÉΓòÉ 1.3.1. Starting the Debugger from OS/2 ΓòÉΓòÉΓòÉ
  593.  
  594. To start the debugger from the OS/2 command prompt, enter the command icatgam. 
  595.  
  596. For example, type the following: 
  597.  
  598.    icatgam /x
  599. where /x represents a debugger parameter. 
  600.  
  601. The debugger parameters are: 
  602.  
  603.  /p+  Use program profile information. 
  604.  
  605.  /p-  Do not use any program profile information. 
  606.  
  607.  If you type icatgam and press Enter, the Initialization Window displays. See 
  608.  Using the Initialization Window for more information. 
  609.  
  610.  
  611. ΓòÉΓòÉΓòÉ 1.3.2. Using the Initialization Window ΓòÉΓòÉΓòÉ
  612.  
  613. Use the Initialization window to attach to the OS2KRNL. 
  614.  
  615. Initialization Window 
  616.  
  617. To use this window: 
  618.  
  619.      Select the Use program profile check box if you want to restore the 
  620.       windows and breakpoints when debugging a program more than once. 
  621.      Select the Attach push button to attach to the OS2KRNL. 
  622.      Select the Settings push button to display the Debugger Properties 
  623.       window, which allows you to select how threads and source files initially 
  624.       display and set environment variables.  See Debugger properties... for 
  625.       more information. 
  626.  
  627.  
  628. ΓòÉΓòÉΓòÉ 1.3.3. Ending the Debugging Session ΓòÉΓòÉΓòÉ
  629.  
  630. To end the debugging session, select Close debugger from the File menu in a 
  631. debugger window. The Close Debugger window displays. Select one of the 
  632. following choices: 
  633.  
  634.      Select Yes to end your debugging session. 
  635.      Select No to return to the previous screen without exiting the debugger. 
  636.  
  637.  You can also end the debugging session by pressing F3 in any of the debugger 
  638.  windows. 
  639.  
  640.  
  641. ΓòÉΓòÉΓòÉ 2. Frequently Used Features of the Debugger ΓòÉΓòÉΓòÉ
  642.  
  643. This section introduces the tool buttons, ways to execute your program, and 
  644. describes how to set breakpoints. 
  645.  
  646.  
  647. ΓòÉΓòÉΓòÉ 2.1. Using the Tool Buttons ΓòÉΓòÉΓòÉ
  648.  
  649. A tool bar has been provided for easier access to frequently used features. 
  650. Not all buttons are displayed in the windows.  To display buttons in a window, 
  651. enable the Tool buttons choice that is listed under the Options menu. The 
  652. following is a list of features that are provided: 
  653.  
  654.                      Step over executes the current line in the program.  If 
  655.                      the current line is a call, execution is halted when the 
  656.                      call is completed. 
  657.  
  658.                      Step into executes the current line in the program.  If 
  659.                      the current line is a call, execution is halted at the 
  660.                      first statement in the called function. 
  661.  
  662.                      Step debug executes the current line in the program. The 
  663.                      debugger steps over any function for which debugging 
  664.                      information is not available (for example, library and 
  665.                      system routines) and steps into any function for which 
  666.                      debugging information is available. 
  667.  
  668.                      Step return automatically executes the lines of code up to 
  669.                      and including the return statement of the current 
  670.                      function. 
  671.  
  672.                      Run allows you to start and stop the program. 
  673.  
  674.                      When the debugger is running, the Run button is disabled 
  675.                      and the Halt button is enabled. You can click on the Halt 
  676.                      button to halt the program execution.  You can also 
  677.                      interrupt the program you are debugging by selecting the 
  678.                      Halt choice from the Run menu. 
  679.  
  680.                      View changes the current source window to one of the other 
  681.                      source windows. For example, you can change from the 
  682.                      Disassembly window to the Mixed window. 
  683.  
  684.                      Monitor Expression displays the Monitor Expression window, 
  685.                      which allows you to type in the name of the expression you 
  686.                      want to monitor. 
  687.  
  688.                      Call Stack displays the Call Stack window, which allows 
  689.                      you to view all of the active functions for a particular 
  690.                      thread including the system calls. The functions are 
  691.                      displayed in the order that they were called. 
  692.  
  693.                      Registers displays the Registers window, which allows you 
  694.                      to view all the processor and coprocessor registers for a 
  695.                      particular thread. 
  696.  
  697.                      Storage displays the Storage window, which shows the 
  698.                      storage contents and the address of the storage. 
  699.  
  700.                      Breakpoints displays the Breakpoints List window, which 
  701.                      allows you to view all the breakpoints that have been set. 
  702.  
  703.                      Passthru displays the Passthru window, which allows you to 
  704.                      send commands and receive responses from KDB directly. 
  705.  
  706.                      Debug Session Control displays the Debug Session Control 
  707.                      window. 
  708.  
  709.                      Growth direction allows you to change the direction that 
  710.                      items are displayed on the stack. 
  711.  
  712.                      Delete allows you to delete the highlighted item. 
  713.  
  714.                      Delete all allows you to delete all the items in the 
  715.                      window. 
  716.  
  717.                      32-float displays the storage contents as a 32-bit 
  718.                      floating point. 
  719.  
  720.                      64-float displays the storage contents as a 64-bit 
  721.                      floating point. 
  722.  
  723.                      32-bit unsigned displays the storage contents as a 32-bit 
  724.                      unsigned integer. 
  725.  
  726.                      32-bit signed displays the storage contents as a 32-bit 
  727.                      signed integer. 
  728.  
  729.                      ASCII displays the storage contents in ASCII. 
  730.  
  731.                      Hex and ASCII displays the storage contents in Hex and 
  732.                      ASCII. 
  733.  
  734.                      Change representation allows you the change the data 
  735.                      representation. 
  736.  
  737.  
  738. ΓòÉΓòÉΓòÉ 2.2. Executing a Program ΓòÉΓòÉΓòÉ
  739.  
  740. You can execute your program by using step commands or the Run command. 
  741.  
  742.  Step commands   Step commands control the execution of the program. 
  743.  
  744.                  The step commands are located in the tool bar of the source 
  745.                  windows and under the Run menu of the source windows. 
  746.  
  747.  Run command     The Run command runs the program until a breakpoint is 
  748.                  encountered, the program is halted, or the program ends. 
  749.  
  750.                  You can start the RUN command from the Run button in the tool 
  751.                  bar or the Run menu of the source windows. 
  752.  
  753.  When you execute your program, a clock icon displays to indicate that the 
  754.  program is running and might require input to continue to the next breakpoint 
  755.  or termination of the program. 
  756.  
  757.  
  758. ΓòÉΓòÉΓòÉ 2.3. Setting Breakpoints ΓòÉΓòÉΓòÉ
  759.  
  760. You can control how your program executes by setting breakpoints.  A breakpoint 
  761. stops the execution of your program at a specific location or when a specific 
  762. event occurs. 
  763.  
  764. To set breakpoints, select the Breakpoints menu from the Debug Session Control 
  765. window or from any of the source windows and select the appropriate choice for 
  766. the type of breakpoint you want to set. You can also set a simple line 
  767. breakpoint by double-clicking in the prefix area of an executable statement in 
  768. any of the source windows.  The prefix area is the area to the left of the 
  769. source code where line numbers or addresses are displayed. The prefix area 
  770. turns red indicating that the breakpoint has been set. You can also use the 
  771. arrow keys to move the cursor to the prefix area and then use the space bar to 
  772. toggle the breakpoints. This allows you to set or delete a breakpoint. 
  773.  
  774. Refer to Breakpoints Menu Choices for more information on breakpoints. 
  775.  
  776.  
  777. ΓòÉΓòÉΓòÉ 3. Introducing the Main Debugging Windows ΓòÉΓòÉΓòÉ
  778.  
  779. This section introduces the Debug Session Control window and the three source 
  780. windows which offer different views of your source code. It describes the menu 
  781. items and choices that are located in each of these windows. 
  782.  
  783.  
  784. ΓòÉΓòÉΓòÉ 3.1. Using the Debug Session Control Window ΓòÉΓòÉΓòÉ
  785.  
  786. The Debug Session Control window is the control window of the debugger and 
  787. displays during the entire debugging session. This window is divided into two 
  788. panes. One pane shows the threads for the program you are debugging and the 
  789. corresponding process IDs, process names, kernel thread IDs, and processor 
  790. number (when applicable). The other pane shows the components for the program 
  791. that you are debugging. 
  792.  
  793. Debug Session Control Window 
  794.  
  795. The Threads pane contains the threads and the state of the threads started by 
  796. your program. These values can be used in conjunction with the KDB .p command 
  797. to match an ICAT thread to a corresponding KDB slot. 
  798.  
  799. To display the state of a thread, select the plus icon to the left of the 
  800. thread. 
  801.  
  802. The Thread Popup Menu contains choices to take you to different debugger 
  803. windows. The popup menu is shown when you place the mouse pointer on a 
  804. highlighted thread name and click mouse button 2. 
  805.  
  806. The following are the popup choices: 
  807.  
  808.  Execution point     Opens a source window containing the next line to be run. 
  809.  
  810.  Registers           Displays the Registers window. 
  811.  
  812.  Call stack          Displays the Call Stack window. 
  813.  
  814.  Local variables     Displays the Local Variables window. 
  815.  
  816.  The Components pane shows the path name of the executable files that are 
  817.  associated with the OS2KRNL. 
  818.  
  819.  To display a list of object files contained within an executable file, select 
  820.  the plus icon to the left of the executable file name. To open a source window 
  821.  of an object file, double-click on the object file name. 
  822.  
  823.  To display a list of functions for a specific object file, select the plus 
  824.  icon to the left of the object file name. To open a source window of a 
  825.  specific function, double-click on the function name. 
  826.  
  827.  You can display any object or function in a source window by double-clicking 
  828.  on the name in the Components pane or by highlighting the component name and 
  829.  selecting the View popup choice. 
  830.  
  831.  To specify which components are shown in the Components list, select Options 
  832.  -> Window Settings -> Display style.  The Display Style window displays. 
  833.  Disable the Show all components choice if you want only components compiled 
  834.  and linked with debugging data to be listed. If the choice is enabled, all 
  835.  components are listed. 
  836.  
  837.  The Object or Function Popup Menu contains choices that allow you to display 
  838.  the object or function in a source window or set a function breakpoint. The 
  839.  popup menu is shown when you place the mouse pointer on a object or function 
  840.  name and click mouse button 2. 
  841.  
  842.  The choices in the popup menu are: 
  843.  
  844.  View                       Shows the object or function in a source window. 
  845.  
  846.  Set function breakpoint    Sets a function breakpoint to stop the execution of 
  847.                             your program after calling a specific function in 
  848.                             the current selected thread. 
  849.  
  850.  Set breakpoint (every)     Sets a breakpoint to stop the execution of your 
  851.                             program on a function in all the threads. 
  852.  
  853.  
  854. ΓòÉΓòÉΓòÉ 3.1.1. File Menu Choices ΓòÉΓòÉΓòÉ
  855.  
  856. Select choices from the File menu of the Debug Session Control window to open a 
  857. new source file, locate a particular function, open a source window that 
  858. contains the next line to be executed, start a new debugging session, or end a 
  859. debugging session. 
  860.  
  861.  
  862. ΓòÉΓòÉΓòÉ 3.1.1.1. Open new source... ΓòÉΓòÉΓòÉ
  863.  
  864. Displays the Open New Source window, which allows you to open a new source 
  865. file.  If you have multiple source files in your program, only one source file 
  866. is initially displayed.  Use the Open New Source window to open additional 
  867. source files. 
  868.  
  869. Open New Source Window 
  870.  
  871. To use the Open New Source window: 
  872.  
  873.      Type the name of the object file you want to open the source for in the 
  874.       Source entry field. For example, to look for the source used to compile 
  875.       A123.OBJ, type the following: 
  876.  
  877.                A123
  878.  
  879.       If you are unsure of the file name, select the File list... push button 
  880.       to view a list of the files that you can select. 
  881.      Type the name of the executable file in the Executable entry field.  The 
  882.       source files for the executable file display in the Source entry field. 
  883.      Enable the All Executables check box if you want to search all the 
  884.       executable files. Disable the All Executables check box to search for a 
  885.       particular executable file. 
  886.      Enable the Debugging Information Only check box if you want to search 
  887.       only the source files that contain debugging information. 
  888.      Select the OK push button. 
  889.  
  890.  
  891. ΓòÉΓòÉΓòÉ 3.1.1.2. Find function... ΓòÉΓòÉΓòÉ
  892.  
  893. Displays the Find Function window, which allows you to open a source window to 
  894. a particular function. 
  895.  
  896. Find Function Window 
  897.  
  898. To use the Find Function window: 
  899.  
  900.      Type the name of the function you want to search for in the Function 
  901.       entry field. 
  902.  
  903.       If the function that you specify is not found, the following message 
  904.       displays: 
  905.  
  906.                NO MATCHING FUNCTION FOUND
  907.  
  908.       This means it may be a static function or the function you specified does 
  909.       not exist. 
  910.  
  911.       The debugger searches each object file for global functions that match 
  912.       the function name specified. If an object file contains the global 
  913.       function that was specified, then it will also search that file for any 
  914.       static function with the same name. 
  915.      Enable the Debugging information only check box if you want to search 
  916.       only the object files that contain debugging information. 
  917.      Enable the Case sensitive check box if you want to search for the string 
  918.       exactly as typed.  Disable this check box if you want to search for both 
  919.       uppercase and lowercase characters. 
  920.      Select the OK push button. 
  921.  
  922.  
  923. ΓòÉΓòÉΓòÉ 3.1.1.3. Where is execution point ΓòÉΓòÉΓòÉ
  924.  
  925. Opens a source window containing the next line to be executed. 
  926.  
  927.  
  928. ΓòÉΓòÉΓòÉ 3.1.1.4. Save thread list in file ΓòÉΓòÉΓòÉ
  929.  
  930. Saves the contents of the Threads pane into a file.  The default file name is 
  931. threads.out.  To change the default file name, select Options -> Window 
  932. settings -> Display style... from the Debug Session Control window. 
  933.  
  934.  
  935. ΓòÉΓòÉΓòÉ 3.1.1.5. Save component list in file ΓòÉΓòÉΓòÉ
  936.  
  937. Saves the contents of the Components pane into a file.  The default file name 
  938. is comps.out.  To change the default file name, select Options -> Window 
  939. settings -> Display style... from the Debug Session Control window. 
  940.  
  941.  
  942. ΓòÉΓòÉΓòÉ 3.1.1.6. Initialization... ΓòÉΓòÉΓòÉ
  943.  
  944. Displays the Initialization window, which allows you to start a debugging 
  945. session by attaching to the OS2KRNL. Refer to Using the Initialization Window 
  946. for more information. 
  947.  
  948.  
  949. ΓòÉΓòÉΓòÉ 3.1.1.7. Close debugger ΓòÉΓòÉΓòÉ
  950.  
  951. Ends the debugging session. When you select the Close debugger choice, the 
  952. Close Debugger message box prompts you to confirm that you want to end the 
  953. debugging session. 
  954.  
  955.  
  956. ΓòÉΓòÉΓòÉ 3.1.2. Breakpoints Menu Choices ΓòÉΓòÉΓòÉ
  957.  
  958. Select choices from the Breakpoints menu to set breakpoints and to stop the 
  959. execution of your program at any point. You can set as many breakpoints as you 
  960. want. 
  961.  
  962. Breakpoints can be set from the Debug Session Control window or from the source 
  963. windows. When you set a breakpoint in one source window, it is reflected in the 
  964. other source windows. 
  965.  
  966.  
  967. ΓòÉΓòÉΓòÉ 3.1.2.1. Set line... ΓòÉΓòÉΓòÉ
  968.  
  969. Displays the Line Breakpoint window, which allows you to set a line breakpoint 
  970. to stop the execution of your program at a specific line number. 
  971.  
  972. Line Breakpoint Window 
  973.  
  974. The Line Breakpoint window is divided into two group headings: Required 
  975. Parameters and Optional Parameters. 
  976.  
  977. The Required Parameters group heading contains the following: 
  978.  
  979.      Executable Entry Field 
  980.  
  981.       To select a component from the Executable list: 
  982.         1. Type the executable name in the entry field or open the Executable 
  983.            list by selecting the list button. This displays a drop-down 
  984.            combination box. 
  985.         2. Highlight the executable where you want to set the breakpoint 
  986.      Source Entry Field 
  987.  
  988.       To select a component from the Source list: 
  989.         1. Type the source name in the entry field or open the Source list by 
  990.            selecting the list button. This displays a drop-down combination 
  991.            box. 
  992.         2. Highlight the source where you want to set the breakpoint. 
  993.      Include File Entry Field 
  994.  
  995.       If the source you selected has include files with executable statements, 
  996.       then the File list displays all the file names that contain executable 
  997.       lines. 
  998.         1. Type the name of the file in the entry field or open the File list 
  999.            by selecting the list button. This displays a drop-down combination 
  1000.            box. 
  1001.         2. Highlight the file where you want to set the breakpoint. 
  1002.      Line Entry Field 
  1003.  
  1004.       To set a line breakpoint, type the line number in the Line entry field. 
  1005.       The breakpoint is set on the line number. 
  1006.  
  1007.  The Optional Parameters group heading contains the following: 
  1008.  
  1009.      Thread Entry Field 
  1010.  
  1011.       To select a thread ID from the Thread list: 
  1012.         1. Open the Thread list by selecting the list button. This displays a 
  1013.            drop-down combination box. 
  1014.         2. Highlight the thread where you want to set the breakpoint. 
  1015.  
  1016.       Select Every, the default, to set a breakpoint in all of the active 
  1017.       threads in your program. The Every choice is thread independent. Select 
  1018.       one of the individual threads to set a breakpoint in one thread only. 
  1019.       Threads are added to the Thread list as new threads are activated. 
  1020.      From Entry Field 
  1021.  
  1022.       This field is used for location breakpoints, address breakpoints and load 
  1023.       occurrence breakpoints. Type in a number to start activating the 
  1024.       breakpoint the nth time the location is encountered. 
  1025.      To Entry Field 
  1026.  
  1027.       This field is used for location breakpoints, address breakpoints and load 
  1028.       occurrence breakpoints. Type in a number to stop activating the 
  1029.       breakpoint after the nth time the location is encountered. 
  1030.      Every Entry Field 
  1031.  
  1032.       This field is used for location breakpoints, address breakpoints and load 
  1033.       occurrence breakpoints. Type in a number to indicate how often the 
  1034.       breakpoint should be activated within the From and To range. 
  1035.      Expression Entry Field 
  1036.  
  1037.       If you are setting an address, function, or line breakpoint, you can also 
  1038.       type in an expression.  The execution of the program stops only if this 
  1039.       condition tests true. For example, you could type the following: 
  1040.  
  1041.                (i==1) ΓòæΓòæ (j==k) && (k!=5)
  1042.  
  1043.       Note:  Variables in a conditional expression associated with a function 
  1044.       breakpoint are limited to any static or global variables that are known 
  1045.       to the called function when the function is called. Local variables and 
  1046.       automatic variables will not evaluate correctly. 
  1047.  
  1048.       The maximum length of the condition is 256 characters. 
  1049.      Defer breakpoint Check Box 
  1050.  
  1051.       Enable the Defer breakpoint check box if you want to set a breakpoint in 
  1052.       a module that is not currently loaded. 
  1053.  
  1054.       If you set a deferred line breakpoint and the line is located in a 
  1055.       template, the debugger sets the line breakpoint in all of the templates 
  1056.       when the module is loaded. 
  1057.  
  1058.       When a module is loaded and a deferred breakpoint has been set in the 
  1059.       module, the state of the breakpoint changes from deferred to active. When 
  1060.       a module is freed, any breakpoints that were set in the module change 
  1061.       from the active state to deferred state. 
  1062.  
  1063.       If you enter an invalid source, file or line number, the debugger will be 
  1064.       unable to activate the breakpoint when the module is loaded. Therefore, 
  1065.       the invalid breakpoint will remain in the deferred state even after the 
  1066.       module is loaded. 
  1067.  
  1068.  
  1069. ΓòÉΓòÉΓòÉ 3.1.2.2. Set function... ΓòÉΓòÉΓòÉ
  1070.  
  1071. Displays the Function Breakpoint window, which allows you to set a function 
  1072. breakpoint to stop the execution of your program when the first instruction of 
  1073. the function is encountered where the breakpoint has been set. 
  1074.  
  1075. Function Breakpoint Window 
  1076.  
  1077. The entry fields in this window are the same as in the Line Breakpoint window 
  1078. except for the following: 
  1079.  
  1080.      Function Entry Field 
  1081.  
  1082.       Type the name of the function where you want to set the breakpoint or 
  1083.       select a function from the Function list.  To select a function, do the 
  1084.       following: 
  1085.         1. Open the Function list by selecting the list button. This displays a 
  1086.            drop-down combination box. 
  1087.         2. Highlight the function where you want to set the breakpoint. 
  1088.  
  1089.       If a function is overloaded, then a window displays with a list of all 
  1090.       the overloaded function names. Select the appropriate function from the 
  1091.       list. 
  1092.      Debugging information only Check Box 
  1093.  
  1094.       Enable this check box if you want to search only the object files that 
  1095.       contain debugging information. 
  1096.      Case sensitive Check Box 
  1097.  
  1098.       Enable this check box if you want to search for the string exactly as 
  1099.       typed.  Disable this check box if you want to search for both uppercase 
  1100.       and lowercase characters. 
  1101.  
  1102.  For a description of the types of data you can enter in the entry fields under 
  1103.  the Optional Parameters group heading, refer to Set line.... 
  1104.  
  1105.  
  1106. ΓòÉΓòÉΓòÉ 3.1.2.3. Set address... ΓòÉΓòÉΓòÉ
  1107.  
  1108. Displays the Address Breakpoint window, which allows you to set an address 
  1109. breakpoint to stop the execution of your program at a specific address. 
  1110.  
  1111. Address Breakpoint Window 
  1112.  
  1113. The entry fields in this window are the same as in the Line Breakpoint window 
  1114. except for the following: 
  1115.  
  1116.      Address or Expression Entry Field 
  1117.  
  1118.       Type the name of the address or expression in the Address or Expression 
  1119.       entry field. 
  1120.  
  1121.       For example, to set an address breakpoint for the address 0x000A1FCC, you 
  1122.       would type one of the following in the Address entry field: 
  1123.  
  1124.                0x000A1FCC or A1FCC
  1125.  
  1126.       The 0x is optional. 
  1127.  
  1128.  For a description of the types of data you can enter in the entry fields under 
  1129.  the Optional Parameters group heading, refer to Set line.... 
  1130.  
  1131.  
  1132. ΓòÉΓòÉΓòÉ 3.1.2.4. Set watchpoint... ΓòÉΓòÉΓòÉ
  1133.  
  1134. Displays the Watchpoint window, which allows you to set a watchpoint to stop 
  1135. the execution of your program when contents of memory at a given address are 
  1136. referenced, when an instruction is fetched from a particular address, or when 
  1137. an I/O port at a particular address is referenced. 
  1138.  
  1139. Watchpoint Window 
  1140.  
  1141. Use the Watchpoint window to set a watchpoint. 
  1142.  
  1143.      Address (or Expression) or Port # Entry Field 
  1144.  
  1145.       Type a hexadecimal address or port or an expression that can be evaluated 
  1146.       to a hexadecimal address. 
  1147.  
  1148.       Note:  If you type ABC in the Address (or Expression) or Port # entry 
  1149.       field, and there is a variable named ABC, the value of the variable is 
  1150.       used instead of the hex value ABC. Also, you can type &a in the Address 
  1151.       (or Expression) or Port # entry field to set the watchpoint on the 
  1152.       address of a variable a. 
  1153.  
  1154.       For example, type the following in the Address (or Expression) or Port # 
  1155.       entry field to set a watchpoint for the address A1FCC. 
  1156.  
  1157.                A1FCC
  1158.  
  1159.       Type the following in the Address (or Expression) or Port # entry field 
  1160.       to set a watchpoint for the expression &variable. 
  1161.  
  1162.                &variable
  1163.  
  1164.      Bytes to Monitor Radio Buttons 
  1165.  
  1166.       The debugger will monitor 1, 2, or 4 bytes for the type of watchpoint 
  1167.       operation that you select.  This choice is made for you on the 
  1168.       Instruction fetch and I/O Port types. 
  1169.      Watchpoint Radio Buttons 
  1170.  
  1171.       The debugger supports four types of watchpoints. They are as follows: 
  1172.       I/O Port                 Causes a break when the port address is read 
  1173.                                from or written to. 
  1174.  
  1175.       Write                    Causes a break when the address is written to. 
  1176.  
  1177.       Read or write            Causes a break when the address is read from or 
  1178.                                written to. 
  1179.  
  1180.       Instruction fetch        Causes a break when the instruction at that 
  1181.                                address is fetched. 
  1182.  
  1183.  Warning: If you set a watchpoint that is on the call stack, you should remove 
  1184.  the watchpoint before leaving the routine associated with the watchpoint. 
  1185.  Otherwise, when you return from the routine, the routine's stack frame will be 
  1186.  removed from the stack leaving the watchpoint intact.  Any other routine that 
  1187.  gets loaded on the stack will then contain the watchpoint. You can set up to 
  1188.  four watchpoints. 
  1189.  
  1190.  For a description of the types of data you can enter in the entry fields under 
  1191.  the Optional Parameters group heading, refer to Set line.... 
  1192.  
  1193.  
  1194. ΓòÉΓòÉΓòÉ 3.1.2.5. Set load occurrence... ΓòÉΓòÉΓòÉ
  1195.  
  1196. Displays the Load Occurrence Breakpoint window, which allows you to set a load 
  1197. occurrence breakpoint to stop the execution of your program when a specific 
  1198. module is loaded. 
  1199.  
  1200. Load Occurrence Breakpoint Window 
  1201.  
  1202. To use the Load Occurrence Breakpoint window, type the name of the module in 
  1203. the Module Name entry field. Execution stops when the module is loaded. 
  1204.  
  1205.      Module Name Entry Field 
  1206.  
  1207.  To set a load occurrence breakpoint when MY.DLL is loaded, you would type one 
  1208.  of the following in the Module Name entry field: 
  1209.  
  1210.      MY or MY.DLL
  1211.  
  1212.  Note:  If the CAT_MODULE_LIST environment variable has been defined, and the 
  1213.  module's name is not contained in the CAT_MODULE_LIST, the module will not be 
  1214.  reported. If the module can not be found in the module search path, the module 
  1215.  name will not be accepted. See Debugger properties... for information on 
  1216.  identifying modules. 
  1217.  
  1218.  For a description of the types of data you can enter in the entry fields under 
  1219.  the Optional Parameters group heading, refer to Set line.... 
  1220.  
  1221.  
  1222. ΓòÉΓòÉΓòÉ 3.1.2.6. List ΓòÉΓòÉΓòÉ
  1223.  
  1224. Displays the Breakpoints List window, which lists all the breakpoints that have 
  1225. been set.  It also shows the state of each breakpoint. 
  1226.  
  1227. Breakpoints List Window 
  1228.  
  1229. Use the Breakpoints List window to display a list of the breakpoints that have 
  1230. been set. The following information is also provided for each breakpoint. 
  1231.  
  1232.      The enablement state 
  1233.      The type of breakpoint 
  1234.      The position of the breakpoint 
  1235.      The conditions under which the breakpoint is activated. 
  1236.  
  1237.  For more information on the Breakpoints List window, refer to Using the 
  1238.  Breakpoints List Window. 
  1239.  
  1240.  
  1241. ΓòÉΓòÉΓòÉ 3.1.2.7. Delete All ΓòÉΓòÉΓòÉ
  1242.  
  1243. Deletes all the breakpoints that have been set. 
  1244.  
  1245.  
  1246. ΓòÉΓòÉΓòÉ 3.1.3. Monitors Menu Choices ΓòÉΓòÉΓòÉ
  1247.  
  1248. Select choices from the Monitors menu of the Debug Session Control window to 
  1249. open other debugging windows such as monitors, call stack, registers, and 
  1250. storage. 
  1251.  
  1252. The choices listed under the Monitors menu are also accessible from the tool 
  1253. bar of the source windows. 
  1254.  
  1255.  Call stack          Displays the Call Stack window, which allows you to 
  1256.                      monitor the call stack for a particular thread. This 
  1257.                      window is described in Call Stack Window. 
  1258.  
  1259.  Registers           Displays the Registers window, which allows you to monitor 
  1260.                      registers and flags for a particular component or thread. 
  1261.                      This window is described in Using the Registers Window. 
  1262.  
  1263.  Storage             Displays the Storage window, which allows you to monitor 
  1264.                      the storage in your program. This window is described in 
  1265.                      Using the Storage Window. 
  1266.  
  1267.  Local variables     Displays the Local Variables window, which allows you to 
  1268.                      display the local variables for the program's current 
  1269.                      function. This window is described in Using the Local 
  1270.                      Variables Window. 
  1271.  
  1272.  Passthru            Allows you to send commands to KDB and displays the 
  1273.                      formatted KDB response. 
  1274.  
  1275.  
  1276. ΓòÉΓòÉΓòÉ 3.1.4. Run Menu Choices ΓòÉΓòÉΓòÉ
  1277.  
  1278. Select choices from the Run menu to execute your program or stop execution. 
  1279.  
  1280.  
  1281. ΓòÉΓòÉΓòÉ 3.1.4.1. Run ΓòÉΓòÉΓòÉ
  1282.  
  1283. Executes the program from the current line until a breakpoint is encountered or 
  1284. the program ends. 
  1285.  
  1286.  
  1287. ΓòÉΓòÉΓòÉ 3.1.4.2. Halt ΓòÉΓòÉΓòÉ
  1288.  
  1289. Interrupts the program you are debugging. 
  1290.  
  1291.  
  1292. ΓòÉΓòÉΓòÉ 3.1.4.3. Hide Debugger on Run ΓòÉΓòÉΓòÉ
  1293.  
  1294. Minimizes the debugger windows while your application is running. 
  1295.  
  1296.  
  1297. ΓòÉΓòÉΓòÉ 3.1.5. Options Menu Choices ΓòÉΓòÉΓòÉ
  1298.  
  1299. Select choices from the Options menu to control how the debugger windows 
  1300. display. 
  1301.  
  1302.  
  1303. ΓòÉΓòÉΓòÉ 3.1.5.1. Window settings-> ΓòÉΓòÉΓòÉ
  1304.  
  1305. Use the Window settings cascading choices to modify the characteristics of the 
  1306. Debug Session Control window. 
  1307.  
  1308.  Fonts 
  1309.            Displays the Fonts window, which allows you to select the font you 
  1310.            want to use for the text displayed in the Debug Session Control 
  1311.            window. 
  1312.  
  1313.  Display style... 
  1314.            Displays the Display Style window, which allows you to select the 
  1315.            settings you want to use. 
  1316.  
  1317.  Restore defaults 
  1318.            Resets all of the window settings to their original settings. 
  1319.  
  1320.  Tool buttons 
  1321.            Enables or disables tool buttons. 
  1322.  
  1323.  Hover help 
  1324.            Enables or disables the hover help. 
  1325.  
  1326.  Infoarea 
  1327.            Enables or disables the information area.               . 
  1328.  
  1329.  
  1330. ΓòÉΓòÉΓòÉ 3.1.5.2. Debugger settings-> ΓòÉΓòÉΓòÉ
  1331.  
  1332. Use the Debugger settings cascading choice to set various debugger options that 
  1333. control how the debugger windows display. These settings affect the behavior of 
  1334. the debugger and remain in effect for the duration of the debugging session. 
  1335.  
  1336.  
  1337. ΓòÉΓòÉΓòÉ 3.1.5.3. Debugger properties... ΓòÉΓòÉΓòÉ
  1338.  
  1339. Displays the Debugger Properties window, which allows you to select how the 
  1340. threads and source files initially display. This window contains the following 
  1341. three tabs: 
  1342.  
  1343.      Source 
  1344.      Remote 
  1345.      Modules. 
  1346.  
  1347.  The Remote page displays by default if you open the window using the 
  1348.  Initialization window.  If not, the Source page displays. 
  1349.  
  1350.  When you select the Remote tab, the following page displays: 
  1351.  
  1352.  Debugger Properties Window - Remote Page 
  1353.  
  1354.  Use this window to do the following tasks: 
  1355.  
  1356.      Set the communication baud rate for the debugger. 
  1357.      Set the communication port. 
  1358.      Set the communication baud rate for KDB on initialization and after 
  1359.       exiting. 
  1360.      Set the path where the debugger finds source. 
  1361.      Set the path where the debugger finds the debug binary modules. 
  1362.      View the communication mode (ASYNC_SIGBRK is all that is currently 
  1363.       available). 
  1364.      Set modem communication information, if used. 
  1365.      Set a string to initialize KDB. 
  1366.      Set the option for recursive subdirectory searching of the source and 
  1367.       binary paths. 
  1368.  This window's values are dithered and cannot be changed after communication 
  1369.  has been established with the victim machine. 
  1370.  
  1371.  ICAT Baud Rate Group Heading 
  1372.  
  1373.  This group of radio buttons allows you to select communication baud rates from 
  1374.  9600 to 115200.  Ensure that your machine can handle rates greater than 19200 
  1375.  if you choose them.  You must have buffered UARTs on both machines in this 
  1376.  case. If you choose a rate of 115200, your host machine must have a COM.SYS 
  1377.  different than the default supplied with OS/2. 
  1378.  
  1379.  KDB Baud Rate Group Heading 
  1380.  
  1381.  This group of radio buttons allows you to select the initial (setup) 
  1382.  communication rate that the debugger uses to communicate with KDB.  If any 
  1383.  rate other than default is selected, that same rate will be used to reset the 
  1384.  victim machine's communication port when the debugger is exited. 
  1385.  
  1386.  Communications Port Spin Button 
  1387.  
  1388.  This spin button allows you to select the communication port number for the 
  1389.  debugger on the host machine. 
  1390.  
  1391.  Environment Variables Group Heading 
  1392.  
  1393.  These entry fields correspond respectively to the following environment 
  1394.  variables: 
  1395.  
  1396.      CAT_HOST_SOURCE_PATH 
  1397.      CAT_HOST_BIN_PATH 
  1398.      CAT_COMMUNICATION_TYPE 
  1399.      CAT_DIAL 
  1400.      CAT_MODEM_INIT 
  1401.      CAT_KDB_INIT 
  1402.  
  1403.  By adjusting these fields, you can alter your communication and serial paths 
  1404.  dynamically before communication is established with the victim machine. See 
  1405.  Setting Environment Variables for detailed information on environment 
  1406.  variables. 
  1407.  
  1408.  Path Recursion Check Box 
  1409.  
  1410.  This check box, when selected, forces the debugger to search all source and 
  1411.  binary path subdirectories recursively. 
  1412.  
  1413.  When you select the Source tab, the following page displays: 
  1414.  
  1415.  Debugger Properties Window - Source Page 
  1416.  
  1417.  Use this window to determine: 
  1418.  
  1419.      when a source window first displays during a debugging session. 
  1420.      how to process a source window from which execution has just left.  The 
  1421.       window can remain displayed, be turned into an icon, or be discarded. 
  1422.  
  1423.  Old source disposition Group Heading 
  1424.  
  1425.  In the course of debugging, these selections allow you to control the behavior 
  1426.  of source windows from which execution has just left. The Old Source 
  1427.  Disposition radio buttons control the behavior of source windows within a 
  1428.  thread. 
  1429.  
  1430.  The dispositions that the views can take are: 
  1431.  
  1432.  Keep        Leaves open the source windows that contain the components and 
  1433.              threads that you select with Display at stop. 
  1434.  
  1435.  Minimize    Changes into icons the views that contain the components and 
  1436.              threads that you select with Display at stop. 
  1437.  
  1438.  Discard     Disposes of the views that contain the components and threads that 
  1439.              you select with Display at stop. 
  1440.  
  1441.  Settings Group Heading 
  1442.  
  1443.  You can choose to display more than one source window for a particular source 
  1444.  file.  Enable the Multiple views check box if you want to have multiple source 
  1445.  windows open at the same time. 
  1446.  
  1447.  Mouse button 2 behavior Group Heading 
  1448.  
  1449.  Select the radio button that represents the action that you want mouse button 
  1450.  2 to perform. 
  1451.  
  1452.  When you select the Modules tab, the following page displays: 
  1453.  
  1454.  Debugger Properties Window - Modules Page 
  1455.  
  1456.  Use this window to add a module name to or delete a module name from the 
  1457.  CAT_MODULE_LIST environment variable.  See Setting Environment Variables for 
  1458.  detailed information on this environment variable. 
  1459.  
  1460.  Modules List Box 
  1461.  
  1462.  This contains a list of modules which the debugger obtains information about 
  1463.  if or when they are loaded. If a module is loaded and it is not in the list, 
  1464.  the debugger ignores the module. 
  1465.  
  1466.  New Module Entry Field 
  1467.  
  1468.  Type the name of the module that you want to add or delete. Select the 
  1469.  appropriate push button to perform this task. 
  1470.  
  1471.  
  1472. ΓòÉΓòÉΓòÉ 3.1.5.4. Monitor properties... ΓòÉΓòÉΓòÉ
  1473.  
  1474. Displays the Monitor Properties window, which allows you to select the settings 
  1475. for monitoring variables or expressions. 
  1476.  
  1477. Monitor Properties Window 
  1478.  
  1479. Use the Monitor Properties window to set the following: 
  1480.  
  1481.      The window into which the variable or expression being monitored is 
  1482.       placed. 
  1483.      For popup expression windows, how long the monitor windows display. 
  1484.  
  1485.  Monitor Location Group Heading 
  1486.  
  1487.  Choose one of the following radio buttons to select the monitor window that 
  1488.  opens when you select a variable or expression to monitor. The selections you 
  1489.  can make, and the corresponding windows, are: 
  1490.  
  1491.  Popup 
  1492.            Display the variable or expression in a popup expression window. 
  1493.  
  1494.  Private monitor 
  1495.            Display the variable or expression in the Private Monitor window. 
  1496.  
  1497.  Program monitor 
  1498.            Display the variable or expression in the Program Monitor window. 
  1499.  
  1500.  Storage monitor 
  1501.            Display the variable or expression in the Storage window. 
  1502.  
  1503.  Save File Entry Field 
  1504.  
  1505.  Use this field to identify the file where all monitor windows will write their 
  1506.  contents  when the Save to file choice is selected. 
  1507.  
  1508.  Number of elements to show entry field 
  1509.  
  1510.  Use this field to identify the maximum number of structure or class elements 
  1511.  that will be displayed at one time for a given variable in the monitors. 
  1512.  
  1513.  Enable bubble variables check box 
  1514.  
  1515.  Select this option if you want a bubble value for the contents of a variable 
  1516.  to appear as you place the mouse or the variable in the Source, Disassembly, 
  1517.  and Mixed view windows. 
  1518.  
  1519.  Popup Duration Group Heading 
  1520.  
  1521.  If you select Popup from the Monitor Location group heading, select one of the 
  1522.  following radio buttons to specify how long the popup expression window 
  1523.  displays: 
  1524.  
  1525.  Step/run        The monitor window closes when the next step command or Run is 
  1526.                  executed. 
  1527.  
  1528.  New source      The monitor window closes when execution stops in a new source 
  1529.                  file. 
  1530.  
  1531.  Permanent       This monitor window is associated with a specific source 
  1532.                  window and closes when the associated source window closes. 
  1533.  
  1534.  
  1535. ΓòÉΓòÉΓòÉ 3.1.5.5. Default data representation-> ΓòÉΓòÉΓòÉ
  1536.  
  1537. Use the Default data representation cascading choices to change the 
  1538. representation for a data type in a specific language. 
  1539.  
  1540. Select a language to change the default representation of the selected data 
  1541. type. For example, you can change the default representation for an integer in 
  1542. the C language from decimal to hexadecimal. Select the System choice to change 
  1543. the default representation of the math coprocessor registers. This choice is 
  1544. language independent. 
  1545.  
  1546.  
  1547. ΓòÉΓòÉΓòÉ 3.1.5.6. Program profiles-> ΓòÉΓòÉΓòÉ
  1548.  
  1549. Use the Program profiles cascading choices to enable program profiles, delete 
  1550. program profiles, or change the location where the program profiles are stored, 
  1551.  
  1552. Program profiles are used to restore the debugger windows and breakpoints when 
  1553. debugging a program more than once. They are stored separately for each program 
  1554. debugged. The file extension for the files that contain this information is 
  1555. @DR. 
  1556.  
  1557.  Select information 
  1558.            Select what information you want saved in the program profiles. 
  1559.  
  1560.  Delete program profiles 
  1561.            Delete program profiles for a program that you have debugged. 
  1562.  
  1563.  Change location 
  1564.            Change the location of the file that holds the program profiles. 
  1565.            This also moves any existing profiles to the new directory. 
  1566.  
  1567.  
  1568. ΓòÉΓòÉΓòÉ 3.1.5.7. Save debugger window positions ΓòÉΓòÉΓòÉ
  1569.  
  1570. When you select this choice, the window positions and sizes are saved for each 
  1571. type of debugger window currently open. 
  1572.  
  1573.  
  1574. ΓòÉΓòÉΓòÉ 3.1.5.8. Global font change ΓòÉΓòÉΓòÉ
  1575.  
  1576. Select the Global font change choice to change the font in all the debugger 
  1577. windows. 
  1578.  
  1579. When you select Global font change, the Font Selection window displays. 
  1580.  
  1581.  
  1582. ΓòÉΓòÉΓòÉ 3.1.5.9. Enable window cascading ΓòÉΓòÉΓòÉ
  1583.  
  1584. Select the Enable window cascading choice to have the debugging windows overlap 
  1585. each other. 
  1586.  
  1587. When you enable this choice, successive windows that are opened overlap each 
  1588. other on the screen.  However, they are cascaded so that you can see the 
  1589. underlying windows.  When this choice is disabled, successive windows cover 
  1590. previously displayed windows so that you do not see the underlying windows. 
  1591.  
  1592.  
  1593. ΓòÉΓòÉΓòÉ 3.1.5.10. Display tool buttons ΓòÉΓòÉΓòÉ
  1594.  
  1595. Select the Display tool buttons choice if you want tool buttons to be shown in 
  1596. all the debugger windows. 
  1597.  
  1598.  
  1599. ΓòÉΓòÉΓòÉ 3.1.5.11. Display hover help ΓòÉΓòÉΓòÉ
  1600.  
  1601. Select the Display hover help choice if you want hover help to be shown in all 
  1602. the debugger windows. 
  1603.  
  1604.  
  1605. ΓòÉΓòÉΓòÉ 3.1.5.12. Display infoarea ΓòÉΓòÉΓòÉ
  1606.  
  1607. Select the Display infoarea choice if you want the information area to be shown 
  1608. in all the debugger windows. 
  1609.  
  1610.  
  1611. ΓòÉΓòÉΓòÉ 3.1.5.13. Display tool buttons on title bar ΓòÉΓòÉΓòÉ
  1612.  
  1613. Select the Display tool buttons on title bar choice if you want the tool 
  1614. buttons to be shown on the title bar of each window. 
  1615.  
  1616.  
  1617. ΓòÉΓòÉΓòÉ 3.1.6. Windows Menu Choices ΓòÉΓòÉΓòÉ
  1618.  
  1619. Select the Windows menu from the Debug Session Control window to view a list of 
  1620. all the open debugger windows. By selecting a window from the Windows menu, it 
  1621. is brought into focus and made the active window. Also, if the window is 
  1622. minimized, it is restored. 
  1623.  
  1624.  
  1625. ΓòÉΓòÉΓòÉ 3.1.7. Help Menu Choices ΓòÉΓòÉΓòÉ
  1626.  
  1627. Select choices from the Help menu of the Debug Session Control window to 
  1628. display the various types of help information. 
  1629.  
  1630.  Help index             Displays an alphabetical index of all available 
  1631.                         debugger help topics. 
  1632.  
  1633.  General help           Displays help information for the active window. 
  1634.  
  1635.  Using help             Describes how to use the help facility. 
  1636.  
  1637.  Product information    Displays product information. 
  1638.  
  1639.  
  1640. ΓòÉΓòÉΓòÉ 3.2. Using the Source Windows ΓòÉΓòÉΓòÉ
  1641.  
  1642. A source window allows you to view the program you are debugging.  You can look 
  1643. at your source in one of the following windows: 
  1644.  
  1645.      Source 
  1646.      Disassembly 
  1647.      Mixed 
  1648.  
  1649.  A source window is thread specific.  Executable lines initially display in 
  1650.  blue, and non-executable lines initially display in black. Lines with 
  1651.  breakpoints have a red prefix, and lines with disabled breakpoints have a 
  1652.  green prefix. 
  1653.  
  1654.  The Source window displays the source code for the current function of the 
  1655.  program being debugged. If source is available, the Source window displays 
  1656.  with the Debug Session Control window when the debugging session starts. 
  1657.  Otherwise, the Disassembly window displays. 
  1658.  
  1659.  Source Window 
  1660.  
  1661.  The Disassembly window displays the assembler instructions for your program 
  1662.  without symbolic information. 
  1663.  
  1664.  Disassembly Window 
  1665.  
  1666.  The Mixed window displays your program as follows: 
  1667.  
  1668.      Each line of source code is prefixed by its line number as in the Source 
  1669.       window. 
  1670.      Each disassembled line is prefixed by an address as in the Disassembly 
  1671.       window. 
  1672.      Source comment lines also display. 
  1673.      The lines of source code are treated as comments within the lines of 
  1674.       disassembly code. You can only set breakpoints or run your program on 
  1675.       lines of disassembly code. 
  1676.  
  1677.  Note:  The Mixed window cannot be opened if the source code is not available. 
  1678.  
  1679.  Mixed Window 
  1680.  
  1681.  
  1682. ΓòÉΓòÉΓòÉ 3.2.1. File Menu Choices ΓòÉΓòÉΓòÉ
  1683.  
  1684. The choices in the File menu are a subset of those listed under the File menu 
  1685. of the Debug Session Control window. Refer to File Menu Choices for a 
  1686. description of the choices. 
  1687.  
  1688.  
  1689. ΓòÉΓòÉΓòÉ 3.2.2. View Menu Choices ΓòÉΓòÉΓòÉ
  1690.  
  1691. Select choices from the View menu to locate strings of text, scroll to a 
  1692. particular line, view include files, change the text file, or select a 
  1693. different view of your program. 
  1694.  
  1695.  
  1696. ΓòÉΓòÉΓòÉ 3.2.2.1. Find Window ΓòÉΓòÉΓòÉ
  1697.  
  1698. Displays the Find window which allows you to search for a text string. 
  1699.  
  1700. Find Window 
  1701.  
  1702. To use the Find window to search for a text string: 
  1703.  
  1704.    1. Type the text string you want to search for in the Text entry field. 
  1705.    2. Enable the Case sensitive check box if you want to search for the string 
  1706.       exactly as typed. Disable this check box to search for uppercase and 
  1707.       lowercase characters. 
  1708.    3. Select the OK push button. 
  1709.  
  1710.  The search string can have alphabetic and numeric characters, a maximum of 256 
  1711.  characters, and uppercase and lowercase characters. 
  1712.  
  1713.  
  1714. ΓòÉΓòÉΓòÉ 3.2.2.2. Find next ΓòÉΓòÉΓòÉ
  1715.  
  1716. Allows you to search for the next occurrence of the text string that you typed 
  1717. in the Find window. 
  1718.  
  1719.  
  1720. ΓòÉΓòÉΓòÉ 3.2.2.3. Scroll to line number... ΓòÉΓòÉΓòÉ
  1721.  
  1722. Displays the Scroll to Line Number window, which allows you to go to a 
  1723. particular line in your program or set a line breakpoint. 
  1724.  
  1725. Scroll to Line Number Window 
  1726.  
  1727. To use the Scroll to Line Number window to scroll to a specific line: 
  1728.  
  1729.    1. Type the line number you want to scroll to in the Line entry field. 
  1730.    2. Select the OK push button to scroll to that line. 
  1731.  
  1732.  Note:  If the Source window is active, just type a number and the Scroll to 
  1733.  Line Number window automatically displays. 
  1734.  
  1735.  To use the Scroll to Line Number window to set a breakpoint: 
  1736.  
  1737.    1. Type the line number you want to set the breakpoint on in the Line entry 
  1738.       field. 
  1739.    2. Select the Breakpoint push button to set the breakpoint on the specified 
  1740.       line number. 
  1741.  
  1742.  
  1743. ΓòÉΓòÉΓòÉ 3.2.2.4. Select include file ΓòÉΓòÉΓòÉ
  1744.  
  1745. Displays the Select Include window that allows you to view the files that are 
  1746. included in your program. 
  1747.  
  1748. Select Include Window 
  1749.  
  1750. To use the Select Include window: 
  1751.  
  1752.    1. Select the include file.  The include file name is highlighted. 
  1753.    2. Select the OK push button.  The selected include file view displays. 
  1754.  
  1755.  
  1756. ΓòÉΓòÉΓòÉ 3.2.2.5. Change text file ΓòÉΓòÉΓòÉ
  1757.  
  1758. Displays the Change Text File window, which allows you to specify a file name 
  1759. to be used as the source in the current view. This is useful if the debugger 
  1760. found the incorrect source file for your program so that you can specify the 
  1761. use of a different source file from a different directory. 
  1762.  
  1763. Change Text File Window 
  1764.  
  1765. Use the Change Text File window to replace the path name or file name of the 
  1766. program you are debugging with a new path name or file name. 
  1767.  
  1768. To replace the file name: 
  1769.  
  1770.    1. Type the new path name and file name in the File entry field. 
  1771.    2. Select the appropriate push button. 
  1772.  
  1773.  
  1774. ΓòÉΓòÉΓòÉ 3.2.2.6. Source ΓòÉΓòÉΓòÉ
  1775.  
  1776. Displays the Source window, which displays the source code for the current 
  1777. function of the program being debugged. 
  1778.  
  1779. Refer to Using the Source Windows for more information. 
  1780.  
  1781.  
  1782. ΓòÉΓòÉΓòÉ 3.2.2.7. Disassembly ΓòÉΓòÉΓòÉ
  1783.  
  1784. Displays the Disassembly window, which displays the assembler instructions for 
  1785. your program without symbolic information. 
  1786.  
  1787. Refer to Using the Source Windows for more information. 
  1788.  
  1789.  
  1790. ΓòÉΓòÉΓòÉ 3.2.2.8. Mixed ΓòÉΓòÉΓòÉ
  1791.  
  1792. Displays the Mixed window, which is a combination of the Source and Disassembly 
  1793. windows. 
  1794.  
  1795. Refer to Using the Source Windows for more information. 
  1796.  
  1797.  
  1798. ΓòÉΓòÉΓòÉ 3.2.3. Breakpoints Menu Choices ΓòÉΓòÉΓòÉ
  1799.  
  1800. The choices listed under the Breakpoints menu are the same as those listed for 
  1801. the Debug Session Control window with the addition of the Toggle at current 
  1802. line choice. 
  1803.  
  1804. The Toggle at current line choice sets a breakpoint on the current line or 
  1805. deletes an existing breakpoint from the current line. 
  1806.  
  1807. For a description of the other menu choices, refer to Breakpoints Menu Choices. 
  1808.  
  1809.  
  1810. ΓòÉΓòÉΓòÉ 3.2.4. Monitors Menu Choices ΓòÉΓòÉΓòÉ
  1811.  
  1812. Select choices from the Monitors menu of the source windows to monitor 
  1813. expressions or variables and view the other debugger windows such as call 
  1814. stack, registers, and so on. 
  1815.  
  1816. The next four choices listed under the Monitors menu are also accessible from 
  1817. the tool bar in the Debug Session Control Window. 
  1818.  
  1819.  
  1820. ΓòÉΓòÉΓòÉ 3.2.4.1. Monitor expression... ΓòÉΓòÉΓòÉ
  1821.  
  1822. Displays the Monitor Expression window, which allows you to monitor expressions 
  1823. or variables and add them to various monitor windows. 
  1824.  
  1825. Monitor Expression Window 
  1826.  
  1827. Use the Monitor Expression window to type the name of the expression you want 
  1828. to monitor. This window lists the following contextual information: 
  1829.  
  1830.      The component you are in. 
  1831.      The active line of the source code, which is highlighted. 
  1832.      The view of the module that is active. 
  1833.      The thread you are in. 
  1834.  
  1835.  To specify an expression to be monitored: 
  1836.  
  1837.    1. Type the name of the variable or expression you want to monitor in the 
  1838.       Expression entry field. 
  1839.    2. Select the appropriate radio button for the location from where you want 
  1840.       to monitor your expression. 
  1841.  
  1842.       Note:  The expression displays as specified in the Monitor Properties 
  1843.       window. To change the default location, select Monitor properties from 
  1844.       the Debugger settings choice from the Options menu in the source windows 
  1845.       or the Debug Session Control window. 
  1846.  
  1847.  
  1848. ΓòÉΓòÉΓòÉ 3.2.4.2. Call stack ΓòÉΓòÉΓòÉ
  1849.  
  1850. Displays the Call Stack window, which allows you to monitor the call stack for 
  1851. a particular thread. This window is described in Call Stack Window. 
  1852.  
  1853.  
  1854. ΓòÉΓòÉΓòÉ 3.2.4.3. Registers ΓòÉΓòÉΓòÉ
  1855.  
  1856. Displays the Registers window, which allows you to monitor registers and flags 
  1857. for a particular component or thread. This window is described in Using the 
  1858. Registers Window. 
  1859.  
  1860.  
  1861. ΓòÉΓòÉΓòÉ 3.2.4.4. Storage ΓòÉΓòÉΓòÉ
  1862.  
  1863. Displays the Storage window, which allows you to monitor the storage in your 
  1864. program. This window is described in Using the Storage Window. 
  1865.  
  1866.  
  1867. ΓòÉΓòÉΓòÉ 3.2.4.5. Local variables ΓòÉΓòÉΓòÉ
  1868.  
  1869. Displays the Local Variables window, which allows you to display the local 
  1870. variables for the program's current function. This window is described in Using 
  1871. the Local Variables Window. 
  1872.  
  1873.  
  1874. ΓòÉΓòÉΓòÉ 3.2.4.6. Passthru ΓòÉΓòÉΓòÉ
  1875.  
  1876. Displays the Passthru window, which allows you to send commands to KDB and 
  1877. displays the formatted KDB response. This window is described in Using the 
  1878. Passthru Window. 
  1879.  
  1880.  
  1881. ΓòÉΓòÉΓòÉ 3.2.5. Run Menu Choices ΓòÉΓòÉΓòÉ
  1882.  
  1883. Select choices from the Run menu to perform step commands, run your program or 
  1884. hide debugger windows. 
  1885.  
  1886.  
  1887. ΓòÉΓòÉΓòÉ 3.2.5.1. Step over ΓòÉΓòÉΓòÉ
  1888.  
  1889. Executes the current, highlighted line in the program.  If the line includes a 
  1890. function call, the debugger does not regain control until the function has 
  1891. returned. 
  1892.  
  1893.  
  1894. ΓòÉΓòÉΓòÉ 3.2.5.2. Step into ΓòÉΓòÉΓòÉ
  1895.  
  1896. Executes the current, highlighted line in the program. If the line includes a 
  1897. function call, the debugger regains control before the first statement in the 
  1898. function has been performed. 
  1899.  
  1900.  
  1901. ΓòÉΓòÉΓòÉ 3.2.5.3. Step debug ΓòÉΓòÉΓòÉ
  1902.  
  1903. Executes the current, highlighted line in the program. The debugger steps over 
  1904. any function for which debugging information is not available (for example, 
  1905. library and system routines) and steps into any function for which debugging 
  1906. information is available. 
  1907.  
  1908.  
  1909. ΓòÉΓòÉΓòÉ 3.2.5.4. Step return ΓòÉΓòÉΓòÉ
  1910.  
  1911. Automatically executes the lines of code up to, and including, the return 
  1912. statement of the current function. 
  1913.  
  1914.  
  1915. ΓòÉΓòÉΓòÉ 3.2.5.5. Run ΓòÉΓòÉΓòÉ
  1916.  
  1917. Runs the program. Control returns to the debugger when the program ends or 
  1918. execution stops at an enabled breakpoint. 
  1919.  
  1920.  
  1921. ΓòÉΓòÉΓòÉ 3.2.5.6. Halt ΓòÉΓòÉΓòÉ
  1922.  
  1923. Interrupts the program you are debugging. 
  1924.  
  1925.  
  1926. ΓòÉΓòÉΓòÉ 3.2.5.7. Run to location ΓòÉΓòÉΓòÉ
  1927.  
  1928. Executes your program from the current line up to the line that is highlighted 
  1929. or black in the prefix area. 
  1930.  
  1931. To use the Run to location choice: 
  1932.  
  1933.    1. Single-click in the prefix area of the line you want to become the 
  1934.       current line. The prefix area turns black. 
  1935.    2. Select the Run to location choice. The program runs up to the line that 
  1936.       you marked. 
  1937.  
  1938.  The Run to location choice stops only on executable lines. If a highlighted 
  1939.  line is not executable, the run is not performed. 
  1940.  
  1941.  
  1942. ΓòÉΓòÉΓòÉ 3.2.5.8. Jump to location ΓòÉΓòÉΓòÉ
  1943.  
  1944. Select the Jump to location choice to change the current line in your program 
  1945. without executing the lines between the present current line and the new 
  1946. current line. 
  1947.  
  1948. To use the Jump to location choice: 
  1949.  
  1950.    1. Single-click in the prefix area of the line you want to become the 
  1951.       current line. The prefix area turns gray. 
  1952.    2. Select the Jump to location choice. The current line is changed, and the 
  1953.       lines between are not executed. 
  1954.  
  1955.  The Jump to location choice stops only on executable lines. If a highlighted 
  1956.  line is not executable, the jump is not performed. 
  1957.  
  1958.  Warning: Jumping out of the current function may corrupt the call stack and 
  1959.  cause unpredictable results. 
  1960.  
  1961.  
  1962. ΓòÉΓòÉΓòÉ 3.2.5.9. Hide Debugger on Run ΓòÉΓòÉΓòÉ
  1963.  
  1964. For a description of this choice, refer to Hide Debugger on Run. 
  1965.  
  1966.  
  1967. ΓòÉΓòÉΓòÉ 3.2.6. Options Menu Choices ΓòÉΓòÉΓòÉ
  1968.  
  1969. Select choices from the Options menu to control how the debugger windows 
  1970. display. 
  1971.  
  1972.  
  1973. ΓòÉΓòÉΓòÉ 3.2.6.1. Window settings-> ΓòÉΓòÉΓòÉ
  1974.  
  1975. Use the Window settings cascading choices to modify the characteristics of the 
  1976. source windows. 
  1977.  
  1978.  Colors...              Displays the Source Window Controls window, which 
  1979.                         allows you to change the color in the windows. 
  1980.  
  1981.  Fonts...               Displays the Font window, which allows you to change 
  1982.                         the font in the windows. 
  1983.  
  1984.  Restore defaults       Resets all of the window settings to their original 
  1985.                         settings. 
  1986.  
  1987.  Notebook               Displays the source windows in a notebook format. 
  1988.  
  1989.  Tool buttons           Enables or disables tool buttons. 
  1990.  
  1991.  Hover help             Enables or disables hover help. 
  1992.  
  1993.  Infoarea               Enables or disables the information area. 
  1994.  
  1995.  
  1996. ΓòÉΓòÉΓòÉ 3.2.6.2. Debugger settings-> ΓòÉΓòÉΓòÉ
  1997.  
  1998. Use the Debugger settings cascaded choices to set various debugger options that 
  1999. control how the debugger windows display. These settings affect the behavior of 
  2000. the debugger and remain in effect for the duration of the debugging session. 
  2001.  
  2002. Refer to Debugger settings-> for a description of the choices. 
  2003.  
  2004.  
  2005. ΓòÉΓòÉΓòÉ 3.2.7. Windows Menu Choices ΓòÉΓòÉΓòÉ
  2006.  
  2007. Select the Windows menu of the source windows to view a list of all the open 
  2008. debugger windows. By selecting a window from the Windows menu, it is brought 
  2009. into focus and made the active window. Also, if the window is minimized, it is 
  2010. restored. 
  2011.  
  2012.  
  2013. ΓòÉΓòÉΓòÉ 3.2.8. Help Menu Choices ΓòÉΓòÉΓòÉ
  2014.  
  2015. Select choices from the Help menu of the source windows to display the various 
  2016. types of help information. 
  2017.  
  2018. Refer to Help Menu Choices for a description of the help choices. 
  2019.  
  2020.  
  2021. ΓòÉΓòÉΓòÉ 4. Introducing the Other Debugging Windows ΓòÉΓòÉΓòÉ
  2022.  
  2023. This section introduces the basic debugging windows.  These are the windows 
  2024. that are normally located in the Monitors menu of the Debug Session Control and 
  2025. the source windows. The windows include call stack, registers, storage, local 
  2026. variables, and passthru. 
  2027.  
  2028.  
  2029. ΓòÉΓòÉΓòÉ 4.1. Using the Call Stack Window ΓòÉΓòÉΓòÉ
  2030.  
  2031. The Call Stack window lists all of the active functions for a particular thread 
  2032. including system calls. 
  2033.  
  2034. Call Stack Window 
  2035.  
  2036. Each Call Stack window displays call stack information for one thread only. 
  2037. When the state of the program changes, such as when you execute the program or 
  2038. you update displayed data, the Call Stack window changes to reflect the current 
  2039. state. You can double-click on any call stack entry to display the source code 
  2040. for that entry. The line that calls the next stack entry is highlighted. The 
  2041. remaining stack size shows the bytes left in the stack for the thread. 
  2042.  
  2043. Note:  The stack may not display correctly if the code does not follow standard 
  2044. calling conventions or if you step into optimized code. 
  2045.  
  2046. To display the Call Stack window, select Call Stack from the Monitors menu or 
  2047. select the Call Stack button  from the tool bar. 
  2048.  
  2049.  
  2050. ΓòÉΓòÉΓòÉ 4.1.1. File Menu Choice ΓòÉΓòÉΓòÉ
  2051.  
  2052. Use the choice from the File menu to end the debugging session. 
  2053.  
  2054. The Close debugger choice allows you to end the current debugging session. 
  2055. When you select Close debugger, the Close Debugger message box prompts you to 
  2056. confirm that you want to end the debugging session. 
  2057.  
  2058.  
  2059. ΓòÉΓòÉΓòÉ 4.1.2. Options Menu Choices ΓòÉΓòÉΓòÉ
  2060.  
  2061. Use choices from the Options menu to select the font you want for the Call 
  2062. Stack window and control how the items on the call stack display. 
  2063.  
  2064.  
  2065. ΓòÉΓòÉΓòÉ 4.1.2.1. Fonts... ΓòÉΓòÉΓòÉ
  2066.  
  2067. Displays the Font window, which allows you to select the type of font you want 
  2068. to use for the Call Stack window. 
  2069.  
  2070.  
  2071. ΓòÉΓòÉΓòÉ 4.1.2.2. Display style... ΓòÉΓòÉΓòÉ
  2072.  
  2073. Displays the Display Style window, which allows you to select the type of 
  2074. information you want displayed in the call stack and choose how the items are 
  2075. to be displayed. 
  2076.  
  2077. Display Style Window 
  2078.  
  2079. To use the Display Style window: 
  2080.  
  2081.      Select one or more of the items under Select Items to display for each 
  2082.       call stack entry. Each item causes a new column to be added to the Call 
  2083.       Stack window. 
  2084.  
  2085.       The following items are available: 
  2086.       Entry No                      Represents the position of the call stack 
  2087.                                     item in the list. Entry level 1 is the 
  2088.                                     first function started. 
  2089.  
  2090.       Function                      Lists program name or the address of the 
  2091.                                     function call that created the new call 
  2092.                                     stack entry. 
  2093.  
  2094.       Source                        Lists the component name that contains the 
  2095.                                     function. The name displayed corresponds 
  2096.                                     with a name listed in the Components list 
  2097.                                     box in the Debug Session Control window. 
  2098.  
  2099.       Ring                          Tells the ring level (0, 2, or 3) at which 
  2100.                                     this frame is established. 
  2101.  
  2102.       Return Address                Indicates where execution will return in 
  2103.                                     that function. 
  2104.  
  2105.       Recursion                     Lists the recursion level.  0 is the first 
  2106.                                     invocation. 
  2107.  
  2108.       Frame Address                 Indicates the start of the call stack frame 
  2109.                                     for that function. 
  2110.  
  2111.       Variable Base                 Indicates the end of the call stack frame 
  2112.                                     for that function. 
  2113.  
  2114.       Size                          Indicates the size of the call stack frame 
  2115.                                     for that function. 
  2116.      Select one of the following Growth Direction radio buttons to determine 
  2117.       how new items are displayed on the call stack. 
  2118.       Up             Displays new items at the top of the Call Stack window. 
  2119.  
  2120.       Down           Displays new items at the bottom of the Call Stack window. 
  2121.  
  2122.       Enable the Unwind rings check box to have the debugger unwind the call 
  2123.       stack across ring (privilege) transitions.  This allows you to view the 
  2124.       call sequence from user applications into the kernel. 
  2125.  
  2126.  
  2127. ΓòÉΓòÉΓòÉ 4.1.2.3. Restore defaults ΓòÉΓòÉΓòÉ
  2128.  
  2129. Select the Restore defaults choice to reset all of the window settings to their 
  2130. original settings. 
  2131.  
  2132.  
  2133. ΓòÉΓòÉΓòÉ 4.1.2.4. Tool buttons ΓòÉΓòÉΓòÉ
  2134.  
  2135. Select the Tool buttons choice to enable or disable tool buttons. 
  2136.  
  2137. If enabled, the tool buttons are displayed in the window.  If disabled, the 
  2138. tool buttons are not displayed. 
  2139.  
  2140.  
  2141. ΓòÉΓòÉΓòÉ 4.1.2.5. Hover help ΓòÉΓòÉΓòÉ
  2142.  
  2143. Select the Hover help choice if you want hover help to be shown. 
  2144.  
  2145.  
  2146. ΓòÉΓòÉΓòÉ 4.1.2.6. Infoarea ΓòÉΓòÉΓòÉ
  2147.  
  2148. Select the Infoarea choice if you want the information area to be shown in the 
  2149. window. 
  2150.  
  2151.  
  2152. ΓòÉΓòÉΓòÉ 4.1.3. Windows Menu Choices ΓòÉΓòÉΓòÉ
  2153.  
  2154. Select the Windows menu of the Call Stack window to view a list of all the open 
  2155. debugger windows. By selecting a window from the Windows menu, it is brought 
  2156. into focus and made the active window. Also, if the window is minimized, it is 
  2157. restored. 
  2158.  
  2159.  
  2160. ΓòÉΓòÉΓòÉ 4.1.4. Help Menu Choices ΓòÉΓòÉΓòÉ
  2161.  
  2162. Select choices from the Help menu of the Call Stack window to display the 
  2163. various types of help information. 
  2164.  
  2165. Refer to Help Menu Choices for a description of the help choices. 
  2166.  
  2167.  
  2168. ΓòÉΓòÉΓòÉ 4.2. Using the Registers Window ΓòÉΓòÉΓòÉ
  2169.  
  2170. The Registers window lists all the processor registers for a particular thread. 
  2171. The contents of all of the registers except floating-point registers are 
  2172. displayed in hexadecimal.  To update a register, double-click on the register 
  2173. and a multiple-line entry field displays. Type over the contents and press 
  2174. Enter. 
  2175.  
  2176. Registers Window 
  2177.  
  2178. In the Registers window, floating-point registers display as floating-point 
  2179. decimal numbers.  They can be updated with a floating-point decimal number or 
  2180. with a hexadecimal string that represents a floating-point number. 
  2181.  
  2182. To display the processor registers and flags, select Registers from the 
  2183. Monitors menu or select the Registers button  from the tool bar. 
  2184.  
  2185.  
  2186. ΓòÉΓòÉΓòÉ 4.2.1. File Menu Choices ΓòÉΓòÉΓòÉ
  2187.  
  2188. Use the choice from the File menu to end the debugging session. 
  2189.  
  2190. The Close debugger choice allows you to end the current debugging session. 
  2191. When you select Close debugger, the Close Debugger message box prompts you to 
  2192. confirm that you want to end the debugging session. 
  2193.  
  2194.  
  2195. ΓòÉΓòÉΓòÉ 4.2.2. Options Menu Choice ΓòÉΓòÉΓòÉ
  2196.  
  2197. Use the choices from the Options menu to select the font you want for the 
  2198. Registers window, select the items you want shown in the window, restore the 
  2199. defaults, and enable or disable the tool buttons. 
  2200.  
  2201.  
  2202. ΓòÉΓòÉΓòÉ 4.2.2.1. Fonts... ΓòÉΓòÉΓòÉ
  2203.  
  2204. When you select Fonts..., the Font window displays. From this window, select 
  2205. the font you want shown in the Registers window. 
  2206.  
  2207.  
  2208. ΓòÉΓòÉΓòÉ 4.2.2.2. Display style... ΓòÉΓòÉΓòÉ
  2209.  
  2210. When you select the Display style... choice, the Display Style window is 
  2211. displayed, which allows you to select the type of information you want 
  2212. displayed in the Registers window. 
  2213.  
  2214. Display Style Window 
  2215.  
  2216. Groups Group Heading 
  2217.  
  2218. This specifies the five types of registers that the debugger displays. General 
  2219. registers are as follows: 
  2220.  
  2221.      EIP 
  2222.      EAX 
  2223.      EBX 
  2224.      ECX 
  2225.      EDX 
  2226.      EBP 
  2227.      ESP 
  2228.      ESI 
  2229.      EDI 
  2230.  
  2231.  Status Flags registers include the PC and the EFLAGS registers. Segment 
  2232.  registers are as follows: 
  2233.  
  2234.      CS 
  2235.      DS 
  2236.      ES 
  2237.      FS 
  2238.      GS 
  2239.      SS 
  2240.  
  2241.  The PC register is the linear address of the current instruction. The FP stack 
  2242.  registers are those defined by the math coprocessor.  The Debug registers 
  2243.  include miscellaneous processor registers such as CR0 and DR0. 
  2244.  
  2245.  Orientation Heading 
  2246.  
  2247.  The registers groups are separated with either vertical or horizontal split 
  2248.  bars.  Select the radio button which represents how you want the groups 
  2249.  separated. 
  2250.  
  2251.  Enable the Column titles check box if you want the registers group to have a 
  2252.  title.  For example, General. 
  2253.  
  2254.  Enable the Save split bars check box if you want to save the adjustment of the 
  2255.  split bars for the next time you open the Registers window. 
  2256.  
  2257.  
  2258. ΓòÉΓòÉΓòÉ 4.2.2.3. Restore defaults ΓòÉΓòÉΓòÉ
  2259.  
  2260. Select the Restore defaults choice to reset all of the window settings to their 
  2261. original settings. 
  2262.  
  2263.  
  2264. ΓòÉΓòÉΓòÉ 4.2.2.4. Tool buttons ΓòÉΓòÉΓòÉ
  2265.  
  2266. Select the Tool buttons choice to enable or disable tool buttons. 
  2267.  
  2268. If enabled, the tool buttons are displayed in the window.  If disabled, the 
  2269. tool buttons are not displayed. 
  2270.  
  2271.  
  2272. ΓòÉΓòÉΓòÉ 4.2.2.5. Hover help ΓòÉΓòÉΓòÉ
  2273.  
  2274. Select the Hover help choice to enable or disable hover help. 
  2275.  
  2276. If enabled, hover help is displayed in the window.  If disabled, hover help is 
  2277. not displayed. 
  2278.  
  2279.  
  2280. ΓòÉΓòÉΓòÉ 4.2.2.6. Infoarea ΓòÉΓòÉΓòÉ
  2281.  
  2282. Select the Infoarea choice to enable or disable the information area. 
  2283.  
  2284. If enabled, the infoarea is displayed in the window.  If disabled, the infoarea 
  2285. is not displayed. 
  2286.  
  2287.  
  2288. ΓòÉΓòÉΓòÉ 4.2.3. Windows Menu Choices ΓòÉΓòÉΓòÉ
  2289.  
  2290. Select the Windows menu from the Registers window to view a list of all the 
  2291. open debugger windows. By selecting a window from the Windows menu, it is 
  2292. brought into focus and made the active window. Also, if the window is 
  2293. minimized, it is restored. 
  2294.  
  2295.  
  2296. ΓòÉΓòÉΓòÉ 4.2.4. Help Menu Choices ΓòÉΓòÉΓòÉ
  2297.  
  2298. Select choices from the Help menu of the  Registers window to display the 
  2299. various types of help information. 
  2300.  
  2301. Refer to Help Menu Choices for a description of the help choices. 
  2302.  
  2303.  
  2304. ΓòÉΓòÉΓòÉ 4.3. Using the Storage Window ΓòÉΓòÉΓòÉ
  2305.  
  2306. The Storage window shows the storage contents and the address of the storage. 
  2307.  
  2308. Storage Window 
  2309.  
  2310. Multiple storage windows can display the same storage. When you run a program 
  2311. or update displayed data, the Storage window is updated to reflect the change. 
  2312.  
  2313. To update the storage contents and all affected windows, double-click in the 
  2314. multiple-line entry field that displays. Type over the contents of the field. 
  2315.  
  2316. To specify a new address location, type over the address field in the Storage 
  2317. window. The window scrolls to the appropriate storage location. 
  2318.  
  2319. To display the Storage window, select Storage from the Monitors menu or select 
  2320. the Storage button from the tool buttons. 
  2321.  
  2322.  
  2323. ΓòÉΓòÉΓòÉ 4.3.1. File Menu Choice ΓòÉΓòÉΓòÉ
  2324.  
  2325. Use the choice from the File menu to end the debugging session. 
  2326.  
  2327. The Close debugger choice allows you to end the current debugging session. 
  2328. When you select Close debugger, the Close Debugger message box prompts you to 
  2329. confirm that you want to end the debugging session. 
  2330.  
  2331.  
  2332. ΓòÉΓòÉΓòÉ 4.3.2. Options Menu Choices ΓòÉΓòÉΓòÉ
  2333.  
  2334. Use choices from the Options menu to monitor expressions, control how the items 
  2335. in the storage window display, and select the font you want for the Storage 
  2336. window. 
  2337.  
  2338.  
  2339. ΓòÉΓòÉΓòÉ 4.3.2.1. Fonts... ΓòÉΓòÉΓòÉ
  2340.  
  2341. Displays the Font window, which allows you to select the type of font you want 
  2342. to use for the Storage window. 
  2343.  
  2344.  
  2345. ΓòÉΓòÉΓòÉ 4.3.2.2. Display style... ΓòÉΓòÉΓòÉ
  2346.  
  2347. Displays the Display Style window, which allows you to select the format for 
  2348. the storage contents and storage addresses and change the columns per line that 
  2349. display. 
  2350.  
  2351. Display Style Window 
  2352.  
  2353. Use the Storage Display Style window to select the parameters that control how 
  2354. the storage contents display and set how the storage addresses display. 
  2355.  
  2356. Content Style Group Heading 
  2357.  
  2358. Select how you want the storage contents displayed. You can select from several 
  2359. storage display styles. 
  2360.  
  2361. To select the storage content style: 
  2362.  
  2363.    1. Scroll to the content style you want. 
  2364.    2. Select the content style. 
  2365.    3. The style becomes highlighted. 
  2366.  
  2367.  Address Style Group Heading 
  2368.  
  2369.  Select the available address style. 
  2370.  
  2371.  To select the address style: 
  2372.  
  2373.    1. Select the address style. 
  2374.    2. The address style becomes highlighted. 
  2375.  
  2376.  Columns per line Entry Field 
  2377.  
  2378.  Select the number of columns per line you want displayed in the Storage 
  2379.  window. 
  2380.  
  2381.  Use the Up or Down arrow keys to select the number of columns you want 
  2382.  displayed in the Storage window. The available number of columns per line are 
  2383.  1-16. 
  2384.  
  2385.  Enable the Column titles check box if you want to display the titles of the 
  2386.  columns in the Storage window. 
  2387.  
  2388.  
  2389. ΓòÉΓòÉΓòÉ 4.3.2.3. Fill Storage... ΓòÉΓòÉΓòÉ
  2390.  
  2391. Displays the Storage Fill Dialog window, which allows you to fill memory with a 
  2392. specific character or hexadecimal pattern. 
  2393.  
  2394. Fill Storage Dialog Window 
  2395.  
  2396. To fill memory with a specific character or hexadecimal pattern: 
  2397.  
  2398.    1. Type the starting address of the memory area to fill in the Starting 
  2399.       Address entry field. 
  2400.  
  2401.    2. Type the ending address of the area or the length of the area to fill in 
  2402.       the corresponding entry field. 
  2403.  
  2404.    3. Select either Character or Hexadecimal as the string type. 
  2405.  
  2406.    4. Type the fill string in the Repeated String, Character or Byte(s) field. 
  2407.       This string is repeated as necessary to fill the specified area. 
  2408.  
  2409.  
  2410. ΓòÉΓòÉΓòÉ 4.3.2.4. Monitor expression... ΓòÉΓòÉΓòÉ
  2411.  
  2412. Displays the Monitor Expression in Storage window, which allows you to type in 
  2413. the name of the expression you want to monitor. 
  2414.  
  2415. Monitor Expression in Storage Window 
  2416.  
  2417. To specify an expression, type the name or address of the variable or 
  2418. expression you want to monitor in the Expression entry field. 
  2419.  
  2420. The expression evaluator used is based on the context.  For example if you 
  2421. display the Storage window by selecting the Monitor expression... choice from 
  2422. the Monitors menu, the evaluator used is based on the context in the Monitor 
  2423. Expression window.  However, if you display the Storage window first and then 
  2424. select the Monitor expression... choice from the Options menu of the Storage 
  2425. window, the evaluator used is based on the context of the stopping thread. 
  2426.  
  2427. Note:  You cannot look at variables that have been defined using the #DEFINE 
  2428. preprocessor directive. If the variable is not in scope when the monitor is 
  2429. opened, the default address is displayed.  If the variable goes out of scope, 
  2430. the address is changed to a hex constant. 
  2431.  
  2432. If you enable the Enabled monitor check box, the monitor updates the stop value 
  2433. of the program to the actual value in storage. However, a disabled monitor 
  2434. suspends this updating and reflects the stop value or the value held when the 
  2435. monitor was disabled. 
  2436.  
  2437.  
  2438. ΓòÉΓòÉΓòÉ 4.3.2.5. Restore defaults ΓòÉΓòÉΓòÉ
  2439.  
  2440. Select the Restore defaults choice to reset all of the window settings to their 
  2441. original settings. 
  2442.  
  2443.  
  2444. ΓòÉΓòÉΓòÉ 4.3.2.6. Tool buttons ΓòÉΓòÉΓòÉ
  2445.  
  2446. Select the Tool buttons choice if you want tool buttons. 
  2447.  
  2448.  
  2449. ΓòÉΓòÉΓòÉ 4.3.2.7. Hover help ΓòÉΓòÉΓòÉ
  2450.  
  2451. Select the Hover help choice if you want hover help. 
  2452.  
  2453.  
  2454. ΓòÉΓòÉΓòÉ 4.3.2.8. Infoarea ΓòÉΓòÉΓòÉ
  2455.  
  2456. Select the Infoarea choice if you want the information area to be shown in the 
  2457. window. 
  2458.  
  2459.  
  2460. ΓòÉΓòÉΓòÉ 4.3.3. Windows Menu Choices ΓòÉΓòÉΓòÉ
  2461.  
  2462. Select the Windows menu from the Storage window to view a list of all the open 
  2463. debugger windows. By selecting a window from the Windows menu, it is brought 
  2464. into focus and made the active window. Also, if the window is minimized, it is 
  2465. restored. 
  2466.  
  2467.  
  2468. ΓòÉΓòÉΓòÉ 4.3.4. Help Menu Choices ΓòÉΓòÉΓòÉ
  2469.  
  2470. Select choices from the Help menu of the Storage window to display the various 
  2471. types of help information. 
  2472.  
  2473. Refer to Help Menu Choices for a description of the help choices. 
  2474.  
  2475.  
  2476. ΓòÉΓòÉΓòÉ 4.4. Using the Local Variables Window ΓòÉΓòÉΓòÉ
  2477.  
  2478. The Local Variables window monitors the local variables (static, automatic, and 
  2479. parameters) for the current execution point in the program.  The contents of 
  2480. the Local Variables window change each time your program enters or leaves a 
  2481. function. 
  2482.  
  2483. Local Variables Window 
  2484.  
  2485.  
  2486. ΓòÉΓòÉΓòÉ 4.4.1. File Menu Choice ΓòÉΓòÉΓòÉ
  2487.  
  2488. Use the choice from the File menu to end the debugging session. 
  2489.  
  2490. The Close debugger choice allows you to end the current debugging session. 
  2491. When you select Close debugger, the Close Debugger message box prompts you to 
  2492. confirm that you want to end the debugging session. 
  2493.  
  2494.  
  2495. ΓòÉΓòÉΓòÉ 4.4.2. Edit Menu Choices ΓòÉΓòÉΓòÉ
  2496.  
  2497. Select the choices from the Edit menu of the Local Variables window to delete, 
  2498. select, deselect, show other elements, or change representation of the 
  2499. variables. 
  2500.  
  2501.  
  2502. ΓòÉΓòÉΓòÉ 4.4.2.1. Delete ΓòÉΓòÉΓòÉ
  2503.  
  2504. Select the Delete choice to delete variables or expressions that are being 
  2505. monitored from a monitor window. 
  2506.  
  2507. To delete a variable or expression from a monitor window: 
  2508.  
  2509.    1. Select the variable or expression using your mouse pointer. The variable 
  2510.       or expression becomes highlighted. 
  2511.    2. Select the Delete choice from the Edit menu. 
  2512.  
  2513.  
  2514. ΓòÉΓòÉΓòÉ 4.4.2.2. Select all ΓòÉΓòÉΓòÉ
  2515.  
  2516. Select the Select all choice to select all the expressions in the window. 
  2517.  
  2518.  
  2519. ΓòÉΓòÉΓòÉ 4.4.2.3. Deselect all ΓòÉΓòÉΓòÉ
  2520.  
  2521. Select the Deselect all choice to cancel the selection of all the expressions 
  2522. in the window, 
  2523.  
  2524.  
  2525. ΓòÉΓòÉΓòÉ 4.4.2.4. Other elements... ΓòÉΓòÉΓòÉ
  2526.  
  2527. Select the Other elements choice to view the next n items (classes, arrays, or 
  2528. structures) that are related to the variable or expression that you are 
  2529. monitoring. Currently, n defaults to 50.  You can override this number by 
  2530. setting the environment variable DEBUG_NUMBEROFELEMENTS.  For example, you 
  2531. would type the following to change it to 100: 
  2532.  
  2533.    set DEBUG_NUMBEROFELEMENTS=100
  2534.  
  2535. You can also change this number dynamically in the Number of elements to show 
  2536. field by selecting Options -> Debugger settings -> Monitor properties from the 
  2537. Debug Session Control window or any of the source windows. 
  2538.  
  2539.  
  2540. ΓòÉΓòÉΓòÉ 4.4.2.5. Representation-> ΓòÉΓòÉΓòÉ
  2541.  
  2542. Use the Representation cascading choices to display the contents of the 
  2543. variable in a new representation. The types of representation that display on 
  2544. the menu depend on the data type of the variable you are monitoring. 
  2545.  
  2546. The following are possible representations: 
  2547.  
  2548.  Hexadecimal 
  2549.    Displays the contents of the monitored variable in hexadecimal notation. 
  2550.  
  2551.  Decimal 
  2552.    Displays the contents of the monitored variable in decimal notation. 
  2553.  
  2554.  String 
  2555.    Displays the contents of the monitored variable as a character string. 
  2556.  
  2557.  Hexadecimal pointer 
  2558.    Displays the contents of the monitored variable as a hexadecimal pointer. 
  2559.  
  2560.  Decimal pointer 
  2561.    Displays the contents of the monitored variable as a decimal pointer. 
  2562.  
  2563.  Array 
  2564.    Displays the contents of the monitored variable as an array. 
  2565.  
  2566.  Floating/point 
  2567.    Displays the contents of the monitored variable in floating-point notation. 
  2568.  
  2569.  Character 
  2570.    Displays the contents of the monitored variable in character form. 
  2571.  
  2572.  Note:  Floating-point registers or variables display as either a 
  2573.  floating-point decimal number or as a hexadecimal string. However, they cannot 
  2574.  be updated with a hexadecimal string that represents a floating-point number. 
  2575.  If you need to update a floating-point variable with a hexadecimal 
  2576.  representation of a floating-point number, you must step through the 
  2577.  Disassembly window to see when the variable loads into a register and then 
  2578.  change the value in the Registers window. 
  2579.  
  2580.  
  2581. ΓòÉΓòÉΓòÉ 4.4.2.6. Copy to clipboard ΓòÉΓòÉΓòÉ
  2582.  
  2583. Select the Copy to clipboard choice to copy the selected (highlighted) local 
  2584. variable data to the clipboard. 
  2585.  
  2586.  
  2587. ΓòÉΓòÉΓòÉ 4.4.2.7. Save window in file ΓòÉΓòÉΓòÉ
  2588.  
  2589. Select the Save window in file choice to save the Local Variables window 
  2590. contents in a file.  You can choose the file name by selecting Options -> 
  2591. Debugger settings -> Monitor properties from the Debug Session Control window 
  2592. or any of the source windows and filling in the Save File entry field. 
  2593.  
  2594.  
  2595. ΓòÉΓòÉΓòÉ 4.4.3. Options Menu Choices ΓòÉΓòÉΓòÉ
  2596.  
  2597. Select choices from the Options menu to control how the contents of variables 
  2598. display and set debugger options. 
  2599.  
  2600.  
  2601. ΓòÉΓòÉΓòÉ 4.4.3.1. Fonts... ΓòÉΓòÉΓòÉ
  2602.  
  2603. Displays the Font window, which allows you to select the type of font you want 
  2604. to use for the Local Variables window. 
  2605.  
  2606.  
  2607. ΓòÉΓòÉΓòÉ 4.4.3.2. Restore defaults ΓòÉΓòÉΓòÉ
  2608.  
  2609. Select the Restore defaults choice to reset all of the window settings to their 
  2610. original settings. 
  2611.  
  2612.  
  2613. ΓòÉΓòÉΓòÉ 4.4.3.3. Show context ΓòÉΓòÉΓòÉ
  2614.  
  2615. Select the Show context choice to display the contextual information for the 
  2616. variable you are monitoring. The following information displays: comapct. 
  2617.  
  2618.      Source 
  2619.  
  2620.      File 
  2621.  
  2622.      Line 
  2623.  
  2624.      Thread. 
  2625.  
  2626.  
  2627. ΓòÉΓòÉΓòÉ 4.4.3.4. Tool buttons ΓòÉΓòÉΓòÉ
  2628.  
  2629. Select the Tool buttons choice if you want tool buttons. 
  2630.  
  2631.  
  2632. ΓòÉΓòÉΓòÉ 4.4.3.5. Hover help ΓòÉΓòÉΓòÉ
  2633.  
  2634. Select the Hover help choice if you want hover help. 
  2635.  
  2636.  
  2637. ΓòÉΓòÉΓòÉ 4.4.3.6. Infoarea ΓòÉΓòÉΓòÉ
  2638.  
  2639. Select the Infoarea choice if you want the information area to be shown in the 
  2640. window. 
  2641.  
  2642.  
  2643. ΓòÉΓòÉΓòÉ 4.4.4. Windows Menu Choices ΓòÉΓòÉΓòÉ
  2644.  
  2645. Select the Windows menu from the Local Variables window to view a list of all 
  2646. the open debugger windows. By selecting a window from the Windows menu, it is 
  2647. brought into focus and made the active window. Also, if the window is 
  2648. minimized, it is restored. 
  2649.  
  2650.  
  2651. ΓòÉΓòÉΓòÉ 4.4.5. Help Menu Choices ΓòÉΓòÉΓòÉ
  2652.  
  2653. Select choices from the Help menu of the Local Variables window to display the 
  2654. various types of help information. 
  2655.  
  2656. Refer to Help Menu Choices for a description of the help choices. 
  2657.  
  2658.  
  2659. ΓòÉΓòÉΓòÉ 4.5. Using the Passthru Window ΓòÉΓòÉΓòÉ
  2660.  
  2661. The Passthru window allows you to send commands to KDB and view its responses. 
  2662. The window is divided into two areas.  The Command entry field area is where 
  2663. you enter the KDB commands, and the response area is used to display the KDB 
  2664. output. 
  2665.  
  2666. The KDB response area is scrollable, which allows you to review previous KDB 
  2667. responses from prior commands.  This output area also appends a status icon for 
  2668. each line to indicate your input, the debugger's acceptance of that input, and 
  2669. text from KDB. 
  2670.  
  2671. Note:  When you send KDB commands using the Passthru window, the debugger does 
  2672. not update its state.  Thus, you should use this window for obtaining 
  2673. information instead of altering registers or data. 
  2674.  
  2675. Passthru Window 
  2676.  
  2677. To send a command to KDB, do the following: 
  2678.  
  2679.    1. Type the command you want to send in the Command entry field. 
  2680.    2. Select the Send push button.  You can also press the Enter key if the 
  2681.       Enter key performs send function check box is enabled in the Display 
  2682.       Style window. 
  2683.    3. Select the Resync button to force the debugger to refresh all of its 
  2684.       internal caches of the victim machine state.  Use this button if you used 
  2685.       the Passthru window to alter the state on the victim machine. 
  2686.  
  2687.  Note:  Commands that cause the victim machine to resume execution (for 
  2688.  example, g and t) should be avoided.  They can cause the debugger to lock up. 
  2689.  The debugger tries to filter out the KDB commands that can cause a lockup, but 
  2690.  you should always exercise caution. 
  2691.  
  2692.  
  2693. ΓòÉΓòÉΓòÉ 4.5.1. REXX Command Files ΓòÉΓòÉΓòÉ
  2694.  
  2695. The debugger supports the execution of DEBUGO REXX command files. To start a 
  2696. DEBUGO REXX command file, specify an * before the command filename in the 
  2697. Command entry field. For example: 
  2698.  
  2699.    * memcount.cmd
  2700. would trigger the execution of the DEBUGO REXX command file memcount.cmd. 
  2701.  
  2702.  
  2703. ΓòÉΓòÉΓòÉ 4.5.2. File Menu Choice ΓòÉΓòÉΓòÉ
  2704.  
  2705. Use the choice from the File menu to end the debugging session. 
  2706.  
  2707. The Close debugger choice allows you to end the current debugging session. 
  2708. When you select Close debugger, the Close Debugger message box prompts you to 
  2709. confirm that you want to end the debugging session. 
  2710.  
  2711.  
  2712. ΓòÉΓòÉΓòÉ 4.5.3. Edit Menu Choices ΓòÉΓòÉΓòÉ
  2713.  
  2714. Select the choices from the Edit menu to edit lines in the response area, 
  2715. delete a line in the response area, or delete all the lines in the response 
  2716. area of the Passthru window. 
  2717.  
  2718.  
  2719. ΓòÉΓòÉΓòÉ 4.5.3.1. Edit ΓòÉΓòÉΓòÉ
  2720.  
  2721. Select the Edit choice to edit a line in the response area of the Passthru 
  2722. window. 
  2723.  
  2724. To edit a line: 
  2725.  
  2726.    1. Highlight the line you want to edit. 
  2727.    2. Select the Edit choice. 
  2728.  
  2729.  
  2730. ΓòÉΓòÉΓòÉ 4.5.3.2. Delete ΓòÉΓòÉΓòÉ
  2731.  
  2732. Select the Delete choice to delete a line in the response area of the Passthru 
  2733. window. 
  2734.  
  2735. To delete a line: 
  2736.  
  2737.    1. Highlight the line you want to delete. 
  2738.    2. Select the Delete choice. 
  2739.  
  2740.  
  2741. ΓòÉΓòÉΓòÉ 4.5.3.3. Delete all ΓòÉΓòÉΓòÉ
  2742.  
  2743. Select the Delete all choice to delete all the lines in the response area of 
  2744. the Passthru window. 
  2745.  
  2746. To delete all the lines in the response area: 
  2747.  
  2748.    1. Select the Delete all choice. When you select the Delete all choice, a 
  2749.       message box prompts you to confirm that you want to delete all the lines. 
  2750.    2. Select Yes. 
  2751.  
  2752.  
  2753. ΓòÉΓòÉΓòÉ 4.5.3.4. Find ΓòÉΓòÉΓòÉ
  2754.  
  2755. Select the Find choice to search for a text string in the active window. 
  2756.  
  2757. To find a text string: 
  2758.  
  2759.    1. Type in the string of text you want to find in the Text entry field. 
  2760.    2. Enable the Case sensitive check box if you want to search for the string 
  2761.       exactly as typed.  Disable this check box to search for uppercase and 
  2762.       lowercase characters. 
  2763.    3. Select the OK push button. 
  2764.  
  2765.  
  2766. ΓòÉΓòÉΓòÉ 4.5.3.5. Find Next ΓòÉΓòÉΓòÉ
  2767.  
  2768. Select Find Next to search for the next occurrence of the text string that you 
  2769. typed in the Find window. 
  2770.  
  2771.  
  2772. ΓòÉΓòÉΓòÉ 4.5.4. Options Menu Choices ΓòÉΓòÉΓòÉ
  2773.  
  2774. Select choices from the Options menu to change the font and control what items 
  2775. are shown in the Passthru window. 
  2776.  
  2777.  
  2778. ΓòÉΓòÉΓòÉ 4.5.4.1. Fonts... ΓòÉΓòÉΓòÉ
  2779.  
  2780. Displays the Font window, which allows you to select the type of font you want 
  2781. to use for the Passthru window. 
  2782.  
  2783.  
  2784. ΓòÉΓòÉΓòÉ 4.5.4.2. Display style... ΓòÉΓòÉΓòÉ
  2785.  
  2786. Displays the Display Style window, which allows you to select the items you 
  2787. want displayed in the window, select the number of items you want displayed, 
  2788. change the function of the Enter key, and save the output in a file. 
  2789.  
  2790. Display Style Window 
  2791.  
  2792. To use the Display Style window: 
  2793.  
  2794.      Select the items you want under the Select Items group heading. Each item 
  2795.       you select causes a new column to be added to the response area of the 
  2796.       Passthru window. 
  2797.      In the Number Items entry field, type the number of lines you want to be 
  2798.       displayed in the response area.  The maximum number of lines is 10,000. 
  2799.      The Output File entry field allows you to specify the name of the file 
  2800.       where Passthru responses are optionally saved. 
  2801.      The Save output in file also check box allows you to copy the Passthru 
  2802.       response items into a file (logging function). If the check box is 
  2803.       enabled, the responses are copied into the file that you specified in the 
  2804.       Output File entry field. 
  2805.      The Enter key performs send function check box allows you to enable or 
  2806.       disable the Enter key from performing a send function.  If the check box 
  2807.       is enabled, the Enter key will perform the same function as the Send push 
  2808.       button. If it is disabled, the Enter key will perform a carriage return. 
  2809.  
  2810.  
  2811. ΓòÉΓòÉΓòÉ 4.5.4.3. Restore defaults ΓòÉΓòÉΓòÉ
  2812.  
  2813. Select the Restore defaults choice to reset all of the window settings to their 
  2814. original settings. 
  2815.  
  2816.  
  2817. ΓòÉΓòÉΓòÉ 4.5.4.4. Add custom tool buttons ΓòÉΓòÉΓòÉ
  2818.  
  2819. Select the Add custom tool buttons choice to associate a Passthru command with 
  2820. a tool button icon. 
  2821.  
  2822. To do this: 
  2823.  
  2824.    1. Select one of the 10 icons to associate with a command. 
  2825.    2. Enter a Passthru command in the Commands entry field.  For example, dg 
  2826.       cs. 
  2827.    3. Select the Add push button to place the icon on the toolbar. When you 
  2828.       select the icon from the toolbar, the associated command is executed. 
  2829.       You can add, delete, or change icons and their associated text. 
  2830.  
  2831.  Note:  If the tool buttons choice has not been selected or if the tool buttons 
  2832.  are on the title bar, you can not select the Add custom tool buttons choice 
  2833.  
  2834.  
  2835. ΓòÉΓòÉΓòÉ 4.5.4.5. Tool buttons ΓòÉΓòÉΓòÉ
  2836.  
  2837. Select the Tool buttons choice to enable or disable tool buttons. 
  2838.  
  2839. If enabled, the tool buttons are displayed in the window. If disabled, the tool 
  2840. buttons are not displayed. 
  2841.  
  2842.  
  2843. ΓòÉΓòÉΓòÉ 4.5.4.6. Hover help ΓòÉΓòÉΓòÉ
  2844.  
  2845. Select the Hover help choice if you want hover help. 
  2846.  
  2847.  
  2848. ΓòÉΓòÉΓòÉ 4.5.4.7. Infoarea ΓòÉΓòÉΓòÉ
  2849.  
  2850. Select the Infoarea choice if you want the information area to be shown in the 
  2851. window. 
  2852.  
  2853.  
  2854. ΓòÉΓòÉΓòÉ 4.5.5. Windows Menu Choices ΓòÉΓòÉΓòÉ
  2855.  
  2856. Select the Windows menu from the Passthru window to view a list of all the open 
  2857. debugger windows. By selecting a window from the Windows menu, it is brought 
  2858. into focus and made the active window. Also, if the window is minimized, it is 
  2859. restored. 
  2860.  
  2861.  
  2862. ΓòÉΓòÉΓòÉ 4.5.6. Help Menu Choices ΓòÉΓòÉΓòÉ
  2863.  
  2864. Select choices from the Help menu of the Passthru window to display the various 
  2865. types of help information. 
  2866.  
  2867. Refer to Help Menu Choices for a description of the help choices. 
  2868.  
  2869.  
  2870. ΓòÉΓòÉΓòÉ 4.6. Using the Monitor Windows ΓòÉΓòÉΓòÉ
  2871.  
  2872. The debugger has four other windows that allow you to monitor variables and 
  2873. expressions.  These windows are as follows: 
  2874.  
  2875.      Popup Monitor 
  2876.      Program Monitor 
  2877.      Private Monitor 
  2878.      Storage Monitor. 
  2879.  
  2880.  A Popup Monitor window monitors single variables or expressions. This window 
  2881.  is associated with a specific source window and closes when the associated 
  2882.  window closes. 
  2883.  
  2884.  The Program Monitor, Private Monitor, and Storage Monitor windows are used as 
  2885.  collectors for individual variables or expressions in which you might be 
  2886.  interested. 
  2887.  
  2888.  The difference between the Private Monitor window and the Program Monitor 
  2889.  window is the length of time that each remains open. The Program Monitor 
  2890.  window remains open for the entire debugging session. The Private Monitor 
  2891.  window is associated with the source window from which it was opened and 
  2892.  closes when its associated view is closed. 
  2893.  
  2894.  
  2895. ΓòÉΓòÉΓòÉ 4.7. Using the Breakpoints List Window ΓòÉΓòÉΓòÉ
  2896.  
  2897. Use the Breakpoints List window to display a list of the breakpoints that have 
  2898. been set. The following information is provided for each breakpoint that has 
  2899. been set: 
  2900.  
  2901.      The type of breakpoint 
  2902.      The position of the breakpoint 
  2903.      The enablement state 
  2904.      The conditions under which the breakpoint is activated. 
  2905.  
  2906.  To display the Breakpoints List window, select List from the Breakpoints menu 
  2907.  or select the Breakpoints button in the tool bar. 
  2908.  
  2909.  Breakpoint List Window 
  2910.  
  2911.  
  2912. ΓòÉΓòÉΓòÉ 4.7.1. File Menu Choice ΓòÉΓòÉΓòÉ
  2913.  
  2914. Use the choice from the File menu to end the debugging session. 
  2915.  
  2916. The Close debugger choice allows you to end the current debugging session. 
  2917. When you select Close debugger, the Close Debugger message box prompts you to 
  2918. confirm that you want to end the debugging session. 
  2919.  
  2920.  
  2921. ΓòÉΓòÉΓòÉ 4.7.2. Edit Menu Choices ΓòÉΓòÉΓòÉ
  2922.  
  2923. Select the choices from the Edit menu of the Breakpoints List window to delete, 
  2924. disable, modify, or enable breakpoints. 
  2925.  
  2926.  
  2927. ΓòÉΓòÉΓòÉ 4.7.2.1. Delete ΓòÉΓòÉΓòÉ
  2928.  
  2929. Deletes any breakpoints that are highlighted in the Breakpoints List window. 
  2930.  
  2931. To delete a breakpoint: 
  2932.  
  2933.    1. Highlight the breakpoint you want to delete. 
  2934.    2. Select the Delete choice. 
  2935.  
  2936.  
  2937. ΓòÉΓòÉΓòÉ 4.7.2.2. Disable ΓòÉΓòÉΓòÉ
  2938.  
  2939. Disables any highlighted breakpoints.  The breakpoint remains set but is not 
  2940. activated.  This allows you to run your program and not stop when the 
  2941. breakpoint is encountered. 
  2942.  
  2943. To disable a breakpoint: 
  2944.  
  2945.    1. Highlight the breakpoint you want to disable. 
  2946.    2. Select the Disable choice. 
  2947.  
  2948.  
  2949. ΓòÉΓòÉΓòÉ 4.7.2.3. Modify ΓòÉΓòÉΓòÉ
  2950.  
  2951. Use the Modify choice to change the breakpoints that have been set in your 
  2952. program. 
  2953.  
  2954. To modify a breakpoint: 
  2955.  
  2956.    1. Highlight the breakpoint you want to change. 
  2957.    2. Select the Modify choice. The breakpoint window that represents the type 
  2958.       of breakpoint displays. 
  2959.    3. Make the appropriate changes to the entry fields. 
  2960.    4. Select the OK push button to accept your changes and close the window. If 
  2961.       you want to make other changes, select the Set push button to accept the 
  2962.       changes and keep the window open. 
  2963.  
  2964.  
  2965. ΓòÉΓòÉΓòÉ 4.7.2.4. Delete all ΓòÉΓòÉΓòÉ
  2966.  
  2967. Deletes all the breakpoints that have been set. 
  2968.  
  2969. To delete all the breakpoints: 
  2970.  
  2971.    1. Select the Delete all choice.  The Delete All Breakpoints window 
  2972.       displays. 
  2973.    2. Select Yes from the Delete All Breakpoints window. 
  2974.  
  2975.  
  2976. ΓòÉΓòÉΓòÉ 4.7.2.5. Disable all ΓòÉΓòÉΓòÉ
  2977.  
  2978. Disables all the breakpoints that have been set. 
  2979.  
  2980. To disable all the breakpoints: 
  2981.  
  2982.       Select the Disable all choice.  The prefix area in the source window 
  2983.       changes from red to green to show that the breakpoints are disabled. 
  2984.  
  2985.  
  2986. ΓòÉΓòÉΓòÉ 4.7.2.6. Enable all ΓòÉΓòÉΓòÉ
  2987.  
  2988. Enables all the breakpoints that have been disabled. 
  2989.  
  2990. To enable the breakpoints: 
  2991.  
  2992.       Select the Enable all choice.  The prefix area in the source window 
  2993.       changes from green to red to show that the breakpoints are enabled. 
  2994.  
  2995.  
  2996. ΓòÉΓòÉΓòÉ 4.7.3. Set Menu Choices ΓòÉΓòÉΓòÉ
  2997.  
  2998. Refer to Breakpoints Menu Choices for a description of the Set menu choices. 
  2999.  
  3000.  
  3001. ΓòÉΓòÉΓòÉ 4.7.4. Options Menu Choices ΓòÉΓòÉΓòÉ
  3002.  
  3003. Select choices from the Options menu of the Breakpoints List window to sort the 
  3004. breakpoints, change the style, and change the font for the window. 
  3005.  
  3006.  
  3007. ΓòÉΓòÉΓòÉ 4.7.4.1. Fonts... ΓòÉΓòÉΓòÉ
  3008.  
  3009. Displays the Font window that allows you to select the font you want to use for 
  3010. the text in the Breakpoints List window. 
  3011.  
  3012.  
  3013. ΓòÉΓòÉΓòÉ 4.7.4.2. Display style... ΓòÉΓòÉΓòÉ
  3014.  
  3015. Displays the Display Style window, which allows you to control how the items 
  3016. appear in the Breakpoints List window. 
  3017.  
  3018. Breakpoints - Display Style Window 
  3019.  
  3020. To change the columns which are displayed in the Breakpoint List window: 
  3021. comapct. 
  3022.  
  3023.    1. Select one or more of the items under the Select Items group heading. 
  3024.       Each item you select causes a new column to be added to the Breakpoint 
  3025.       List window. 
  3026.  
  3027.    2. Select the OK push button. 
  3028.  
  3029.  The Show Watchpoint Types check box allows you to see more type information 
  3030.  for watchpoints when they are enabled.  For example, a type field of Watch - 
  3031.  Instruction fetch would be displayed. 
  3032.  
  3033.  
  3034. ΓòÉΓòÉΓòÉ 4.7.4.3. Sort ΓòÉΓòÉΓòÉ
  3035.  
  3036. Displays the Sort window, which allows you to sort the breakpoints by the 
  3037. characteristics of the breakpoint. 
  3038.  
  3039. Sort Window 
  3040.  
  3041. Use the Sort window to sort the breakpoints that have been set in your program. 
  3042.  
  3043. Breakpoints can be sorted according to the following categories: 
  3044.  
  3045.      Type 
  3046.      Executable 
  3047.      Source 
  3048.      File 
  3049.      Function 
  3050.      Line 
  3051.      Address 
  3052.      State 
  3053.      Status 
  3054.      Thread 
  3055.      Expression 
  3056.      From 
  3057.      To 
  3058.      Every. 
  3059.  
  3060.  Select the category you want and select the OK push button. 
  3061.  
  3062.  
  3063. ΓòÉΓòÉΓòÉ 4.7.4.4. Restore defaults ΓòÉΓòÉΓòÉ
  3064.  
  3065. Select the Restore defaults choice to reset all of the window settings to their 
  3066. original settings. 
  3067.  
  3068.  
  3069. ΓòÉΓòÉΓòÉ 4.7.4.5. Tool buttons ΓòÉΓòÉΓòÉ
  3070.  
  3071. Select the Tool buttons choice if you want tool buttons. 
  3072.  
  3073.  
  3074. ΓòÉΓòÉΓòÉ 4.7.4.6. Hover help ΓòÉΓòÉΓòÉ
  3075.  
  3076. Select the Hover help choice if you want hover help. 
  3077.  
  3078.  
  3079. ΓòÉΓòÉΓòÉ 4.7.4.7. Infoarea ΓòÉΓòÉΓòÉ
  3080.  
  3081. Select the Infoarea choice if you want the information area to be shown in the 
  3082. window. 
  3083.  
  3084.  
  3085. ΓòÉΓòÉΓòÉ 4.7.5. Windows Menu Choices ΓòÉΓòÉΓòÉ
  3086.  
  3087. Select the Windows menu from the Breakpoints List window to view a list of all 
  3088. the open debugger windows. By selecting a window from the Windows menu, it is 
  3089. brought into focus and made the active window. Also, if the window is 
  3090. minimized, it is restored. 
  3091.  
  3092.  
  3093. ΓòÉΓòÉΓòÉ 4.7.6. Help Menu Choices ΓòÉΓòÉΓòÉ
  3094.  
  3095. Select choices from the Help menu of the Breakpoints List window to display the 
  3096. various types of help information. 
  3097.  
  3098. Refer to Help Menu Choices for a description of the help choices. 
  3099.  
  3100.  
  3101. ΓòÉΓòÉΓòÉ 5. Expressions Supported ΓòÉΓòÉΓòÉ
  3102.  
  3103. This section describes the expression language supported by the debugger, which 
  3104. is a subset of C/C++.  This includes the operands, operators, and data types. 
  3105.  
  3106. Note:  You can display and update bit fields for C/C++ code only. You cannot 
  3107. look at variables that have been defined using the #DEFINE preprocessor 
  3108. directive. 
  3109.  
  3110.  
  3111. ΓòÉΓòÉΓòÉ 5.1. Supported Expression Operands ΓòÉΓòÉΓòÉ
  3112.  
  3113. You can monitor an expression that uses the following types of operands only: 
  3114.  
  3115.  Operand           Definition 
  3116.  
  3117.  Variable          A variable used in your program. 
  3118.  
  3119.  Constant          The constant can be one of the following types: 
  3120.  
  3121.                        Fixed or floating-point constant. 
  3122.  
  3123.                         Note:  The largest floating-point constant is 1.8E308. 
  3124.                         The smallest floating-point is 2.23E-308. 
  3125.                        A string constant, enclosed in quotation marks (" ") 
  3126.                        A character constant, enclosed in single quote marks (' 
  3127.                         ') 
  3128.  
  3129.  Registers         In the case of conflicting names, the program variable names 
  3130.                    take precedence over the register names. For conversions 
  3131.                    that are done automatically when the registers display in 
  3132.                    mixed-mode expressions, general purpose registers are 
  3133.                    treated as unsigned arithmetic items with a length 
  3134.                    appropriate to the register. 
  3135.  
  3136.  If you monitor an enumerated variable, a comment displays to the right of the 
  3137.  value.  If the value of the variable matches one of the enumerated types, the 
  3138.  comment contains the name of the first enumerated type that matches the value 
  3139.  of the variable. If the length of the enumerated name does not fit in the 
  3140.  monitor, the contents display as an empty entry field. 
  3141.  
  3142.  The comment (empty or not) lets you distinguish between a valid enumerated 
  3143.  value and an invalid value. An invalid value does not have a comment to the 
  3144.  right of the value. 
  3145.  
  3146.  You can not update an enumerated variable by entering an enumerated type. You 
  3147.  must enter a value or expression. If the value is a valid enumerated value, 
  3148.  the comment to the right of the value updates. 
  3149.  
  3150.  Bit fields are supported for C/C++ compiled code only. You can display and 
  3151.  update bit fields, but you cannot use them in expressions. You cannot look at 
  3152.  variables that have been defined using the #DEFINE preprocessor directive. 
  3153.  
  3154.  
  3155. ΓòÉΓòÉΓòÉ 5.2. Supported Expression Operators ΓòÉΓòÉΓòÉ
  3156.  
  3157. You can monitor an expression that uses the following operators only: 
  3158.  
  3159.  
  3160. 
  3161.  Table 1. Supported Expression Operators                                      
  3162. 
  3163.  OPERATOR                               CODED AS                             
  3164. 
  3165.  GLOBAL SCOPE RESOLUTION                ::a                                  
  3166. 
  3167.  CLASS SCOPE RESOLUTION                 a::b                                 
  3168. 
  3169.  SUBSCRIPTING                           a[b]                                 
  3170. 
  3171.  MEMBER SELECTION                       a.b or a->b                          
  3172. 
  3173.  SIZE                                   sizeof a or sizeof (type)            
  3174. 
  3175.  LOGICAL NOT                            !a                                   
  3176. 
  3177.  ONE'S COMPLEMENT                       ~a                                   
  3178. 
  3179.  UNARY MINUS                            -a                                   
  3180. 
  3181.  UNARY PLUS                             +a                                   
  3182. 
  3183.  DEREFERENCE                            *a                                   
  3184. 
  3185.  TYPE CAST                              (type) a                             
  3186. 
  3187.  MULTIPLY                               a * b                                
  3188. 
  3189.  DIVIDE                                 a / b                                
  3190. 
  3191.  MODULO                                 a % b                                
  3192. 
  3193.  ADD                                    a + b                                
  3194. 
  3195.  SUBTRACT                               a - b                                
  3196. 
  3197.  LEFT SHIFT                             a << b                               
  3198. 
  3199.  RIGHT SHIFT                            a >> b                               
  3200. 
  3201.  LESS THAN                              a < b                                
  3202. 
  3203.  GREATER THAN                           a > b                                
  3204. 
  3205.  LESS THAN OR EQUAL TO                  a <= b                               
  3206. 
  3207.  GREATER THAN OR EQUAL TO               a >= b                               
  3208. 
  3209.  EQUAL                                  a == b                               
  3210. 
  3211.  NOT EQUAL                              a != b                               
  3212. 
  3213.  BITWISE AND                            a & b                                
  3214. 
  3215.  BITWISE OR                             a | b                                
  3216. 
  3217.  BITWISE EXCLUSIVE OR                   a Γòí b                                
  3218. 
  3219.  LOGICAL AND                            a && b                               
  3220. 
  3221.  LOGICAL OR                             a || b                               
  3222. 
  3223. 
  3224.  
  3225.  
  3226. ΓòÉΓòÉΓòÉ 5.3. Supported Data Types ΓòÉΓòÉΓòÉ
  3227.  
  3228. You can monitor an expression that uses the following typecasting operations: 
  3229.  
  3230.      8-bit signed byte 
  3231.      8-bit unsigned byte 
  3232.      16-bit signed integer 
  3233.      16-bit unsigned integer 
  3234.      32-bit signed integer 
  3235.      32-bit unsigned integer 
  3236.      32-bit floating-point 
  3237.      64-bit floating-point 
  3238.      128-bit floating-point 
  3239.      Pointers 
  3240.      User-defined types. 
  3241.