=Title Debug Overview
 General DEBUG text goes here

Additional information available:

The Main WindowMain Menu BarFile Menu EntryFile Menu
File Menu Exit ButtonFile Menu Quit ButtonEdit Menu EntryEdit Menu
Edit Menu Undo ButtonEdit Menu Copy ButtonEdit Menu Paste ButtonEdit Menu Clear Button
Ctrl Menu EntryCtrl MenuCtrl Menu Go ButtonCtrl Menu Step Button
Ctrl Menu Breakpoint ButtonCtrl Menu Watchpoint ButtonCtrl Menu Call Button
Data Menu EntryData MenuData Menu Variables EntryData Menu Variables Submenu
Vbls Menu Deposit ButtonVbls Menu Examine ButtonVbls Menu Show Button
Data Menu Code EntryData Menu Code SubmenuCode Menu Deposit Button
Code Menu Examine ButtonCode Menu Show ButtonData Menu Express Button
Data Menu Addresses EntryData Menu Addresses SubmenuAddr Menu Deposit Button
Addr Menu Examine ButtonAddr Menu Symbolize ButtonData Menu Callstack Button
Data Menu Modules ButtonData Menu Images ButtonData Menu Handlers Button
Data Menu Processes ButtonData Menu Tasks ButtonCust Menu Entry
Cust MenuCust Hide Show Command DBCust Menu Windows Button
Cust Menu WSetups EntryWind Menu WSetups SubmenuWSetups Menu Default Button
WSetups Menu Choice2 ButtonWSetups Menu Choice3 ButtonCust Menu MPwind Entry
Wind Menu MPwind SubmenuMPwind Menu 2Src ButtonMPwind Menu 2SrcInst Button
Cust Menu Radix ButtonCust Menu Language EntryCust Menu Language Submenu
Lang Menu Ada ButtonLang Menu Basic ButtonLang Menu Bliss ButtonLang Menu C Button
Lang Menu Cobol ButtonLang Menu Dibol ButtonLang Menu Fortran Button
Lang Menu Macro ButtonLang Menu Pascal ButtonLang Menu PLI ButtonLang Menu RPG Button
Lang Menu Scan ButtonLang Menu Unknown ButtonCust Menu Source Button
Cust Menu Logging ButtonCust Menu Datatype ButtonCust Menu Misc setting Button
Help Menu EntryHelp MenuHelp Menu OverviewHelp Menu About
Help Menu UsingMain RegionExamine Status L ButtonScopes Status L Button
Process Status L ButtonButton RegionGo ButtonStep ButtonExamine Button
Stop ButtonThe Command DBAddress Dialog Boxg ok apply cancel buttons
g display sourceg display instructionsg symbg intro to addrexpr
g langexprg langg multilangg cmd modeg log fileg symb shareg multiproc
g specifying codeg selecting codeg selecting variablesg specifying variables
g display predwndsg source notavailableg radixg DST GST RST
g Symb mod setg resolve symbg callframe labelg callframe buttons display src
g callframe buttons display instg resolve symb using callframeAuto Dialog Box
Break Dialog BoxCall Dialog BoxCallstk Dialog BoxDatatype Dialog Box
Dep Addr Dialog BoxDep Code Dialog BoxDep Vbl Dialog BoxEx Addr Dialog Box
Ex Code Dialog BoxEx Vbl Dialog BoxExpress Dialog BoxGo Dialog Box
Images Dialog BoxLinenum Dialog BoxLogging Dialog BoxModules Dialog Box
Other Dialog BoxRadix Dialog BoxShow Ad Dialog BoxShow Vbl Dialog Box
Src File Dialog BoxStep Dialog BoxSymbol Dialog BoxWatch Dialog Box
Wind Dialog BoxTask Dialog BoxProc Dialog BoxSRC Display Window
SRC Display Menu BarSRC Disp Cmds Menu EntrySRC Disp Cmds Menu
SRC Disp Cmds Menu View SrcINST Display WindowINST Display Menu Bar
INST Disp Cmds Menu EntryINST Disp Cmds MenuINST Disp Cmds Menu View Src
OUT Display WindowOUT Display Menu BarREG Display WindowREG Display Menu Bar
AUTO Display WindowAUTO Display Menu BarAUTO Disp Cmds Menu Entry
AUTO Disp Cmds MenuAUTO Disp Cmds Menu Add SeleAUTO Disp Cmds Menu Del Sele
Disp File Menu EntryDisp File MenuDisp File Menu Close Button
Disp File Menu Quit ButtonDisp File Menu Exit ButtonDisp Edit Menu Entry
Disp Edit MenuDisp Edit Menu Copy ButtonDisp Edit Menu Clear Button
The Popup MenuQuit Caution BoxMessage BoxNot Yet Implemented

=Title Debugger Main Window
=include debug Main_Menu_Bar
=include debug Examine_Status_L_Button
=include debug Scopes_Status_L_Button
=include debug Process_Status_L_Button
=include debug Button_Region
The debugger's main window includes:

  -  A menu bar.

  -  Three sets of fields and buttons that are labeled
     Current Entity, Call Frame, and Visible Process.

  -  Four buttons that are labeled Go, Step, Examine,
     and Stop.

=Title Debugger Main Window Menu Bar
=include debug Edit_Menu_Entry
=include debug File_Menu_Entry
=include debug Ctrl_Menu_Entry
=include debug Data_Menu_Entry
=include debug Cust_Menu_Entry
=include debug Help_Menu_Entry
=include debug The_Popup_Menu
=include debug The_Main_Window
Use the pulldown menus in the main window as follows:

  -  Choose the File menu to end the debugging session
     (exit the debugger).

  -  Choose the Edit menu to copy text to the clipboard
     or to paste text from the clipboard to a debugger
     dialog box or the COMMAND box.

  -  Choose the Control menu to start, stop, and monitor
     the execution of your program under debugger
     control.  For example:  execute to the next line or
     to the next VAX assembly-language instruction; set
     breakpoints, tracepoints, and watchpoints; call a
     routine.

  -  Choose the Data menu to display or manipulate data
     that is associated with your program.  For example:
     examine variables and arbitrary program locations;
     assign new values to variables; evaluate language
     expressions; control access to variable names,
     routine names, and other symbols; manipulate
     multiprocess programs and Ada tasking programs.
     Note that the Tasks menu item is dimmed unless you
     are debugging a VAX Ada program.

  -  Choose the Customize menu to tailor your debugging
     environment and establish default conditions.  For
     example:  create and manipulate debugger windows;
     change the programming language context; establish
     defaults for manipulating data and for accessing
     symbols; open the COMMAND box to access the
     debugger's command interface.

  -  Choose the Help menu to obtain conceptual and
     task-oriented information about the debugger.  This
     is an alternative to obtaining context-sensitive
     help on individual items that are displayed on the
     screen (menus, buttons, dialog boxes, and so on).

=Title File Menu in Main Window
=include debug File_Menu_Quit_Button
=include debug File_Menu_Exit_Button
=include debug Data_Menu_Handlers_Button
Use the File menu as follows:

  -  Choose Exit to end the debugging session, also
     executing any exit handlers that are declared in
     the program.

  -  Choose Quit to end the debugging session.

     If an exit handler is declared in your program, a
     dialog box gives you the option of executing that
     handler when you choose Quit.

=Title File Menu in Main Window
=include debug File_Menu_Quit_Button
=include debug File_Menu_Exit_Button
=include debug Data_Menu_Handlers_Button
Use the File menu as follows:

  -  Choose Exit to end the debugging session, also
     executing any exit handlers that are declared in
     the program.

  -  Choose Quit to end the debugging session.

     If an exit handler is declared in your program, a
     dialog box gives you the option of executing that
     handler when you choose Quit.

=Title Exit Item on File Menu in Main Window
=include debug Data_Menu_Handlers_Button
=Include DEBUG File_Menu_Quit_Button
Choose Exit to end the debugging session, also executing
 any exit handlers that are declared in the program.

=Title Quit Item on File Menu in Main Window
=include debug Data_Menu_Handlers_Button
=Include DEBUG File_Menu_Exit_Button
Choose Quit to end the debugging session.

 If an exit handler is declared in your program, a
 dialog box gives you the option of executing that
 handler.

=Title Edit Menu in Main Window
=include debug Edit_Menu_Copy_Button
=include debug Edit_Menu_Paste_Button
Use the Edit menu as follows:

  -  Choose Copy to copy text selected in a window to
     the clipboard.

  -  Choose Paste to paste text from the clipboard to
     either a field in a debugger dialog box or to the
     debugger COMMAND box.

=Title Edit Menu in Main Window
=include debug Edit_Menu_Copy_Button
=include debug Edit_Menu_Paste_Button
Use the Edit menu as follows:

  -  Choose Copy to copy text selected in a window to
     the clipboard.

  -  Choose Paste to paste text from the clipboard to
     either a field in a debugger dialog box or to the
     debugger COMMAND box.

=Title Undo Copy Item on Edit Menu

=Title Copy Item on Edit Menu
Choose Copy to copy text selected in a window to the
 clipboard.

=Title Paste Item on Edit Menu
=include debug Cust_Hide_Show_Command_DB
Choose Paste to paste text from the clipboard to either
 a field in a debugger dialog box or to the debugger
 COMMAND box.

=Title Clear Item on Edit Menu

=Title Control Menu in Main Window
=include debug Ctrl_Menu_Go_Button
=include debug Ctrl_Menu_Step_Button
=include debug Ctrl_Menu_Breakpoint_Button
=include debug Ctrl_Menu_Watchpoint_Button
=include debug Ctrl_Menu_Call_Button
Use the Control menu to start, stop, and monitor the
 execution of your program under debugger control.
 Whenever execution stops, the source window is updated,
 and the boxed line identifies the source line at which
 execution is suspended.

 Choose Go...  to start execution from a specified
 location in your program.

 Choose Step...  to execute one or more source lines or
 VAX assembly-language instructions.

 Choose Break...  to set, cancel, or modify, breakpoints
 and tracepoints.

 Choose Watch...  to set, cancel, or modify watchpoints.

 Choose Call...  to execute a routine independently of
 the normal execution of the program.

=Title Control Menu in Main Window
=include debug Ctrl_Menu_Go_Button
=include debug Ctrl_Menu_Step_Button
=include debug Ctrl_Menu_Breakpoint_Button
=include debug Ctrl_Menu_Watchpoint_Button
=include debug Ctrl_Menu_Call_Button
Use the Control menu to start, stop, and monitor the
 execution of your program under debugger control.
 Whenever execution stops, the source window is updated,
 and the boxed line identifies the source line at which
 execution is suspended.

 Choose Go...  to start execution from a specified
 location in your program.

 Choose Step...  to execute one or more source lines or
 VAX assembly-language instructions.

 Choose Break...  to set, cancel, or modify, breakpoints
 and tracepoints.

 Choose Watch...  to set, cancel, or modify watchpoints.

 Choose Call...  to execute a routine independently of
 the normal execution of the program.

=Title Go...  Item on Control Menu
=Include debug Go_Dialog_Box
=include debug Go_Dialog_Box g_go
=include debug go_button
=include debug The_Popup_Menu g_go
Choose Go...  to start program execution from a
 specified location.

 To start execution from the current location, click on
 the Go button in the main window.

=Title Step...  Item on Control Menu
=Include debug Step_Dialog_Box
=include debug Step_Dialog_Box g_step
=include debug step_button
=include debug The_Popup_Menu
Choose Step...  to execute one or more lines of source
 code or VAX assembly-language instructions, or to
 execute the program to the next instruction of a
 particular kind, for example, a CALL instruction.

 To execute one step unit at a time, click on the Step
 button in the main window.

 By default, a step unit is one executable line of
 source source code.  To change the step unit, choose
 Step...  from the Control menu.

=Title Break...  Item on Control Menu
=Include debug Break_Dialog_Box
=include debug Break_Dialog_Box g_breaktrace
=include debug The_Popup_Menu g_break
Choose Break...  to set, cancel, or modify breakpoints
 and tracepoints.

=Title Watch...  Item on Control Menu
=Include debug Watch_Dialog_Box
Choose Watch...  to set, cancel, or modify watchpoints.

=Title Call...Item on Control Menu
=include debug Call_Dialog_Box
Choose Call...  to execute a routine independently of
 the normal execution of the program.

=Title Data Menu in Main Window
=include debug Data_Menu_Variables_Entry
=include debug Data_Menu_Code_Entry
=include debug Data_Menu_Express_Button
=include debug Data_Menu_Addresses_Entry
=include debug Data_Menu_Callstack_Button
=include debug Data_Menu_Modules_Button
=include debug Data_Menu_Images_Button
=include debug Data_Menu_Handlers_Button
=include debug Data_Menu_Processes_Button
=include debug Data_Menu_Tasks_Button
=include debug The_Popup_Menu
Use the Data menu to display or manipulate data
 associated with your program.

=Title Data Menu in Main Window
=include debug Data_Menu_Variables_Entry
=include debug Data_Menu_Code_Entry
=include debug Data_Menu_Express_Button
=include debug Data_Menu_Addresses_Entry
=include debug Data_Menu_Callstack_Button
=include debug Data_Menu_Modules_Button
=include debug Data_Menu_Images_Button
=include debug Data_Menu_Handlers_Button
=include debug Data_Menu_Processes_Button
=include debug Data_Menu_Tasks_Button
=include debug The_Popup_Menu
Use the Data menu to display or manipulate data
 associated with your program.

=Title Variables Item on Data Menu
=include debug Vbls_Menu_Examine_Button
=include debug Vbls_Menu_Deposit_Button
=include debug Vbls_Menu_Show_Button
=include debug The_Popup_Menu g_examine
Choose Variables to do the following tasks:

  -  Display the current value of a variable

  -  Assign a value to a variable

  -  Display information about a variable, such as its
     type, address, or path name

=Title Variables Submenu of Data Menu
=include debug Vbls_Menu_Examine_Button
=include debug Vbls_Menu_Deposit_Button
=include debug Vbls_Menu_Show_Button
=include debug The_Popup_Menu g_examine
Use the Variables submenu as follows:

  -  Choose Examine Variable...  to display the current
     value of a variable.

  -  Choose Deposit into Variable...  to assign a value
     to a variable.

  -  Choose Show Variable...  to display information
     about a variable, such as its type, address, and
     path name.

=Title Deposit into Variable...  Item on Variables Submenu
=include debug Dep_Vbl_Dialog_Box
=include debug Dep_Vbl_Dialog_Box g_deposit_var
Choose Deposit into Variable...  to assign a value to a
 variable.

=Title Examine Variable...  Item on Variables Submenu
=include debug Ex_Vbl_Dialog_Box
=include debug Ex_Vbl_Dialog_Box g_examine_var
=include debug Examine_Button
=include debug The_Popup_Menu g_examine
Choose Examine Variable...  to display the current value
 of a variable.

=Title Show Variable...  Item on Variables Submenu
=include debug Show_Vbl_Dialog_Box
=include debug Show_Vbl_Dialog_Box g_show_var
Choose Show Variable...  to display information about a
 variable, such as its type, address, and path name.

=Title Code Item on Data Menu
=include debug Code_Menu_Examine_Button
=include debug Code_Menu_Deposit_Button
=include debug Code_Menu_Show_Button
=include debug The_Popup_Menu g_examine
Choose Code to do the following tasks:

  -  Display the line of source code or the decoded VAX
     instructions for an address expression

  -  Deposit a VAX instruction at the location denoted
     by an address expression

  -  Display the memory address or register for an
     address expression

=Title Code Submenu of Data Menu
=include debug Code_Menu_Examine_Button
=include debug Code_Menu_Deposit_Button
=include debug Code_Menu_Show_Button
=include debug The_Popup_Menu g_examine
Use the Code submenu as follows:

  -  Choose Examine Code...  to display the line of
     source code or the decoded VAX instructions for an
     address expression.

  -  Choose Deposit Code...  to deposit a VAX
     instruction at the location denoted by an address
     expression.

  -  Choose Show Address...  to display the memory
     address or register for an address expression.

=Title Deposit Code...  Item on Code Submenu
=include debug Dep_Code_Dialog_Box
=include debug Dep_Code_Dialog_Box g_deposit_code
Choose Deposit Code...  to deposit a VAX instruction at
 the location denoted by an address expression.

=Title Examine Code...  Item on Code Submenu
=include debug Ex_Code_Dialog_Box
=include debug inst_Disp_Cmds_Menu_View_Src
=include debug Ex_Code_Dialog_Box g_display_instructions
=include debug Examine_Button
=include debug The_Popup_Menu g_examine
Choose Examine Code...  to display the line of source
 code or the decoded VAX instructions for an address
 expression.

=Title Show Address...  Item on Code Submenu
=include debug Show_Ad_Dialog_Box
Choose Show Address...  to display the memory address or
 register for an address expression.

=Title Language Expressions...  Item on Data Menu
=include debug Express_Dialog_Box
=include debug The_Popup_Menu g_evaluate
=include debug g_langexpr
Choose Language Expressions...  to evaluate a language
 expression.

=Title Addresses or Registers Item on Data Menu
=include debug Addr_Menu_Examine_Button
=include debug Addr_Menu_Deposit_Button
=include debug Addr_Menu_Symbolize_Button
=include debug The_Popup_Menu g_examine
Choose Addresses or Registers to do the following tasks:

  -  Display the current value stored at a memory
     address or in a register

  -  Deposit a value of a specified type at a memory
     address or into a register

  -  Display the symbolic name (if any) that is
     associated with a memory address or a register

=Title Addresses or Registers Submenu of Data Menu
=include debug Addr_Menu_Examine_Button
=include debug Addr_Menu_Deposit_Button
=include debug Addr_Menu_Symbolize_Button
=include debug The_Popup_Menu g_examine
Use the Addresses or Registers submenu as follows:

  -  Choose Examine Address or Register...  to display
     the current value stored at a memory address or in
     a register.

  -  Choose Deposit into Address or Register...  to
     deposit a value of a specified type at a memory
     address or in register.

  -  Choose Symbolize Address or Register...  to display
     the symbolic name (if any) that is associated with
     a memory address or a register.

=Title Deposit into Address or Register...  Item on Data Menu
=include debug Dep_Addr_Dialog_Box
=include debug Dep_Addr_Dialog_Box g_deposit_addreg
Choose Deposit into Address or Register...  to deposit a
 value of a specified type at a memory address or into
 register.

=Title Examine Address or Register...  Item on Data Menu
=include debug Ex_Addr_Dialog_Box
=include debug Ex_Addr_Dialog_Box g_examine_addreg
=include debug Examine_Button
=include debug The_Popup_Menu g_examine
Choose Examine Address or Register...  to display the
 current value stored at a memory address or in a
 register.

=Title Symbolize Address or Register...  Item on Data Menu
=include debug Symbol_Dialog_Box
=include debug g_Symb
Choose Symbolize Address or Register...  to display the
 symbolic name (if any) that is associated with a memory
 address or a register.

=Title Call Stack...  Item on Data Menu
=include debug Callstk_Dialog_Box
=Include DEBUG Ctrl_Menu
=include debug Scopes_Status_L_Button
Choose Call Stack...  to identify where execution is
 currently suspended.  This menu item displays the
 sequence of routine calls that are currently on the
 call stack and provides related information.

=Title Modules...  Item on Data Menu
=include debug Modules_Dialog_Box
=include debug g_DST_GST_RST
=include debug g_symb_mod_set
=include debug g_Symb
=include debug data_menu_images_button
Choose Modules...  to load and unload symbol information
 (the names of variables, routines, and so on) for one
 or more modules of the program into the debugger's
 run-time symbol table (RST).  This is referred to as
 setting and canceling modules, respectively.

 Module setting enables the debugger to recognize the
 symbols that are declared in the program, so that you
 can specify them in dialog boxes and commands.

 Note that, by default, the debugger sets modules
 automatically during a debugging session, so that you
 usually do not have to set modules explicitly.

 In addition, if the debugger does not recognize or
 correctly interpret a symbol that you specify, an unset
 module is but one of several possible reasons.

=Title Images...  Item on Data Menu
=include debug Images_Dialog_Box
=include debug g_Symb_share
=include debug g_DST_GST_RST
=include debug g_symb_mod_set
=include debug g_Symb
=include debug data_menu_modules_button
The Images...  item enables you to debug a shareable
 image that is linked with the program.  Choose
 Images...  to load and unload symbol information for
 one or more images and to establish the current image.

 Loading and unloading is referred to as setting and
 canceling images, respectively.  Except for universal
 symbols, the symbols of only one image (the current
 image) are accessible at any one time.

 Note that, by default, the debugger sets images and
 modules automatically during a debugging session, so
 that you usually do not have to set images or modules
 explicitly.

 In addition, if the debugger does not recognize or
 correctly interpret a symbol that you specify, an unset
 image or an unset module is but one of several possible
 reasons.

=Title Exit Handlers Item on Data Menu
=include debug File_Menu_Exit_Button
Choose Exit Handlers to identify any exit handlers that
 are declared in the program.

=Title Processes...  Item on Data Menu
=include debug Proc_Dialog_Box
=include debug g_multiproc
The Processes...  item enables you to debug a
 multiprocess program.  Choose Processes...  to display
 information about the images running in individual
 processes and to control the multiprocess environment.

=Title Tasks...  Item on Data Menu
=include debug Task_Dialog_Box
=include debug g_lang
The Tasks...  item enables you to debug a VAX Ada
 tasking program (this item is dimmed unless you are
 debugging a VAX Ada program).  Choose Tasks...  to
 display information about individual tasks and to
 control the tasking environment.

=Title Customize Menu in Main Window
=include debug Cust_Hide_Show_Command_DB
=include debug Cust_Menu_Windows_Button
=include debug Cust_Menu_WSetups_Entry
=include debug Cust_Menu_MPwind_Entry
=include debug Cust_Menu_Radix_Button
=include debug Cust_Menu_Language_Entry
=include debug Cust_Menu_Source_Button
=include debug Cust_Menu_Logging_Button
=include debug Cust_Menu_Datatype_Button
=include debug Cust_Menu_Misc_setting_Button
=include debug Wind_Dialog_Box g_predwnds
Use the Customize menu to tailor your debugging
 environment and establish default conditions.

=Title Customize Menu in Main Window
=include debug Cust_Hide_Show_Command_DB
=include debug Cust_Menu_Windows_Button
=include debug Cust_Menu_WSetups_Entry
=include debug Cust_Menu_MPwind_Entry
=include debug Cust_Menu_Radix_Button
=include debug Cust_Menu_Language_Entry
=include debug Cust_Menu_Source_Button
=include debug Cust_Menu_Logging_Button
=include debug Cust_Menu_Datatype_Button
=include debug Cust_Menu_Misc_setting_Button
=include debug Wind_Dialog_Box g_predwnds
Use the Customize menu to tailor your debugging
 environment and establish default conditions.

=Title Show Command...  Item on Customize Menu
=include debug The_Command_DB
=include debug g_cmd_mode
When the debugger command window is closed, the first
 menu item on the Customize menu is Show Command...
 This is the default.

 Choose Show Command...  to open the debugger COMMAND
 box.  The COMMAND box enables you to interact with the
 debugger's command interface by entering commands at
 the prompt, DBG>.  The COMMAND box also displays the
 debugger command associated with the last operation
 performed through the DECwindows interface.

 When the COMMAND box is open, the first menu item is
 Hide Command.  Choose Hide Command to close the COMMAND
 box.

 To open the COMMAND box for just one command, press the
 DO key.

=Title Windows...  Item on Customize Menu
=include debug Wind_Dialog_Box
=include debug Wind_Dialog_Box g_predwnds
=include debug g_display_source
=include debug g_display_instructions
Choose Windows...  to modify or create the following
 kinds of debugger windows:

   Source windows, such as the predefined window SRC

   Output windows, such as the predefined window OUT

   Automatic windows, such as the predefined window AUTO

   Instruction windows, such as the predefined window INST

   Register windows, such as the predefined window REG

=Title Window Setups Item on Customize Menu
=include debug Wind_Dialog_Box g_predwnds
=include debug Wind_Dialog_Box g_wind_attrib
=include debug Cust_Menu_Windows_Button
Choose Window Setups to display the debugger windows
 according to one of the three predefined layouts shown
 on the submenu.

 Clicking on the first layout establishes the default
 window configuration at debugger startup.

 Clicking on the second layout places the predefined
 source (SRC) and instruction (INST) windows side by
 side.  This layout is useful when you are debugging
 code that has been optimized during compilation.

 Clicking on the third layout places the predefined
 instruction (INST) and register (REG) windows side by
 side.

 The second and third options assign the instruction
 attribute to INST, so that you can use it to display
 instructions for any part of your program.

 You can modify these windows by choosing Windows...
 from the Customize menu.

=Title Window Setups Submenu of Customize Menu
=include debug Wind_Dialog_Box g_predwnds
=include debug Cust_Menu_Windows_Button
Choose a predefined debugger window layout by clicking
 on one of the three layouts shown on the submenu.

 Clicking on the first layout establishes the default
 window configuration at debugger startup.

 Clicking on the second layout places the predefined
 source (SRC) and instruction (INST) windows side by
 side.  This layout is useful when you are debugging
 code that has been optimized during compilation.

 Clicking on the third layout places the predefined
 instruction (INST) and register (REG) windows side by
 side.

 The second and third options assign the instruction
 attribute to INST, so that you can use it to display
 instructions for any part of your program.

 You can modify these windows by choosing Windows...
 from the Customize menu.

=Title First Layout on Window Setups Submenu
=include debug WSetups_Menu_Choice2_Button
=include debug WSetups_Menu_Choice3_Button
=include debug Wind_Dialog_Box g_predwnds
=include debug g_display_source
=include debug Cust_Menu_Windows_Button
Choose the first layout to display the debugger main
 window and the predefined source (SRC) and output (OUT)
 debugger windows as shown on the submenu.

 This is the default window layout at debugger startup.

 You can modify these windows by choosing Windows...
 from the Customize menu.

=Title Second Layout on Window Setups Submenu
=include debug WSetups_Menu_Default_Button
=include debug WSetups_Menu_Choice3_Button
=include debug Wind_Dialog_Box g_predwnds
=include debug g_display_instructions
=include debug Cust_Menu_Windows_Button
Choose the second layout to display the debugger main
 window and the predefined source (SRC), instruction
 (INST), and output (OUT) debugger windows as shown on
 the submenu.

 Placing windows SRC and INST side by side is useful
 when you are debugging code that has been optimized
 during compilation.

 This option assigns the instruction attribute to INST,
 so that you can use it to display instructions for any
 part of your program.

 You can modify these windows by choosing Windows...
 from the Customize menu.

=Title Third Layout on Window Setups Submenu
=include debug WSetups_Menu_Default_Button
=include debug WSetups_Menu_Choice2_Button
=include debug Wind_Dialog_Box g_predwnds
=include debug g_display_instructions
=include debug Cust_Menu_Windows_Button
Choose the third layout to display the debugger main
 window and the predefined instruction (INST), register
 (REG), and output (OUT) debugger windows as shown on
 the submenu.

 This option assigns the instruction attribute to INST,
 so that you can use it to display instructions for any
 part of your program.

 You can modify these windows by choosing Windows...
 from the Customize menu.

=Title Multiprocess Window Setups Item on Customize Menu
=include debug Wind_Dialog_Box g_proc_windows
=include debug Cust_Menu_Windows_Button
Choose Multiprocess Window Setups to display the
 debugger windows according to one of two predefined
 process-specific layouts shown on the submenu.

 Clicking on the first layout places two predefined
 process-specific source windows (SRC_n) side by side,
 where n is the process number.

 Clicking on the second layout places two sets of
 predefined process-specific source and instruction
 windows (SRC_n and INST_n, respectively) side by side.

 You can modify these windows by choosing Windows...
 from the Customize menu.

=Title Multiprocess Window Setups Submenu of Customize Menu
=include debug Wind_Dialog_Box g_proc_windows
=include debug Cust_Menu_Windows_Button
Choose a predefined debugger window layout by clicking
 on one of the two layouts shown on the submenu.

 Clicking on the first layout places two predefined
 process-specific source windows (SRC_n) side by side,
 where n is the process number.

 Clicking on the second layout places two sets of
 predefined process-specific source and instruction
 windows (SRC_n and INST_n, respectively) side by side.

 You can modify these windows by choosing Windows...
 from the Customize menu.

=Title First Layout on Multiprocess Window Setups Submenu
=include debug MPwind_Menu_2SrcInst_Button
=include debug Wind_Dialog_Box g_proc_windows
=include debug Cust_Menu_Windows_Button
Choose the first layout to display the debugger main
 window, the predefined output window (OUT), and two
 predefined process-specific source windows (SRC_n) as
 shown on the submenu.  N is the process number.

 You can modify these windows by choosing Windows...
 from the Customize menu.

=Title Second Layout on Multiprocess Window Setups Submenu
=include debug MPwind_Menu_2Src_Button
=include debug Wind_Dialog_Box g_proc_windows
=include debug Cust_Menu_Windows_Button
Choose the second layout to display the debugger main
 window, the predefined output window (OUT), and two
 predefined process-specific source and instruction
 windows (SRC_n and INST_n, respectively) as shown on
 the submenu.  N is the process number.

 You can modify these windows by choosing Windows...
 from the Customize menu.

=Title Radix...  Item on Customize Menu
=include debug Radix_Dialog_Box
=include debug g_radix
Choose Radix...  to set the radix for the entry and
 display of integer data.

=Title Language Item on Customize Menu
=include debug g_multilang
=include debug g_lang
=include debug g_langexpr
Choose Language to set the language context for the
 interpretation and display of symbols, expressions, and
 any other language-specific parameters.

=Title Language Submenu of Customize Menu
=include debug g_multilang
=include debug g_lang
Choose a language to set the language context for the
 interpretation and display of symbols, expressions, and
 any other language-specific parameters.

=Title Ada Item on Language Submenu of Customize Menu
Choose ADA to set the current language to Ada.

=Title BASIC Item on Language Submenu of Customize Menu
Choose BASIC to set the current language to BASIC.

=Title BLISS Item on Language Submenu of Customize Menu
Choose BLISS to set the current language to BLISS.

=Title C Item on Language Submenu of Customize Menu
Choose C to set the current language to C.

=Title COBOL Item on Language Submenu of Customize Menu
Choose COBOL to set the current language to COBOL.

=Title DIBOL Item on Language Submenu of Customize Menu
Choose DIBOL to set the current language to DIBOL.

=Title FORTRAN Item on Language Submenu of Customize Menu
Choose FORTRAN to set the current language to FORTRAN.

=Title MACRO Item on Language Submenu of Customize Menu
Choose MACRO to set the current language to MACRO.

=Title Pascal Item on Language Submenu of Customize Menu
Choose Pascal to set the current language to Pascal.

=Title PL/I Item on Language Submenu of Customize Menu
Choose PL/I to set the current language to PL/I.

=Title RPG Item on Language Submenu of Customize Menu
Choose RPG to set the current language to RPG.

=Title SCAN Item on Language Submenu of Customize Menu
Choose SCAN to set the current language to SCAN.

=Title Unknown Item on Language Submenu of Customize Menu
Choose Unknown to set the current language to Unknown.

 When debugging a program that is written in an
 unsupported language, set the language to Unknown.

 To maximize the usability of the debugger with
 unsupported languages, the Unknown setting causes the
 debugger to accept a large set of data formats and
 operators, including some that might be specific to
 only a few supported languages.

=Title Source Files...  Item on Customize Menu
=include debug Src_File_Dialog_Box
=include debug g_source_notavailable
Choose Source Files...  to specify where the debugger
 searches for source files that have been moved to
 another directory after being compiled.

=Title Logging...  Item on Customize Menu
=include debug Logging_Dialog_Box
=include debug g_log_file
Choose Logging...  to enable or disable the recording of
 debugger commands and debugger output into a file.  The
 file contains an exact record of a debugging session.

 You can execute a debugger log file as a command
 procedure to reconstruct a debugging session
 automatically.  To do so, enter the command @file-spec
 at the DBG> prompt in the command window

=Title Datatype Defaults...  Item on Customize Menu
=include debug Datatype_Dialog_Box
Choose Datatype Defaults...  to establish the default
 type for data entry and display to be associated with
 program locations.

=Title Other Attributes...  Item on Customize Menu
=include debug Other_Dialog_Box
Choose Other Attributes...  to establish defaults for
 miscellaneous operations that are not covered through
 other menu items:

  -  Enabling or disabling dynamic module and image
     setting

  -  Enabling or disabling the delivery of asynchronous
     system traps (ASTs) while your program is running

  -  Enabling or disabling the symbolization of address
     expressions

  -  Enabling or disabling dynamic process setting for
     multiprocess programs

  -  Enabling or disabling simultaneous interruption of
     executing processes for multiprocess programs

  -  Establishing the interpretation of double-precision
     floating-point constants as D_float or G_float in
     expressions

  -  Controlling the level of operand information when
     examining VAX instructions

  -  Controling the display of program locations in
     terms of line numbers or as routine-name +
     byte-offset.

=Title Help Menu in Main Window
Use the Help menu as follows:

  -  Choose Overview to obtain conceptual and
     task-oriented information about the debugger.

     The information that is available through the
     Overview menu item supplements the information that
     is available through context-sensitive help on
     individual items in debugger windows, menus, and
     dialog boxes.

  -  Choose About to obtain the version number for this
     release of the VMS debugger.

  -  Choose Using Debugger Help to obtain help on help.

=Title Help Menu in Main Window
Use the Help menu as follows:

  -  Choose Overview to obtain conceptual and
     task-oriented information about the debugger.

     The information that is available through the
     Overview menu item supplements the information that
     is available through context-sensitive help on
     individual items in debugger windows, menus, and
     dialog boxes.

  -  Choose About to obtain the version number for this
     release of the VMS debugger.

  -  Choose Using Debugger Help to obtain help on help.

=Title 'Overview' Item on Help Menu
=include debug Help_Menu_About
=include debug Help_Menu_Using
=include debug Help_Menu_Entry
 Choose Overview to obtain conceptual and task-oriented
 information about the debugger.

 The information that is available through the Overview
 menu item supplements the information that is available
 through context-sensitive help on individual items in
 debugger windows, menus, and dialog boxes.

=Title 'About' Item on Help Menu
=include debug Help_Menu_Overview
=include debug Help_Menu_Using
=include debug Help_Menu_Entry
 Choose this menu item to obtain the version number for
 this release of the VMS debugger.

=Title 'Using Debugger Help' Item on Help Menu
=include debug Help_Menu_Overview
=include debug Help_Menu_About
=include debug Help_Menu_Entry
 Choose this menu item to obtain help on help.

=Title Status Fields and Buttons in Debugger Main Window
=include debug Examine_Status_L_Button
=include debug Scopes_Status_L_Button
=include debug Process_Status_L_Button
Use the Current Entity, Call Frame, and Visible Process
 fields and buttons in the main window as indicated in
 the additional topics.

=title Current Entity Field and Buttons in Main Window
The Current Entity field in the main window identifies
 the last entity that was examined or deposited into
 (for example, a variable or a code location).  It is
 also the entity currently defined by the built-in
 symbol %CURLOC.

 If symbolization is available, the entity might be
 displayed as a symbol with a path name prefix or
 perhaps as a byte offset from a symbolic address
 expression (for example, TEST\X+4).  Symbolic address
 expressions include variable names, routine names,
 labels, and line numbers.

 No entity is displayed unless you have previously
 specified one in an examine or deposit operation.  See
 Operations that Can Update the Current Entity Field.

 When a current entity is defined, you can use the
 Current Entity arrow buttons to examine consecutive
 logical entities.  Otherwise, the buttons are dimmed.

 The debugger uses the type of the current entity to
 determine the logical successor and predecessor
 entities.  The current entity is reset with each click
 of one of the arrow buttons.

 Thus, when the current entity is an array variable, you
 can use the arrow buttons to examine consecutive array
 elements.  When the current entity is a code location,
 you can use the arrow buttons to examine consecutive
 VAX assembly-language instructions.

 By default, the debugger assigns the type longword
 integer to addresses or registers that are not
 associated with a symbolic name and, therefore, are not
 associated with a compiler-generated type.  See
 Examining Consecutive Memory Addresses.

 The topic Current, Next, and Previous Entity Built-In
 Symbols identifies built-in symbols that, when used
 with the Examine command (and related dialog boxes),
 achieve the same effect as the Current Entity arrow
 buttons.

 Note that the concept of previous or next logical
 entity might not apply to some entities, such as
 noncomposite variables (integer, real, and so on).

Additional information available:

g update curloc operationsg examine arr buttonsg examine inst buttonsg examine memory buttons

=title Operations that Can Update the Current Entity Field
=include debug g_intro_to_addrexpr
=include debug g_specifying_code
=include debug Examine_Status_L_Button
 The Current Entity field in the main window identifies
 the last entity that was examined or deposited into
 (for example, a variable or a code location).

 The following operations can update the Current Entity
 Field:

  -  Clicking on the Examine button in the main window
     or choosing Examine from the pop-up menu.

  -  Using the following dialog boxes (which are
     accessible from the Data menu):

       Examine Variable, Deposit into Variable
       Examine Code, Deposit Code
       Examine (Deposit into) Address or Register

  -  Clicking on the Current Entity arrow buttons.

  -  Specifying any of the built-in symbols that denote
     an address expression when examining or depositing.
     See Current, Next, and Previous Entity Built-In
     Symbols.

  -  Using an Examine or Deposit command, for example in
     an Action field of a dialog box or in a command
     procedure.

 When you are examining code address expressions, the
 Current Entity field duplicates some of the information
 in the current source or instruction window.  The
 entity is shown as a pathname consisting of a module
 name, line number, possibly a byte offset, and so on.

=title Examining Consecutive Array Elements
=include debug g_specifying_variables
=include debug Examine_Status_L_Button
=include debug g_intro_to_addrexpr
 You can use the Current Entity arrow buttons in the
 main window to examine consecutive indexed components
 of an array variable.

 For example, assume that you have examined or deposited
 into the third element of array ARR.  That element,
 which is expressed as ARR[3] in some languages, is now
 the current entity and is displayed in the Current
 Entity field.

 To display the value of the next array element, ARR[4],
 click on the down-arrow button.  Or, to display the
 value of the previous array element, ARR[2], click on
 the up-arrow button.

 Each time you click on an arrow button, the current
 entity is reset to the array element that is being
 examined.  That element is then identified in the
 Current Entity field, and its value is displayed in the
 current output window (window OUT, by default).

 The topic Current, Next, and Previous Entity Built-In
 Symbols identifies built-in symbols that, when used
 with the Examine command (and related dialog boxes),
 achieve the same effect as the Current Entity arrow
 buttons.

=title Examining Consecutive VAX Instructions
=include debug Ex_Code_Dialog_Box g_display_instructions
=include debug Examine_Status_L_Button
=include debug Code_Menu_Examine_Button
=include debug Code_Menu_Deposit_Button
=include debug g_specifying_code
=include debug g_intro_to_addrexpr
=include debug g_display_predwnds
=include debug g_display_instructions
=include debug Ctrl_Menu_Step_Button
=include debug inst_Disp_Cmds_Menu_View_Src
=include debug The_Popup_Menu g_examine
 You can use the Current Entity arrow buttons in the
 main window to examine consecutive assembly-language
 instructions that are associated with a code address
 expression (for example, a routine name).

 When you specify a code address expression in the
 following contexts, the current entity is set to the
 first instruction at that code location:

  -  When you choose Examine Code...  or Deposit into
     Code from the Code submenu of the Data menu

  -  When you choose View Instructions...  from the
     Commands menu of an instruction window

  -  When you choose Examine from the pop-up menu, or
     click on the Examine button in the main window

 For example, suppose you have specified line 12 in the
 Examine Code dialog box:

   Examine %LINE 12
     MOD3\%LINE 12:   MOVL  (R11),B^16(R11)

 The instruction displayed is the first instruction
 associated with line 12, and it is now the current
 entity.

 To display the next instruction associated with line
 12, click on the down-arrow button.  To display the
 previous instruction, click on the up-arrow button.
 Each time you click on an arrow button, the current
 entity is reset to the instruction that is being
 examined.

 For example:

   Examine next instruction (click on down-arrow):
     MOD3\%LINE 12+4: MOVL  S^#1,B^4(R11)

   Examine next instruction (click on down-arrow):
     MOD3\%LINE 12+8: TSTL  B^16(R11)

   Examine previous instruction (click on up-arrow):
     MOD3\%LINE 12+4: MOVL  S^#1,B^4(R11)

 If an instruction window with the instruction attribute
 is displayed, the examined instruction is centered and
 boxed in the window.  If no instruction window has the
 instruction attribute, the instruction is displayed in
 the current output window (window OUT, by default).

 The topic Current, Next, and Previous Entity Built-In
 Symbols identifies built-in symbols that, when used
 with the Examine command (and related dialog boxes),
 achieve the same effect as the Current Entity arrow
 buttons.

 A useful technique when debugging at the instruction
 level is to execute the program one instruction at a
 time.  To do so, choose Step by Instruction from the
 pop-up menu.  You can also establish a default
 instruction-based step unit (step to next instruction,
 step to next CALL instruction, and so on).  To
 establish a default step unit, choose Step...  from the
 Control menu.

 Note that, when you examine consecutive instructions in
 a MACRO program, the debugger might misinterpret data
 as instructions if storage for the data is allocated in
 the middle of a stream of instructions.

 The following example shows some MACRO code with two
 longwords of data storage allocated directly after the
 BRB instruction at line 7 (line numbers have been added
 to the example for clarity):

   module TEST
        1:         .TITLE  TEST
        2:
        3: START::
        4:         .WORD   0
        5:
        6:         MOVL    #2,R2
        7:         BRB     LABEL_2
        8:
        9:         .LONG   ^X12345
       10:         .LONG   ^X14465
       11:
       12: LABEL_2:
       13:         MOVL    #5,R5
       14:
       15:         .END    TEST$START

 Examining the code address expression %LINE 6 displays
 the instruction at the start of line 6:

   Examine %LINE 6
     TEST\START\%LINE 6:  MOVL   S^#02,R2

 Clicking on the down-arrow button causes the debugger
 to correctly interpret and display the logical
 successor entity as an instruction, at line 7:

   Examine next instruction (click on down-arrow):
     TEST\START\%LINE 7: BRB TEST\TEST$START\LABEL_2

 However, the following three clicks on the down-arrow
 button cause the debugger to interpret the three
 logical successors incorrectly as instructions:

   Examine next instruction:
     TEST\START\%LINE 7+2: MULF3  S^#11.00000,S^#0.5625000,S^#0.5000000

   Examine next instruction:
     ADDRESSMODE, instruction uses illegal or undefined addressing modes
     TEST\START\%LINE 7+6: MULD3  S^#0.5625000[R4],S^#0.5000000,@W^5505(R0)

   Examine next instruction:
     START+12:   HALT

=title Examining Consecutive Memory Addresses
=include debug g_specifying_code
=include debug Ex_Code_Dialog_Box g_display_instructions
=include debug g_specifying_variables
=include debug Cust_Menu_Datatype_Button
=include debug Examine_Status_L_Button
=include debug g_intro_to_addrexpr
 You can use the Current Entity arrow buttons in the
 main window to examine consecutive memory addresses.
 The behavior of the arrow buttons depends on the type
 that is associated with the current entity.

 If the current entity denotes a location that is
 associated with a compiler-generated type (and,
 therefore, a symbolic name), the debugger determines
 the next or previous logical entity according to that
 type.

 Thus, for an array variable, the down-arrow button sets
 the current entity to the next higher-numbered array
 element.  For a code location, the down-arrow button
 sets the current entity to the next instruction.

 By default, the debugger assigns the type longword
 integer to locations that are not associated with a
 symbolic name.  You can establish another default type
 by choosing Default Datatype...  from the Customize
 menu.  For such locations, the debugger determines the
 next or previous logical entity according to the
 default type.

 Thus, by default, for a location that does not have a
 compiler-generated type, the arrow buttons reset the
 start address of the current entity in increments of
 one longword (4 bytes).

 The topic Current, Next, and Previous Entity Built-In
 Symbols identifies built-in symbols that, when used
 with the Examine command (and related dialog boxes),
 achieve the same effect as the Current Entity arrow
 buttons.

=title Call Frame Field and Buttons in Main Window
=include debug g_callframe_label
=include debug g_callframe_buttons_display_src
=include debug g_callframe_buttons_display_inst
=include debug g_resolve_symb_using_callframe
=include debug g_resolve_symb
=include debug data_menu_callstack_button
=include debug g_display_source
=include debug g_display_instructions
=include debug g_Symb
The Call Frame field in the main window identifies the
 routine that the debugger uses as reference for the
 following purposes:

  -  When displaying source code in the current source
     window (window SRC, by default)

  -  When displaying decoded VAX instructions in the
     current instruction window (window INST, by
     default, if that window is displayed)

  -  When searching for symbols (variable names, routine
     names, and so on) that you specify

 The number displayed in the Call Frame field, to the
 left of the routine name, denotes the associated call
 frame on the routine call stack.

 By default, the routine identified is the one in which
 execution is currently suspended (the routine
 associated with call frame 0, at the top of the stack).

 The Call Frame arrow buttons enable you to reset the
 reference for source and instruction display and for
 symbol lookup to another call frame, which is then
 identified in the Call Frame field.

 A Call Frame arrow button that is dimmed indicates that
 the scope reference is at the end of the call stack.

 Note that the arrow buttons do not affect the execution
 of your program.

 To obtain detailed information about the call stack,
 Choose Call Stack...  from the Data menu.

=title Visible Process Field and Buttons in Main Window
=include debug g_multiproc
=include debug Data_Menu_Processes_Button
The Visible Process field and buttons in the main window
 are used when debugging multiprocess programs (programs
 that run in more than one process).  For programs that
 run in one process, the Visible Process field
 identifies the name of the process that is running the
 program being debugged.

 For a multiprocess program, the Visible Process field
 identifies the process that is currently the context
 for issuing process-specific commands.
 Process-specific commands are those that start
 execution (Step, Go, and so on) and those used for
 looking up symbols, setting breakpoints, looking at the
 call stack and registers, and so on.

 Commands that are not process specific are those that
 do not depend on the mapping of virtual memory but,
 rather, affect the entire debugging environment.

Additional information available:

set visible process

=title Using the Visible Process Arrow Buttons
=include debug Data_Menu_Processes_Button
=include debug Process_Status_L_Button
Use the Visible Process arrow buttons to set the visible
 process to another process that is currently under
 debugger control:

  -  Click on the right-arrow button to set the visible
     process to the process with the next higher process
     number.

  -  Click on the left-arrow button to set the visible
     process to the process with the next lower process
     number.

 The process list is circular.  For example, the next
 process after the highest-numbered process is the
 lowest-numbered process.

=Title Go, Step, Examine, and Stop Buttons in Main Window
=include debug Go_Button
=include debug step_button
=include debug examine_button
=include debug stop_button
=include debug The_Popup_Menu
=include debug The_Main_Window
By clicking on the Go, Step, Examine, or Stop buttons
 you can perform four common operations without having
 to use a dialog box or submenu.

 The Go button starts execution from the current program
 location.

 The Step button executes one step unit of your program
 (one source line, by default).

 The Examine button displays the current value of a
 variable (or other symbolic address expression) that is
 declared in your program and is currently selected in a
 window.  If no entity is currently selected, the
 Examine button displays the value of the entity last
 examined or deposited into.

 The Stop button interrupts program execution or a
 debugger operation that is currently taking place (for
 example, displaying a long stream of data).

=Title Go Button in Main Window
=include debug Go_Dialog_Box g_go
=include debug The_Popup_Menu g_go
=Include DEBUG Ctrl_Menu_Go_Button
=include debug Button_Region
Click on the Go button to start program execution from
 the current location.

 To start execution from another location, choose Go...
 from the Control menu and then specify the location in
 the dialog box.

=Title Step Button in Main Window
=include debug Step_Dialog_Box g_step
=include debug Ctrl_Menu_Step_Button
=include debug The_Popup_Menu
=include debug Button_Region
Click on the Step button to execute the program one step
 unit of execution.

 By default, a step unit is one executable line of
 source code.  To change the step unit and specify other
 Step command options, choose Step...  from the Control
 menu.

=Title Examine Button in Main Window
=include debug g_specifying_variables
=include debug Examine_Status_L_Button
=include debug Ex_Vbl_Dialog_Box g_examine_var
=include debug g_intro_to_addrexpr
=include debug Data_Menu_Variables_Entry
=include debug Data_Menu_Code_Entry
=include debug Data_Menu_Addresses_Entry
=include debug Ex_Code_Dialog_Box g_display_instructions
=include debug g_display_predwnds
=include debug The_Popup_Menu g_examine
=include debug Button_Region
Click on the Examine button to display the current value
 of a variable or other symbolic address expression.

 To examine a variable, proceed as follows:

 1.  Select the variable name from any window, observing
     the syntax of the source language.  For example,
     selecting ARR[4] specifies element 4 of array ARR
     in some languages.

 2.  Click on the Examine button.

 The debugger displays the value of the selected
 variable in the current output window (window OUT, by
 default).

 If no entity is currently selected, the Examine button
 displays the value of the entity last examined or
 deposited into (if any).  This entity is identified in
 the Current Entity field of the main window.

 To display the value associated with an arbitrary
 address expression, choose Variables, Code, or
 Addresses or Registers from the Data menu (then choose
 the Examine item from the associated submenu).

 If you examine a routine name (or any other symbolic
 address expression that is associated with code---that
 is, VAX assembly-language instruction), the output is
 displayed as follows:

  -  If an instruction window with the instruction
     attribute is displayed, the first instruction for
     the specified address expression is centered in the
     window and boxed.

  -  If no instruction window has the instruction
     attribute, the first instruction for the specified
     address expression is displayed in the current
     output window (window OUT, by default).

 Note:  By default, the predefined instruction window
 INST is not displayed and does not have the instruction
 attribute.  See Displaying the Predefined Windows INST,
 REG, and AUTO.

=Title Stop Button in Main Window
=include debug Data_Menu_Callstack_Button
=include debug The_Popup_Menu g_view_curloc
=include debug Button_Region
Click on the Stop button to do the following tasks:

  -  Interrupt program execution.  This is useful if the
     program is executing an infinite loop.

  -  Interrupt a debugger operation that is in progress.
     This is useful if you want to interrupt a debugger
     operation that is taking a long time to complete
     (for example, displaying a long stream of data).

 Clicking on the Stop button does not end the debugging
 session.

=Title COMMAND box
=include debug g_cmd_mode
=include debug Cust_Hide_Show_Command_DB
=include debug Cust_Menu_Entry
Use the COMMAND box to enter debugger commands at the
 prompt.  You must first assign the input focus to the
 command box.

=Title View Instructions Dialog Box
=include debug g_ok_apply_cancel_buttons
=include debug INST_Disp_Cmds_Menu_View_Src
=include debug Code_Menu_Examine_Button
=include debug g_display_predwnds
=include debug Examine_Status_L_Button g_examine_inst_buttons
=include debug Examine_Status_L_Button
=include debug g_display_instructions
=include debug The_Popup_Menu g_examine
=include debug examine_button
Use the View Instructions dialog box to display the VAX
 assembly-language instructions at a code location (an
 address expression associated with instructions).

 Proceed as follows:

 1.  Enter a code address expression in the Address
     Expression field.  Routine names, program labels,
     and line numbers are symbolic address expressions
     that are associated with code.

     Or, to determine the instructions associated with a
     source line, you can first select that line from a
     source window and then open the dialog box.  The
     module name and line number are automatically
     inserted in the Address Expression field.

 2.  Click on OK or Apply.

     The first instruction for the specified address
     expression is centered and boxed in the current
     instruction window.

 Note that choosing Examine Code...  from the Code
 submenu of the Data menu also enables you to display
 the instructions at a code location.  In addition, the
 Examine Code dialog box enables you to display
 information about the instruction operands.

Additional information available:

g address expression field

=title Address Expression Field
=include debug g_selecting_code
=include debug g_specifying_code
=include debug g_intro_to_addrexpr
Enter a code address expression in this field (that is,
 an address expression that is associated with one or
 more VAX assembly-language instructions).

 You can fill this field automatically by selecting text
 in a window before opening the dialog box.

=title OK, Apply, and Cancel Buttons
 The functions of the OK, Apply, and Cancel buttons are
 as follows:

   OK       Applies the current settings in the dialog
            box and closes the box.

   Apply    Applies the current settings, but does not
            close the dialog box. You can therefore apply
            different settings without having to re-open
            the dialog box.

   Cancel   Closes the dialog box without applying the
            current settings.

=title Displaying Source Code
 For information on this topic:

 1.  Display the Overview help topic (for example, by
     choosing Go To Overview from the View menu of this
     help window).

 2.  Choose Displaying Source Code from the list of
     additional topics

=title Displaying Decoded VAX Instructions
 For information on this topic:

 1.  Display the Overview help topic (for example, by
     choosing Go To Overview from the View menu this
     help window).

 2.  Choose Displaying Decoded VAX Instructions from the
     list of additional topics.

=title Controlling Access to Symbols in Your Program
 For information on this topic:

 1.  Display the Overview help topic (for example, by
     choosing Go To Overview from the View menu of this
     help window).

 2.  Choose Controlling Access to Symbols in Your
     Program from the list of additional topics.

=title Specifying Address Expressions
 For information on this topic:

 1.  Display the Overview help topic (for example, by
     choosing Go To Overview from the View menu of this
     help window).

 2.  Choose Specifying Address Expressions from the list
     of additional topics.

=title Specifying and Evaluating Language Expressions
 For information on this topic:

 1.  Display the Overview help topic (for example, by
     choosing Go To Overview from the View menu of this
     help window).

 2.  Choose Specifying and Evaluating Language
     Expressions from the list of additional topics.

=title Debugger Support for Languages
 For information on this topic:

 1.  Display the Overview help topic (for example, by
     choosing Go To Overview from the View menu of this
     help window).

 2.  Choose Debugger Support for Languages from the list
     of additional topics.

=title Debugging Multilanguage Programs
 For information on this topic:

 1.  Display the Overview help topic (for example, by
     choosing Go To Overview from the View menu of this
     help window).

 2.  Choose Debugging Multilanguage Programs from the
     list of additional topics.

=title The Debugger's Command Interface
 For information on this topic:

 1.  Display the Overview help topic (for example, by
     choosing Go To Overview from the View menu of this
     help window).

 2.  Choose The Debugger's Command Interface from the
     list of additional topics.

=TITLE Logging a Debugging Session into a File
 For information on this topic:

 1.  Display the Overview help topic (for example, by
     choosing Go To Overview from the View menu of this
     help window).

 2.  Choose Logging a Debugging Session into a File from
     the list of additional topics.

=title Debugging Shareable Images
 For information on this topic:

 1.  Display the Overview help topic (for example, by
     choosing Go To Overview from the View menu of this
     help window).

 2.  Choose Debugging Shareable Images from the list of
     additional topics.

=title Debugging Multiprocess Programs
 For information on this topic:

 1.  Display the Overview help topic (for example, by
     choosing Go To Overview from the View menu of this
     help window).

 2.  Choose Debugging Multiprocess Programs from the
     list of additional topics.

=title Specifying Code Address Expressions
 For information on this topic:

 1.  Display the Overview help topic (for example, by
     choosing Go To Overview from the View menu of this
     help window).

 2.  Choose Specifying Address expressions from the list
     of additional topics.

 3.  Choose Specifying Code Address Expressions from the
     list of additional topics.

=title Selecting Code Address Expressions from Windows
 For information on this topic:

 1.  Display the Overview help topic (for example, by
     choosing Go To Overview from the View menu of this
     help window).

 2.  Choose Specifying Address expressions from the list
     of additional topics.

 3.  Choose Selecting Code Address Expressions from
     Windows from the list of additional topics.

=title Selecting Variables from Windows
 For information on this topic:

 1.  Display the Overview help topic (for example, by
     choosing Go To Overview from the View menu of this
     help window).

 2.  Choose Specifying Address expressions from the list
     of additional topics.

 3.  Choose Selecting Variables from Windows from the
     list of additional topics.

=title Specifying Variables
 For information on this topic:

 1.  Display the Overview help topic (for example, by
     choosing Go To Overview from the View menu of this
     help window).

 2.  Choose Specifying Address expressions from the list
     of additional topics.

 3.  Choose Specifying Variables from the list of
     additional topics.

=title Displaying the Predefined Windows INST, REG, and AUTO
 For information on this topic:

 1.  Display the Overview help topic (for example, by
     choosing Go To Overview from the View menu of this
     help window).

 2.  Choose Debugger Windows and Menus from the list of
     additional topics.

 3.  Choose Displaying the Predefined Windows INST, REG,
     and AUTO from the list of additional topics.

=title Making Source Code Available for Display
 For information on this topic:

 1.  Display the Overview help topic (for example, by
     choosing Go To Overview from the View menu of this
     help window).

 2.  Choose Displaying Source Code from the list of
     additional topics.

 3.  Choose Making Source Code Available for Display
     from the list of additional topics.

=title Controlling the Radix for Integer Data
 For information on this topic:

 1.  Display the Overview help topic (for example, by
     choosing Go To Overview from the View menu of this
     help window).

 2.  Choose Specifying and Evaluating Language
     Expressions from the list of additional topics.

 3.  Choose Controlling the Radix for Integer Data from
     the list of additional topics.

=title Symbol Tables Used by the Debugger (DST, GST, RST)
 For information on this topic:

 1.  Display the Overview help topic (for example, by
     choosing Go To Overview from the View menu of this
     help window).

 2.  Choose Controlling Access to Symbols in Your
     Program from the list of additional topics.

 3.  Choose Symbol Tables Used by the Debugger (DST,
     GST, RST) from the list of additional topics.

=title Setting and Canceling Modules
 For information on this topic:

 1.  Display the Overview help topic (for example, by
     choosing Go To Overview from the View menu of this
     help window).

 2.  Choose Controlling Access to Symbols in Your
     Program from the list of additional topics.

 3.  Choose Setting and Canceling Modules from the list
     of additional topics.

=title Resolving Symbol Ambiguities
 For information on this topic:

 1.  Display the Overview help topic (for example, by
     choosing Go To Overview from the View menu of this
     help window).

 2.  Choose Controlling Access to Symbols in Your
     Program from the list of additional topics.

 3.  Choose Resolving Symbol Ambiguities from the list
     of additional topics.

=title Explanation of Call Frame Field
=include debug g_symb
=include debug g_symb_mod_set
=include debug g_callframe_buttons_display_src
=include debug g_callframe_buttons_display_inst
=include debug g_resolve_symb_using_callframe
 The following text is displayed in the Call Frame
 field:

  -  A non-negative decimal integer that denotes the
     relative level of a call frame on the routine call
     stack.

     Call frame 0 (also known as scope 0 or the PC
     scope) denotes the routine at the top of the call
     stack, where execution is currently suspended.
     Call frame 1 (scope 1) denotes the calling routine,
     if any.  Call frame 2 denotes its caller, and so
     on.  The last routine down the call stack is the
     main program (the routine with the image transfer
     address).

  -  The name of the routine associated with the call
     frame indicated, including its path name prefix.
     The routine name is displayed only if the module
     associated with that call frame is set.

 By default, call frame 0 and its routine are identified
 in the Call Frame field.  By using the arrow buttons,
 you can reset the reference for symbol lookup and
 source and instruction display to another call frame on
 the stack.

=title Using Call Frame Arrow Buttons to Display Source Code
=include debug g_callframe_label
=include debug g_display_source
=include debug g_source_notavailable
=include debug g_callframe_buttons_display_inst
=include debug g_resolve_symb_using_callframe
=include debug Scopes_Status_L_Button
 By default, window SRC displays the source code for the
 routine in which execution is currently suspended.
 This is the routine associated with call frame 0, at
 the top of the call stack, as indicated in the Call
 Frame field of the main window.

 A convenient way to display the source code for
 routines on the call stack is to use the Call Frame
 arrow buttons in the main window:

  -  Clicking on the down-arrow button causes the source
     code of the calling routine (if any) to be
     displayed.

  -  Clicking on the up-arrow button causes the source
     code of the called routine (if any) to be
     displayed.

 If the debugger cannot locate source code for display,
 it tries to display source code in the next routine
 down on the call stack for which source code is
 available.  If the debugger can display source code for
 such a routine, it issues the following message:

    SOURCESCOPE, Source lines not available for .0\%PC.
      Displaying source in a caller of the current routine.

 In such cases, the boxed line in the source window
 identifies the line that contains code following the
 call statement in the calling routine.

=title Using Call Frame Arrow Buttons to Display Instructions
=include debug g_callframe_label
=include debug g_display_instructions
=include debug g_callframe_buttons_display_src
=include debug g_resolve_symb_using_callframe
=include debug Scopes_Status_L_Button
 By default, window INST displays the decoded VAX
 assembly-language instruction stream for the routine in
 which execution is currently suspended.  This is the
 routine associated with call frame 0, at the top of the
 call stack, as indicated in the Call Frame field of the
 main window.

 A convenient way to display the decoded instructions
 for routines on the call stack is to use the Call Frame
 arrow buttons in the main window:

  -  Clicking on the down-arrow button causes the
     instructions for the calling routine (if any) to be
     displayed.

  -  Clicking on the up-arrow button causes the
     instructions for the called routine (if any) to be
     displayed.

=title Using Call Frame Arrow Buttons to Resolve Symbols
=include debug g_resolve_symb
=include debug g_callframe_buttons_display_src
=include debug g_callframe_buttons_display_inst
=include debug Scopes_Status_L_Button
 If a symbol is defined multiple times among routines
 that are active on the call stack, you can use the Call
 Frame arrow buttons in the main window to access a
 particular declaration of the symbol without having to
 use a path name prefix.

 The Call Frame field always shows the scope reference
 that the debugger uses for symbol searches.  By
 default, this is scope 0---the scope of the routine at
 the top of the call stack.

 The Call Frame arrow buttons enable you to change the
 scope reference for symbol searches as follows:
 Clicking once on the down-arrow button changes the
 search list from the default 0,1,2...N to 1,2,3...N.
 As a result, the Call Frame field shows scope 1.
 Clicking once more changes it to 2,3,4...N (the Call
 Frame field shows scope 2), and so on.  Conversely,
 clicking on the up-arrow button sets the reference to
 the next level up the call stack.

 The following examples show how you can use these
 buttons to change the convention for symbol lookup:

 Suppose a local variable X is defined twice in your
 program, within two routines that are currently on the
 stack.  One routine is associated with call frame 1,
 the other with frame 3.  When you specify X, the
 debugger by default searches down the call stack from
 frame 0 and uses the declaration of X in call frame 1.
 If you click on the down-arrow button to set the call
 frame to 2 or 3, the debugger then uses the declaration
 of X in call frame 3.

 In another example, suppose a routine has been called
 recursively several times, each time assigning a new
 value to variable X.  When the Call Frame field is set
 to 0, the debugger obtains the value of X in the
 current routine call.  When the Call Frame field is set
 to 1, the debugger obtains the value of X in the
 preceding call (in scope 1), and so on.

=Title Gone

=Title Break Dialog Box
=include debug g_ok_apply_cancel_buttons
=include debug The_Popup_Menu g_break
Use the Break dialog box to set, identify, or cancel
 breakpoints or tracepoints.

Additional information available:

g breaktracebehavior break dialogg set breakidentify breakcancel break
set canceltargetg address expression fieldg list boxg notification option menu
g Condition fieldg after passes fieldg action fieldg instructions field
g event fieldwithin calls buttong jsb routines buttong shareable routines button
g system routines button

=title Using Breakpoints and Tracepoints
=include debug Ctrl_Menu_Breakpoint_Button
=include debug The_Popup_Menu g_break
=include debug g_exec
=include debug Break_Dialog_Box
To set a breakpoint or tracepoint in your program,
 choose Break...  from the Control menu.

 A breakpoint is a location in your program at which
 execution is to be suspended.  Typical locations are
 routine declarations, program labels, and specific
 lines of source code.  At a breakpoint, you can step
 into a routine, check the current value of a variable,
 and so on.

 In addition to specifying unique locations, you can set
 breakpoints on every source line or on certain classes
 of VAX assembly-language instructions.  You can also
 set breakpoints on certain kinds of events, such as
 exceptions and Ada tasking events.  And you can set
 conditional breakpoints that trigger only when a
 specified expression is evaluated to be true.

 A tracepoint is like a breakpoint, except that
 execution continues after the debugger reports that the
 tracepoint has been reached.  Tracepoints enable you to
 monitor the path of execution of your program through
 specified locations (for example, through routine
 calls).  As with breakpoints, you can trace through
 classes of instructions, monitor events, and set
 conditional tracepoints.

=title Debugger Behavior at Breakpoints and Tracepoints
When a breakpoint or tracepoint is triggered, the
 debugger takes the following action:

 1.  Suspends program execution at the breakpoint or
     tracepoint location.

 2.  If an integer value was specified in the After
     field when the breakpoint or tracepoint was set,
     checks the current count.  If the specified number
     of counts has not been reached, execution is
     resumed and the debugger does not perform the
     remaining steps.

 3.  Evaluates the expression that was specified in the
     Condition field, if any, when the breakpoint or
     tracepoint was set.  If the value of the expression
     is FALSE, execution is resumed and the debugger
     does not perform the remaining steps.

 4.  Reports that execution has reached the breakpoint
     or tracepoint location by issuing a "break..." or
     "trace..." message, unless the 'off' option was
     specified in the Notification option menu.

 5.  Displays the line of source code in which execution
     is suspended, unless the 'off' or 'on, without
     source display' option was specified in the
     Notification option menu, either in the Break
     dialog box or, previously, as a Step command
     default in the Step dialog box.

 6.  Executes the debugger commands specified in the
     Action field, if any were specified when the
     breakpoint or tracepoint was set.  In the case of a
     breakpoint, if a GO command was specified,
     execution continues and the debugger does not
     perform the remaining step.

 7.  If a tracepoint was set, resumes execution.

=title Setting Breakpoints and Tracepoints
=include debug Break_Dialog_Box set_cancel
=include debug Break_Dialog_Box target
=include debug Break_Dialog_Box g_address_expression_field
=include debug g_selecting_code
To set a breakpoint or tracepoint with the Break dialog
 box, proceed as follows:

 1.  Choose the appropriate 'Set...' option from the
     Set/Cancel (upper-left) option menu.

     A temporary breakpoint or tracepoint disappears
     after it is triggered.  The breakpoint or
     tracepoint does not remain permanently set.

 2.  Choose the kind of breakpoint or tracepoint on the
     Target (upper-right) option menu (for example, on a
     specified address, on every source line, on a
     particular VAX instruction, or on a class of
     instructions).

 3.  If setting a breakpoint or tracepoint on a
     specified address, enter an address expression that
     is associated with code (one or more VAX
     instructions) in the Address Expression field.
     Routine names, program labels, and line numbers are
     symbolic address expressions that are associated
     with code.

     Or, before opening the dialog box, select a line in
     a source or instruction window at which to set a
     breakpoint or tracepoint.  The module name and line
     number are automatically inserted in the Address
     Expression field.

 4.  If setting breakpoints or tracepoints on every
     source line or on classes of instructions, do not
     specify an address expression.

 5.  If setting breakpoints or tracepoints on events
     (Ada or SCAN programs), you can specify an address
     expression with certain event name keywords (see
     your language documentation).

 6.  Choose any additional options from the dialog box,
     then click on OK or Apply.

 Any breakpoints or tracepoints that are currently set
 are identified in the list box.  Some breakpoints and
 tracepoints are predefined when you invoke the debugger
 with certain kinds of programs (for example, Ada or
 multiprocess programs).  Predefined breakpoints and
 tracepoints are identified as such in the list box.

 You can set and cancel a (user defined) breakpoint or
 tracepoint independently of a predefined breakpoint or
 tracepoint that was set on the same location or event.

 However, setting a breakpoint on the same location or
 classes of locations (instructions, lines, events, and
 so on) as a previously set tracepoint cancels the
 breakpoint, and conversely.

=title Identifying the Current Breakpoints and Tracepoints
Any breakpoints or tracepoints that are currently set
 are identified in the list box.  Some breakpoints and
 tracepoints are predefined when you invoke the debugger
 with certain kinds of programs (for example, Ada,
 multiprocess).  Predefined breakpoints and tracepoints
 are identified as such in the list box.

 If you established a breakpoint or tracepoint using the
 After field, the current value of the decimal integer N
 is displayed (that is, the originally specified integer
 value minus one for each time the breakpoint or
 tracepoint location was reached).  The debugger
 decrements N each time the breakpoint or tracepoint
 location is reached until the value of N is zero, when
 the debugger takes break or trace action.

=title Canceling Breakpoints and Tracepoints
Any breakpoints or tracepoints that are currently set
 are identified in the list box.  To cancel a breakpoint
 or tracepoint:

 1.  In the list box, click on the breakpoint or
     tracepoint to be canceled.

 2.  Click on the Cancel selected option from the
     Set/Cancel option menu.

 3.  Click on OK or Apply.

 Some breakpoints and tracepoints are predefined when
 you invoke the debugger with certain kinds of programs
 (for example, Ada or multiprocess programs).
 Predefined breakpoints and tracepoints are identified
 as such in the list box.

 You can set and cancel a (user defined) breakpoint or
 tracepoint independently of a predefined breakpoint or
 tracepoint that was set on the same location or event.

 Setting a breakpoint on the same location or class of
 locations (instructions, lines, events, and so on) as a
 previously set tracepoint cancels the tracepoint, and
 conversely.

=title Set/Cancel (Upper-Left) Option Menu
Use the Set/Cancel option menu to specify that you want
 to set or cancel one or more breakpoints or
 tracepoints.

 A temporary breakpoint or tracepoint disappears after
 it is triggered.  The breakpoint or tracepoint does not
 remain permanently set.

 Use the Cancel selected option to cancel a breakpoint
 or tracepoint that you have selected in the list box:

 1.  In the list box, click on the breakpoint or
     tracepoint to be canceled.

 2.  Click on the Cancel selected option from the
     Set/Cancel option menu.

 3.  Click on OK or Apply.

=title Target (Upper-Right) Option Menu
Use the Target option menu to specify the kind of
 breakpoint or tracepoint that you want to set (for
 example, on a specified address, on every source line,
 on a particular VAX instruction, or on a class of
 instructions).

Additional information available:

addressinstructionbranchcallreturnevery instline
exceptioneventactivationtermination

=title 'on the specified address' Option
=include debug Break_Dialog_Box g_address_expression_field
=include debug Break_Dialog_Box target instruction
=include debug Break_Dialog_Box target
Use this option when setting a breakpoint or tracepoint
 on a particular location in your program.

 You specify the location by entering an address
 expression in the Address Expression field.  For
 breakpoints or tracepoints, use an address expression
 that is associated with code (one or more VAX
 instructions).

=title 'on the specified instruction' Option
=include debug Break_Dialog_Box g_instructions_field
=include debug Break_Dialog_Box within_calls_button
=include debug Break_Dialog_Box target
Causes the debugger to break on or trace one or more
 specified VAX instructions, if encountered during
 execution.

 You specify the instructions by entering a list of one
 or more instruction opcodes in the Instructions field.

=title 'on every branch instruction' Option
=include debug Break_Dialog_Box within_calls_button
=include debug Break_Dialog_Box target
Causes the debugger to break on or trace every branch
 instruction encountered during program execution.

 These include the BEQL, BGTR, BLEQ, BGEQ, BLSS, BGTRU,
 BLEQU, BVC, BVS, BGEQU, BLSSU, BRB, BRW, JMP, BBS, BBC,
 BBSS, BBCS, BBSC, BBCC, BBSSI, BBCCI, BLBS, BLBC, ACBB,
 ACBW, ACBL, ACBF, ACBD, ACBG, ACBH, AOBLEQ, AOBLSS,
 SOBGEQ, SOBGTR, CASEB, CASEW, and CASEL instructions.

=title 'on every call instruction' Option
=include debug Break_Dialog_Box within_calls_button
=include debug Break_Dialog_Box target
Causes the debugger to break on or trace every call
 instruction encountered during program execution.

 These include the CALLS, CALLG, BSBW, BSBB, JSB, RSB,
 and RET instructions.

=title 'on the return instruction' Option
=include debug Break_Dialog_Box g_address_expression_field
=include debug Break_Dialog_Box within_calls_button
=include debug Break_Dialog_Box target
Causes the debugger to break on or trace the return
 (RET) instruction of a specified routine.

 When using this option, you must specify an address
 expression for the routine in the Address Expression
 field.  For example, enter the routine name or the line
 number for the routine declaration.

 You can use this option only with routines called with
 a CALLS or CALLG instruction; it cannot be used with
 JSB routines.

 Breaking on the RET instruction enables you to inspect
 the local environment (for example, obtain the values
 of local variables) before the RET instruction deletes
 the routine's call frame from the call stack.

 The address expression specified is an instruction
 address within a CALLS or CALLG routine.  It can be
 simply be a routine name, in which case it specifies
 the routine start address.  However, you can also
 specify another location in a routine, so you can see
 only those returns that are taken after a certain code
 path is followed.

 Setting a breakpoint on the return instruction of a
 routine cancels any previous breakpoint that was set on
 that same routine.

=title 'on every instruction' Option
=include debug Break_Dialog_Box within_calls_button
=include debug Break_Dialog_Box target
Causes the debugger to break on or trace every
 instruction encountered during program execution.

=title 'on every line' Option
=include debug Break_Dialog_Box within_calls_button
=include debug Break_Dialog_Box target
Causes the debugger to break on or trace the start of
 each source line encountered during program execution.

=title 'on every exception' Option
=include debug Break_Dialog_Box within_calls_button
=include debug Break_Dialog_Box target
Causes the debugger to break or trace whenever an
 exception is signaled.  The exception breakpoint or
 tracepoint is triggered before any application-declared
 exception handler is invoked.

 When an exception breakpoint is triggered, the debugger
 suspends execution and reports the exception condition.
 When you resume execution, the behavior is as follows:

  -  If you enter a Go command without specifying an
     address expression, the exception is resignaled,
     thus allowing any application-declared exception
     handler to execute.

  -  If you enter a Go command and specify an address
     expression, execution continues at the specified
     location, thus inhibiting the execution of any
     application-declared exception handler.

  -  If you enter a Step command, the debugger steps
     into any application-declared exception handler.
     If there is no application-declared handler for
     that exception, the debugger resignals the
     exception.

  -  If you enter a Call command, the routine specified
     is executed.  If a routine is called with the Call
     command directly after an exception breakpoint has
     been triggered, no breakpoints, tracepoints, or
     watchpoints set within that routine are triggered.
     However, they are triggered if the Call command is
     given at another time.

 When an exception tracepoint is triggered, the debugger
 reports the exception condition and resignals the
 exception, thus allowing any application-declared
 exception handler to execute.

=title 'on the specified event' Option
=include debug Break_Dialog_Box g_address_expression_field
=include debug Break_Dialog_Box target
Note:  This option applies only to Ada and SCAN
 programs.  See the VAX Ada and VAX SCAN documentation
 for complete information.

 Causes the debugger to break on or trace a specified
 event (if that event is defined and detected by the
 run-time system).

 You can specify an address expression (in the Address
 Expression field) for certain events.  In such cases,
 the debugger breaks or traces whenever the specified
 event occurs for that address expression.

=title 'on activation' Option
=include debug g_multiproc
=include debug Break_Dialog_Box target
Note:  This option applies to a multiprocess debugging
 configuration.

 Causes the debugger to break or trace when a new
 process comes under debugger control.

=title 'on termination' Option
=include debug Break_Dialog_Box target
Causes the debugger to break or trace when a process
 performs an image exit.

 Note that the debugger always gains control when the
 last image of a one-process or multiprocess program
 exits.

 A process is terminated when the image has executed the
 $EXIT system service and all of its exit handlers have
 executed.

=title Address Expression Field
=include debug g_selecting_code
=include debug g_specifying_code
=include debug g_intro_to_addrexpr
Enter a code address expression in this field (that is,
 an address expression that is associated with one or
 more VAX assembly-language instructions).

 You can fill this field automatically by selecting text
 in a window before opening the dialog box.

 Note:  If you specify a memory address or an address
 expression whose value is not a symbolic location,
 check that an instruction actually begins at the byte
 of memory so indicated.  Choose Examine Code...  from
 the Code submenu of the Data menu.

 If an instruction does not begin at this byte, a
 run-time error can occur when an instruction including
 that byte is executed.

 When you set a breakpoint or tracepoint by specifying
 an address expression whose value is not a symbolic
 location, the debugger does not verify that the
 specified location marks the beginning of an
 instruction.  CALLS and CALLG routines start with an
 entry mask.

=title Breakpoint/Tracepoint List Box
The list box identifies the breakpoints and tracepoints
 that are currently set.

 Some breakpoints and tracepoints are predefined when
 you invoke the debugger with certain kinds of programs
 (for example, Ada, multiprocess).  Predefined
 breakpoints and tracepoints are identified as such in
 the list box.

 If you established a breakpoint or tracepoint using the
 After field, the current value of the decimal integer N
 is displayed (that is, the originally specified integer
 value minus one for each time the breakpoint or
 tracepoint location was reached).  The debugger
 decrements N each time the breakpoint or tracepoint
 location is reached until the value of N is zero, when
 the debugger takes break or trace action.

=title Notification Option Menu
The Notification option menu controls the debugger
 output that is displayed when the breakpoint or
 tracepoint is triggered.

 On, with source display (default):
    The "break..." or "trace..." message and the source
    line for the current location are displayed at the
    breakpoint or tracepoint.

 On, without source display:
    The "break..." or "trace.." message is displayed at
    the breakpoint or tracepoint, but the source line
    for the current location is not displayed.

 Off:
    Neither the "break..." or "trace..." message nor the
    source line for the current location are displayed
    at the breakpoint or tracepoint.

 Note that the default Notification option that is
 established for the Step command in the Step dialog box
 also affects the debugger output when any breakpoint,
 tracepoint, or watchpoint is triggered.  The
 Notification option you choose in the Break dialog box
 overrides the default established in the Step dialog
 box, but only for the breakpoint or tracepoint that you
 are setting.

=title Condition Field
Use this field to specify a conditional expression in
 the currently set language that is to be evaluated when
 execution reaches the breakpoint or tracepoint.

 If the expression is true, break or trace action
 occurs, and the debugger reports that a break or trace
 has occurred.  If the expression is false, break or
 trace action does not occur.  In this case, a report is
 not issued, any commands specified in the Action field
 are not executed, and program execution is continued.

=title After ___ Pass Field
Use this field to specify that break or trace action not
 be taken until the Nth time the designated breakpoint
 or tracepoint is encountered (after N passes).  Specify
 N as a decimal integer.  The default is 1.

 Thereafter, break or trace action occurs every time the
 breakpoint or tracepoint is encountered, provided that
 conditions in the Condition field (if specified) are
 true.

=title Action Field
=include debug g_cmd_mode
Use this field to specify one or more debugger commands
 to be executed when break or trace action is taken..
 Use semicolons (;) to separate command strings.

=title Instructions Field
=include debug Break_Dialog_Box within_calls_button
If you choose 'the specified instruction(s)' on the
 Target (upper-right) option menu, use this field to
 specify a list of one or more VAX instructions
 (opcodes), separated by commas.

 This causes the debugger to break on or trace every
 instruction whose opcode is specified in the list, if
 encountered during execution.

=title Event Field
Note:  This field applies only to Ada and SCAN programs.
 See the VAX Ada and VAX SCAN documentation for complete
 information.

 If you choose 'the specified event' on the Target
 (upper-right) option menu, use this field to specify an
 event for the debugger to break on or trace (if that
 event is defined and detected by the run-time system).

 You can specify an address expression (in the Address
 Expression field) for certain events.  In such cases,
 the debugger breaks or traces whenever the specified
 event occurs for that address expression.

=title Within Called Routines Button
=include debug Break_Dialog_Box g_jsb_routines_button
=include debug Break_Dialog_Box g_shareable_routines_button
=include debug Break_Dialog_Box g_system_routines_button
This button applies only to breakpoints or tracepoints
 set on instructions or on every line---that is, when an
 address expression is not explicitly specified.

 Button on (default):
    Causes the debugger to break on or trace the
    specified points within called routines (as well as
    within the routine in which execution is currently
    suspended).

    When the button is on, you can further qualify the
    break or trace action within routines that are
    called by JSB instructions, routines in shareable
    images, or system service routines (by means of the
    corresponding buttons, which are displayed below
    this button).

 Button off:
    Causes the debugger to break on or trace the
    specified points only within the routine in which
    execution is currently suspended (not within called
    routines).

=title Within Routines Called by a JSB Instruction Button
=include debug Break_Dialog_Box within_calls_button
This button applies only to breakpoints or tracepoints
 set on instructions or on every line (that is, when an
 address expression is not explicitly specified) and
 only when the Within Called Routines button is on.

 Button on (default for all languages except DIBOL):
    Permits the debugger to break or trace within
    routines that are called by the JSB or CALL
    instruction.

 Button off (DIBOL default):
    Specifies that breakpoints or tracepoints not be set
    within routines called by JSB instructions.  In
    DIBOL, user-written routines are called by the CALL
    instruction and DIBOL run-time library routines are
    called by the JSB instruction.

=title Within Called Routines in Shareable Images Button
=include debug Break_Dialog_Box within_calls_button
This button applies only to breakpoints or tracepoints
 set on instructions or on every line (that is, when an
 address expression is not explicitly specified) and
 only when the Within Called Routines button is on.

 Button on (default):
    Permits the debugger to break or trace within
    shareable image routines as well as other routines.

 Button off:
    Specifies that breakpoints or tracepoints not be set
    within shareable images.

=title Within Called System Service Routines Button
=include debug Break_Dialog_Box within_calls_button
This button applies only to breakpoints or tracepoints
 set on instructions or on every line (that is, when an
 address expression is not explicitly specified) and
 only when the Within Called Routines button is on.

 Button on (default):
    Permits the debugger to break within system routines
    (P1 space) as well as other routines.

 Button off:
    Specifies that breakpoints not be set within system
    routines.

=Title Call Dialog Box
=include debug g_ok_apply_cancel_buttons
Use the Call dialog box to execute a routine
 independently of the normal execution of the program.
 The routine must have been linked with your program,
 but the program does not need to include a call to the
 routine.

 To call a routine, proceed as follows:

 1.  Enter the routine name in the Routine field.

 2.  Specify the parameters to be passed during the
     routine call in the Parameters field.

 3.  Choose whether to enable or disable the delivery of
     asynchronous system traps during the execution of
     the routine.

 4.  Click on OK or Apply.

Additional information available:

behavior call dialogg routine fieldg parameters fieldg asts enabled button

=title Behavior of Call Command
When you use the debugger Call command to call a
 routine, the debugger takes the following action:

  -  Saves the current values of the general registers.

  -  Constructs an argument list.

  -  Executes a call to the routine specified and passes
     any specified arguments.

  -  Executes the routine.

  -  Displays the value returned by the routine in
     register R0.  By VMS convention, after a called
     routine has executed, register R0 contains the
     function return value (if the routine is a
     function) or the procedure completion status (if
     the routine is a procedure that returns a status
     value).

     If a called procedure does not return a status
     value or function value, the value in R0 might be
     meaningless, and the "value returned" message can
     be ignored.

     If a routine changes the value of a passed
     parameter, returning the new value, you cannot use
     the Call command to call the routine and obtain the
     new value.

  -  Restores the values of the general registers to the
     values they had just before the call was executed.

 The debugger assumes that the called routine conforms
 to the VAX Procedure Calling Standard.  However, note
 that the debugger does not support all the
 argument-passing mechanisms for all supported
 languages.  Therefore, you might need to specify how to
 pass parameters---for example, use Call SUB1(%VAL X)
 rather than Call SUB1(X).  See your language
 documentation for complete information about how
 arguments are passed to routines.

 Note that, if you use the Call command to call a
 routine that modifies the value of a passed parameter
 and returns a new value, the returned value might be
 unreliable.

=title Routine Field
=include debug g_specifying_code
=include debug g_selecting_code
Use this field to specify the name of the routine to be
 called.

=title Parameters Field
Use this field to specify one or more parameters that
 are required by the routine.  When specifying several
 parameters, separate them with commas.

 You can pass parameters by address (the default), by
 descriptor, by reference, and by value.  You specify
 the passing mode by preceding the parameter with one of
 the built-in symbols %ADDR, %DECR, %REF, and %VAL,
 respectively, as follows:

  -  To pass the parameter by address (default), use the
     following format:

         %ADDR address-expression

     The debugger evaluates the address expression and
     passes that address to the routine specified.  For
     simple variables (such as X), the address of X is
     passed into the routine.  This passing mechanism
     corresponds to the way FORTRAN implements
     ROUTINE(X).  In other words, for named variables,
     using %ADDR corresponds to a call by reference in
     FORTRAN.

     For other expressions, however, you must pass the
     parameter by reference.  For complex or structured
     variables (such as arrays, records, and access
     types), the address is passed when you specify
     %ADDR, but the called routine might not handle the
     passed data properly.  Do not specify a literal
     value (a number or an expression composed of
     numbers) when using %ADDR.


  -  To pass the parameter by descriptor, use the
     following format:

         %DESCR language-expression

     The debugger evaluates the language expression and
     builds a VAX-standard descriptor to describe the
     value.  The descriptor is then passed to the
     routine you named.  You might use this technique to
     pass strings to a FORTRAN routine.


  -  To pass the parameter by reference, use the
     following format:

         %REF language-expression

     The debugger evaluates the language expression and
     passes a pointer to the value, into the called
     routine.  This passing mechanism corresponds to the
     way FORTRAN passes the result of an expression.


  -  To pass the parameter by value, use the following
     format:

         %VAL language-expression

     The debugger evaluates the language expression and
     passes the value directly to the called routine.

=title ASTs Enabled During Execution Button
Button on (default):
    The delivery of asynchronous system traps (ASTs) is
    enabled during the execution of the called routine.
    Note that the delivery of ASTs is enabled if, and
    only if, delivery was enabled before the Call
    command was entered.

 Button off:
    The delivery of ASTs is disabled during the
    execution of the called routine.

=Title Call Stack Dialog Box
=include debug g_ok_apply_cancel_buttons
=include debug Scopes_Status_L_Button
=include debug g_symb_mod_set
=include debug Data_Menu_Modules_Button
Use the Call Stack dialog box to display information
 about the call frames that are currently active on the
 routine call stack.

 Proceed as follows:

  -  Choose 'Show calls by routine name' from the option
     menu to determine the sequence of routine calls
     leading to the point at which execution is
     currently suspended.

  -  Choose 'Show calls by call frame' to display more
     detailed information about each call frame.

  -  Click on the Depth scale to specify the number of
     call frames to display.

  -  Click on OK or Apply.

 Whenever a call is made to a routine during program
 execution, the VMS operating system creates a separate
 call frame on the stack.  Each call frame stores
 information about the calling routine.  The call frame
 for the most recently called routine is on the top of
 the stack.

 When a routine returns execution to its caller, the
 call frame for that routine is removed from the stack.

Additional information available:

calls by namecalls by frameg depth scale

=title Show calls by routine name
=include debug Callstk_Dialog_Box calls_by_frame
=include debug Scopes_Status_L_Button
=include debug Data_Menu_Modules_Button
This option identifies the currently active routines on
 the call stack, to the depth specified by the Depth
 scale on the dialog box.

 The Show calls by routine name option shows a traceback
 that lists the sequence of active routine calls that
 lead to the routine in which execution is currently
 suspended.  Any recursive routine calls are shown in
 the display, so you can use this feature to examine the
 chain of recursion.

 One line of information is displayed for each call
 frame, starting with the most recent call.  The top
 line identifies the currently executing routine, the
 next line identifies its caller, the following line
 identifies the caller of the caller, and so on.

 The following information is provided for each call
 frame:

  -  The name of the enclosing module.  An asterisk (*)
     to the left of a module name indicates that the
     module is set.

  -  The name of the calling routine, provided the
     module is set.  The first line shows the currently
     executing routine.

  -  The line number where the call was made in that
     routine, provided the module is set.  The first
     line shows the line number at which execution is
     suspended.

  -  The value of the PC (program counter) in the
     calling routine at the time that control was
     transferred to the called routine.  The PC value is
     shown as a memory address relative to the address
     of the name of the routine and also as an absolute
     address.

 Note that, even if your program contains no routine
 calls, an active call is displayed.  The reason for
 this is that your program has a stack frame built for
 it when it is first activated.  Thus, if no active
 calls are displayed, either your program has terminated
 or the stack has been corrupted.

=title Show calls by call frame
=include debug Callstk_Dialog_Box calls_by_name
=include debug Scopes_Status_L_Button
This option displays detailed information from the
 current call stack, for the call frames specified with
 the Depth scale.

 The information displayed for each call frame includes
 the condition handler, saved register values, and the
 argument list, if any.

 The latter is the list of arguments passed to the
 subroutine with that call.  In some cases the argument
 list can contain the addresses of actual arguments.  In
 such cases, choose Examine Address or Register...  from
 the Addresses or Registers submenu of the Data menu to
 display the values of these arguments.

=title Depth Scale
Click on the Depth scale to specify the number of call
 frames to display.

=Title Datatype Defaults Dialog Box
=include debug g_ok_apply_cancel_buttons
Use the Datatype Defaults dialog box to establish a
 default type for memory addresses and registers that
 are not associated with a compiler-generated type.
 Addresses or registers that are associated with a
 compiler-generated type (locations that have a symbolic
 name) are not affected.

 Proceed as follows:

 1.  Set the Default Datatype option menu to the default
     type to be established (for example, byte integer,
     ASCII, and so on).

 2.  Click on OK or Apply.

 By default, the debugger associates the type longword
 integer with locations that do not have a
 compiler-generated type.  This means that, for example,
 if you specify an address that does not have a symbolic
 name in the Examine Address or Register dialog box, the
 debugger displays the contents of 4 bytes starting at
 the address specified and formats the displayed
 information as an integer value.

 To determine whether a program location is associated
 with a compiler-generated type, choose Addresses or
 Registers from the Data menu, then choose Symbolize
 Address or Register...  from the submenu.

 The following dialog boxes have option menus that
 enable you to override the default type, but only for
 one command:

  -  Examine Variable, Deposit into Variable (choose
     Variables from the Data menu).

  -  Examine Address or Register, Deposit into Address
     or Register (choose Addresses or Registers from the
     Data menu).

Additional information available:

optionlengthuser

=title Default Datatype Option Menu
Use the Default Datatype option menu to establish a
 default type.

Additional information available:

ASCICASCIDASCII

asciwascizbyted floatdate timefloatg float
h floatinstructionlongwordoctawordpackedquadworduser
word

=title ASCIC option
=include debug Datatype_Dialog_Box option
Sets the default type to counted ASCII string with a
 1-byte count field that precedes the string and gives
 its length.  AC is also accepted as a keyword.

=title ASCID Option
=include debug Datatype_Dialog_Box option
Sets the default type to ASCII string descriptor.  The
 CLASS and DTYPE fields of the descriptor are not
 checked, but the LENGTH and POINTER fields provide the
 character length and address of the ASCII string.  The
 string is then displayed.  AD is also accepted as a
 keyword.

=title ASCII Option
=include debug Datatype_Dialog_Box length
=include debug Datatype_Dialog_Box option
Sets the default type to ASCII character string.  You
 specify the length of the string (the number of bytes
 or characters) in the Length field, in decimal radix.
 If you do not specify a length, the default value is 4
 bytes.

=title ASCIW Option
=include debug Datatype_Dialog_Box option
Sets the default type to counted ASCII string with a
 2-byte count field that precedes the string and gives
 its length.  This data type occurs in Pascal and PL/I.
 AW is also accepted as a keyword.

=title ASCIZ Option
=include debug Datatype_Dialog_Box option
Sets the default type to zero-terminated ASCII string.
 The ending zero byte indicates the end of the string.
 AZ is also accepted as a keyword.

=title BYTE Option
=include debug Datatype_Dialog_Box option
Sets the default type to byte integer (length 1 byte).

=title D_FLOAT Option
=include debug Datatype_Dialog_Box option
Sets the default type to D_floating (length 8 bytes).
 Values of type D_ floating can range from .29 * 1038 to
 1.7 * 108 with approximately 16 decimal digits
 precision.

=title DATE_TIME Option
=include debug Datatype_Dialog_Box option
Sets the default type to date-time.  This is a quadword
 integer (length 8 bytes) containing the internal VMS
 representation of date-time.  Values are displayed in
 the format dd-mmm-yyyy hh:mm:ss.xx.  Specify an
 absolute date and time as follows:

   [dd-mmm-yyyy[:]] [hh:mm:ss.cc]

=title FLOAT Option
=include debug Datatype_Dialog_Box option
Sets the default type to F_floating (length 4 bytes).
 Values of type F_ floating can range from .29 * 1038 to
 1.7 * 108 with approximately 7 decimal digits
 precision.

=title G_FLOAT Option
=include debug Datatype_Dialog_Box option
Sets the default type to G_floating (length 8 bytes).
 Values of type G_ floating can range from .56 * 10308
 to .9 * 1008 with approximately 15 decimal digits
 precision.

=title H_FLOAT Option
=include debug Datatype_Dialog_Box option
Sets the default type to H_floating (length 16 bytes).
 Values of type H_ floating can range from .84*10 -4932
 to .59*10 4932 with approximately 33 decimal digits
 precision.

=title INSTRUCTION Option
=include debug Datatype_Dialog_Box option
Sets the default type to VAX instruction
 (variable-length, depending on the number of
 instruction operands and the kind of addressing modes
 used).

=title LONGWORD Option
=include debug Datatype_Dialog_Box option
Sets the default type to longword integer (length 4
 bytes).  This is the default type for program locations
 that do not have a symbolic name (do not have a
 compiler-generated type).

=title OCTAWORD Option
=include debug Datatype_Dialog_Box option
Sets the default type to octaword integer (length 16
 bytes).

=title PACKED option
=include debug Datatype_Dialog_Box length
=include debug Datatype_Dialog_Box option
Sets the default type to packed decimal.  You specify
 the number of decimal digits in the Length field.  Each
 digit occupies one nibble (4 bits).

=title QUADWORD Option
=include debug Datatype_Dialog_Box option
Sets the default type to quadword integer (length 8
 bytes).

=title User Defined Option
=include debug Datatype_Dialog_Box user
=include debug Datatype_Dialog_Box option
Sets the default type to the type specified in the User
 Type field (a variable or data type declared in the
 program).  This enables you to specify an
 application-declared type.

=title WORD Option
=include debug Datatype_Dialog_Box option
Sets the default type to word integer (length 2 bytes).

=title Length Field
=include debug Datatype_Dialog_Box option ascii
=include debug Datatype_Dialog_Box option packed
If you choose ASCII on the Default Datatype option menu,
 use this field to specify the number of bytes (ASCII
 characters) to be associated with this ASCII type.  The
 default value is 4.

 If you choose PACKED on the Default Datatype option
 menu, use this field to specify the number of decimal
 digits to be associated with this PACKED type.  The
 default value is 4.

=title User Type Field
=include debug Datatype_Dialog_Box option user
If you choose User Defined on the Default Datatype
 option menu, use this field to specify the type.  You
 can specify a type or variable that is declared in your
 program.

=Title Deposit Into Address or Register Dialog Box
=include debug g_ok_apply_cancel_buttons
Use this dialog box to deposit a value of a specified
 type at a memory address or into a register.  Proceed
 as follows:

 1.  Enter the address or the register symbol in the
     Address or Register field.

 2.  Set the Target Datatype option menu to the type of
     the value to be deposited (for example, byte
     integer, ASCII, and so on).

 3.  Enter the value to be deposited in the Language
     Expression field.

 4.  Click on OK or Apply.

 Note that the Deposit into Address or Register dialog
 box overrides a variable's compiler-generated type,
 using the type specified on the Target Datatype option
 menu.  To assign a value to a variable declared in your
 program, choose Variables from the Data menu, then
 choose Deposit into Variable....  from the Variables
 submenu.

Additional information available:

g deposit addregg addreg fieldg language expression fieldtargetlength
user

=title Depositing Values into Addresses and Registers
=include debug Addr_Menu_Deposit_Button
=include debug g_langexpr
=include debug Examine_Status_L_Button
=include debug Dep_Addr_Dialog_Box
 To deposit a value at a memory address or into a
 register, choose Addresses or Registers from the Data
 menu, then choose Deposit into Address or Register...
 from the submenu.  A dialog box is displayed.

 When you deposit a value at an address or register, the
 debugger takes the following action:

 1.  Evaluates the language expression specified in the
     Language Expression field of the dialog box in the
     syntax of the current language and in the current
     radix to yield a value.

 2.  Checks that the value and type of the language
     expression is consistent with the type specified on
     the Target Datatype menu.  If you try to deposit a
     value that is incompatible, the debugger issues a
     diagnostic message.  If the value is compatible,
     the debugger deposits the value at the location
     specified in the Address or Register field.  This
     updates the Current Entity field in the main
     window.

 The debugger might do type conversion during a deposit
 operation if the language rules allow it.  For example
 a real value that is specified in the Language
 Expression field might be converted to an integer value
 if an integer type was chosen on the Target Datatype
 option menu.  In general, the debugger tries to follow
 the assignment rules for the current language.

=title Address or Register Field
=include debug Examine_Status_L_Button
=include debug g_intro_to_addrexpr
To specify a memory address, enter an integer in the
 current radix.

 To specify a VAX register, enter a percent sign
 followed by the name of the register.  For example,
 enter %R2 to specify register R2, enter %PC to specify
 the PC register.

 You can also specify a byte offset from an address,
 register, or symbolic address expression.

 In addition, you can specify a debugger built-in symbol
 such as the period (.) or %NEXTLOC in this field.

=title Language Expression Field
=include debug g_langexpr
Use this field to specify the value to be deposited at
 the specified location.  You can specify any expression
 that is valid in the current language.

 For most languages, the expression can include the
 names of a simple (single-valued) variable but not the
 name of an aggregate variable (such as an array or
 record).  If the expression contains symbols with
 different compiler-generated types, the debugger uses
 the rules of the current language to evaluate the
 expression.

 If the expression is an ASCII string, you must enclose
 it in quotation marks (") or apostrophes (').  If the
 string contains quotation marks or apostrophes, use the
 other delimiter to enclose the string.  If the string
 has more characters (1-byte ASCII) than are specified
 in the Length field, the debugger truncates the extra
 characters from the right.  If the string has fewer
 characters, the debugger pads the remaining characters
 to the right of the string by inserting ASCII space
 characters.

=title Target Datatype Option Menu
Use the Target Datatype option menu to specify the type
 of the language expression to be deposited at the
 specified location (address or register).

 For example, if you choose the ASCII option, you can
 then deposit an ASCII string value at the specified
 location.

 The default type for depositing into an address or
 register is LONGWORD (longword integer), unless another
 default type was previously established by choosing
 Datatype Defaults...  from the Customize menu.  The
 current default type is shown on the Target Datatype
 option menu when you open the Deposit into Address or
 Register dialog box.

Additional information available:

ASCIDASCII

ascicasciwascizbyted floatdate timefloat
g floath floatlongwordoctawordpackedquadworduser
word

=title ASCIC Option
=include debug Dep_Addr_Dialog_Box target
Deposits a counted ASCII string into the specified
 location.  You must specify a string in the Language
 Expression field.  The deposited string is preceded by
 a 1-byte count field that gives the length of the
 string.

=title ASCID Option
=include debug Dep_Addr_Dialog_Box target
Deposits an ASCII string into the address given by a
 string descriptor that is at the specified location.
 You must specify a string in the Language Expression
 field.  The specified location must contain a string
 descriptor.  If the string lengths do not match, the
 string is either truncated on the right or padded with
 space characters on the right.

=title ASCII Option
=include debug Dep_Addr_Dialog_Box length
=include debug Dep_Addr_Dialog_Box target
Deposits an ASCII string into the specified location.
 You must specify a string in the Language Expression
 field.

 You can specify the length of the string (number of
 characters or bytes) by entering a decimal integer in
 the Length field.  If the actual length of the string
 is not as specified in the Length field, the string is
 truncated or padded with space characters on the right.

 If you do not specify a length, the actual length of
 the data item at the specified location is used.

=title ASCIW Option
=include debug Dep_Addr_Dialog_Box target
Deposits a counted ASCII string into the specified
 location.  You must specify a string in the Language
 Expression field.  The deposited string is preceded by
 a 2-byte count field that gives the length of the
 string.

=title ASCIZ Option
=include debug Dep_Addr_Dialog_Box target
Deposits a zero-terminated ASCII string into the
 specified location.  You must specify a string in the
 Language Expression field.  The deposited string is
 terminated by a zero byte that indicates the end of the
 string.

=title BYTE Option
=include debug Dep_Addr_Dialog_Box target
Deposits a 1-byte integer into the specified location.

=title D_FLOAT Option
=include debug Dep_Addr_Dialog_Box target
Converts the specified language expression to the
 D_floating type (length 8 bytes) and deposits the
 result into the specified location.  Values of type
 D_floating can range from .29*10 -38 to 1.7*10 +38 with
 approximately 16 decimal digits precision.

=title DATE_TIME Option
=include debug Dep_Addr_Dialog_Box target
Converts a string representing a date and a time (for
 example, 19-APR-1989 21:08:47.15) to the VMS internal
 format for the date and time and deposits that value
 (length 8 bytes) into the specified location.  Specify
 an absolute date and time in the following format:

   [dd-mmm-yyyy[:]] [hh:mm:ss.cc]

=title FLOAT Option
=include debug Dep_Addr_Dialog_Box target
Converts the specified language expression to the
 F_floating type (length 4 bytes) and deposits the
 result into the specified location.  Values of
 F_floating type can range from .29*10 -38 to 1.7*10 +38
 with approximately 7 decimal digits precision.

=title G_FLOAT Option
=include debug Dep_Addr_Dialog_Box target
Converts the specified language expression to the
 G_floating type (length 8 bytes) and deposits the
 result into the specified location.  Values of type
 G_floating can range from .56*10 -308 to .9*10 +308
 with approximately 15 decimal digits precision.

=title H_FLOAT Option
=include debug Dep_Addr_Dialog_Box target
Converts the specified language expression to the
 H_floating type (length 16 bytes) and deposits the
 result into the specified location.  Values of type
 H_floating can range from .84*10 -4932 to .59*10 +4932
 with approximately 33 decimal digits precision.

=title LONGWORD Option
=include debug Dep_Addr_Dialog_Box target
Deposits a longword integer (length 4 bytes) into the
 specified location.

=title OCTAWORD Option
=include debug Dep_Addr_Dialog_Box target
Deposits an octaword integer (length 16 bytes) into the
 specified location.

=title PACKED Option
=include debug Dep_Addr_Dialog_Box length
=include debug Dep_Addr_Dialog_Box target
Converts the specified language expression to a packed
 decimal representation and deposits the resulting value
 into the specified location.

 You specify the number of decimal digits by entering a
 decimal integer in the Length field.  Each digit
 occupies one nibble (4 bits).

=title QUADWORD Option
=include debug Dep_Addr_Dialog_Box target
Deposits a quadword integer (length 8 bytes) into the
 specified location.

=title User Defined Option
=include debug Dep_Addr_Dialog_Box user
=include debug Dep_Addr_Dialog_Box target
Converts the specified language expression to a
 user-defined type, then deposits the resulting value
 into the specified location.

 You specify the type by entering the name of a type or
 variable that is declared in your program in the User
 Type field.

=title WORD Option
=include debug Dep_Addr_Dialog_Box target
Deposits a word integer (length 2 bytes) into the
 specified location.

=title Length Field
=include debug Dep_Addr_Dialog_Box target ascii
=include debug Dep_Addr_Dialog_Box target packed
If you choose ASCII on the Target Datatype option menu,
 use this field to specify the number of bytes (ASCII
 characters) to be deposited.  Enter a decimal integer.

 If you choose PACKED on the Default Datatype option
 menu, use this field to specify the number of decimal
 digits to be deposited.

=title User Type Field
=include debug Dep_Addr_Dialog_Box target user
If you choose User Defined on the Target Datatype option
 menu, use this field to specify the type.  You can
 specify a type or variable that is declared in your
 program.

=Title Deposit Code Dialog Box
=include debug g_ok_apply_cancel_buttons
=include debug Ex_Code_Dialog_Box g_display_instructions
=include debug Examine_Status_L_Button
Use the Deposit Code dialog box to deposit a VAX
 assembly-language instruction at the location denoted
 by an address expression.

 Typically, the address expression is one that is
 already associated with code (one or more VAX
 instructions).  Routine names, program labels, and line
 numbers are symbolic address expressions that are
 associated with code.

 Proceed as follows:

 1.  Enter the address expression in the Address
     Expression field.

 2.  Enter the VAX instruction in the Instruction field.

 3.  Click on OK or Apply.

Additional information available:

g deposit codeg addrexp fieldg instruction field

=title Depositing VAX Assembly-Language Instructions
=include debug Code_Menu_Deposit_Button
=include debug Examine_Status_L_Button
=include debug g_selecting_code
=include debug g_specifying_code
=include debug Dep_Code_Dialog_Box
 To deposit an instruction at a memory address or into a
 register, choose Code from the data menu, then choose
 Deposit Code...  from the Code submenu.  A dialog box
 is displayed.

 When you deposit an instruction, the debugger takes the
 following action:

 1.  Checks that the entity specified in the Instruction
     field of the dialog box is a valid VAX
     assembly-language instruction.

 2.  If you try to deposit an invalid instruction, the
     debugger issues a diagnostic message.  If the
     entity specified is a valid instruction, the
     debugger deposits the instruction starting at the
     address or register denoted by the specified
     address expression.  This updates the Current
     Entity field in the main window.

 VAX instructions occupy different numbers of bytes,
 depending on their operands.  When depositing
 instructions of arbitrary lengths into successive
 memory locations, use the Current Entity arrow keys to
 establish the next unoccupied location where an
 instruction can be deposited.

 When you replace an instruction, be sure that the new
 instruction, including operands, is the same length in
 bytes as the old instruction.  If the new instruction
 is longer, you cannot deposit it without overwriting,
 and thereby destroying, the next instruction.  If the
 new instruction occupies fewer bytes of memory than the
 old one, you must deposit NOP instructions
 (instructions that cause "no operation") in bytes of
 memory left unoccupied after the replacement.

 The debugger does not warn you if an instruction you
 are depositing overwrites a subsequent instruction, nor
 does it remind you to fill in vacant bytes of memory
 with NOPs.

=title Address Expression Field
=include debug g_selecting_code
=include debug g_specifying_code
=include debug g_intro_to_addrexpr
Use this field to enter an address expression that
 denotes the location at which the instruction is to be
 deposited.

 For example, %LINE 14+8 denotes the memory address that
 is 8 bytes beyond the start of line 14.

 You can fill this field automatically by selecting text
 in a window before opening the dialog box.

=title Instruction Field
Use this field to specify the VAX assembly-language
 instruction to be deposited.  For example, you can
 select an instruction from a window and copy it to the
 Instruction field.

=Title Deposit into Variable Dialog Box
=include debug g_ok_apply_cancel_buttons
Use the Deposit into Variable dialog box to assign a new
 value to a variable that is declared in your program.
 Proceed as follows:

 1.  Enter the variable name in the Variable field.

     Or, before opening the dialog box, select the
     variable name in a window.  The name is
     automatically inserted in the Variable field.

 2.  Enter the value to be assigned to the variable in
     the Language Expression field.

 3.  Click on OK or Apply.

Additional information available:

g deposit varg var fieldg language expression fieldtargetlengthuser

=title Depositing (Assigning Values) Into Variables
=include debug Vbls_Menu_Deposit_Button
=include debug g_langexpr
=include debug g_specifying_variables
=include debug Examine_Status_L_Button
=include debug Dep_Vbl_Dialog_Box
 To deposit (assign) a value into a variable, choose
 Variables from the Data menu, then choose Deposit into
 Variable...  from the Variables submenu.  A dialog box
 is displayed.

 When you deposit a value into a variable, the debugger
 takes the following action:

 1.  Associates the name specified in the Variable field
     of the dialog box with a memory address or register
     and with the compiler-generated type for that
     variable (integer, real, string, array, record, and
     so on).

 2.  Evaluates the language expression specified in the
     Language Expression field in the syntax of the
     current language and in the current radix to yield
     a value.

 3.  Checks that the value and type of the language
     expression is consistent with the type of the
     variable.  If you try to deposit a value that is
     incompatible with the type of the variable, the
     debugger issues a diagnostic message.  If the value
     is compatible, the debugger deposits the value into
     the location denoted by the variable name.  This
     updates the Current Entity field in the main
     window.

 The debugger might do type conversion during a deposit
 operation if the language rules allow it.  For example,
 a real value that is specified in the Language
 Expression field might be converted to an integer value
 if it is being assigned to a variable with an integer
 type.  In general, the debugger tries to follow the
 assignment rules for the current language.

 You cannot deposit a value into an entire aggregate
 variable (a composite data structure such as an array
 or record).  To specify an individual array element or
 a record component, use the syntax of the source
 language.  For example, ARR[4] could denote element 4
 of array ARR in some languages.

 You can override the compiler-generated type of a
 variable and deposit a value of another type at the
 location denoted by a variable name.  To do so, choose
 the type on the Target Datatype option menu.

=title Variable Field
=include debug g_selecting_variables
=include debug g_specifying_variables
Specify any of the following in this field, observing
 the syntax of the source language:

  -  For an integer, real, Boolean, or any other
     noncomposite type, specify the variable name.

  -  For an array, record, or any other composite type,
     specify only an individual element.  Do not specify
     the entire aggregate.

 For example, ARR[4] could denote element 4 of array ARR
 in some languages.

 You can fill this field automatically by selecting text
 in a window before opening the dialog box.

=title Language Expression Field
=include debug g_langexpr
Use this field to specify the new value to be assigned
 to the variable.  You can specify any expression that
 is valid in the current language.

 For most languages, the expression can include the name
 of a simple (single-valued) variable but not the name
 of an aggregate variable (such as an array or record).
 If the expression contains symbols with different
 compiler-generated types, the debugger uses the rules
 of the current language to evaluate the expression.

 If the expression is an ASCII string, you must enclose
 it in quotation marks (") or apostrophes (').  If the
 string contains quotation marks or apostrophes, use the
 other delimiter to enclose the string.  If the string
 has more characters (1-byte ASCII) than are specified
 in the Length field, the debugger truncates the extra
 characters from the right.  If the string has fewer
 characters, the debugger pads the remaining characters
 to the right of the string by inserting ASCII space
 characters.

=title Target Datatype Option Menu
Use the Target Datatype option menu to override the
 compiler-generated type associated with a variable.
 This enables you to deposit data of another type into
 the program location (address or register) that is
 denoted by the variable name.

 For example, if you choose the ASCII option, you can
 then deposit an ASCII string value at the specified
 location.

 The Compiler Generated option causes the debugger to
 associate the location denoted by a variable name with
 the compiler-generated type for that variable.

 If the Target Datatype option menu is not set to
 Compiler Generated when you open the Deposit into
 Variable dialog box, then a default override type (of
 the type indicated on the menu) is in effect.  A
 default override type is established when you enter a
 SET TYPE/OVERRIDE command in the COMMAND box.

 See the Compiler Generated Option additional topic for
 complete information about that option.  The topic
 describes the effect of previously establishing a
 default type through the Datatype Defaults dialog box
 (Customize menu) or the SET TYPE/OVERRIDE command.

Additional information available:

ASCIDASCII

ascicasciwascizbytedefaultd floatdate time
floatg floath floatlongwordoctawordpackedquadword
userword

=title ASCIC Option
=include debug Dep_Vbl_Dialog_Box target
Deposits a counted ASCII string into the specified
 location.  You must specify a string in the Language
 Expression field.  The deposited string is preceded by
 a 1-byte count field that gives the length of the
 string.

=title ASCID Option
=include debug Dep_Vbl_Dialog_Box target
Deposits an ASCII string into the address given by a
 string descriptor that is at the specified location.
 You must specify a string in the Language Expression
 field.  The specified location must contain a string
 descriptor.  If the string lengths do not match, the
 string is either truncated on the right or padded with
 space characters on the right.

=title ASCII Option
=include debug Dep_Vbl_Dialog_Box length
=include debug Dep_Vbl_Dialog_Box target
Deposits an ASCII string into the specified location.
 You must specify a string in the Language Expression
 field.

 You can specify the length of the string (number of
 characters or bytes) by entering a decimal integer in
 the Length field.  If the actual length of the string
 is not as specified in the Length field, the string is
 truncated or padded with space characters on the right.

 If you do not specify a length, the actual length of
 the data item at the specified location is used.

=title ASCIW Option
=include debug Dep_Vbl_Dialog_Box target
Deposits a counted ASCII string into the specified
 location.  You must specify a string in the Language
 Expression field.  The deposited string is preceded by
 a 2-byte count field that gives the length of the
 string.

=title ASCIZ Option
=include debug Dep_Vbl_Dialog_Box target
Deposits a zero-terminated ASCII string into the
 specified location.  You must specify a string in the
 Language Expression field.  The deposited string is
 terminated by a zero byte that indicates the end of the
 string.

=title BYTE Option
=include debug Dep_Vbl_Dialog_Box target
Deposits a 1-byte integer into the specified location.

=title Compiler Generated Option
=include debug Dep_Vbl_Dialog_Box target
This option is the default.  It directs the debugger to
 associate the location (address or register) denoted by
 a variable name with the compiler-generated type for
 that variable.

 If the Target Datatype option menu is not set to
 Compiler Generated when you open the Deposit into
 Variable dialog box, then a default override type (of
 the type indicated on the menu) is in effect.  A
 default override type is established when you enter a
 SET TYPE/OVERRIDE command in the COMMAND box.

 In such cases, the Compiler Generated option is dimmed,
 and you cannot restore the compiler-generated type
 using this option.  To restore the compiler-generated
 type, enter the command CANCEL TYPE/OVERRIDE in the
 COMMAND box.

=title D_FLOAT Option
=include debug Dep_Vbl_Dialog_Box target
Converts the specified language expression to the
 D_floating type (length 8 bytes) and deposits the
 result into the specified location.  Values of type
 D_floating can range from .29*10 -38 to 1.7*10 +38 with
 approximately 16 decimal digits precision.

=title DATE_TIME Option
=include debug Dep_Vbl_Dialog_Box target
Converts a string representing a date and a time (for
 example, 19-APR-1989 21:08:47.15) to the VMS internal
 format for the date and time and deposits that value
 (length 8 bytes) into the specified location.  Specify
 an absolute date and time in the following format:

   [dd-mmm-yyyy[:]] [hh:mm:ss.cc].

=title FLOAT Option
=include debug Dep_Vbl_Dialog_Box target
Converts the specified language expression to the
 F_floating type (length 4 bytes) and deposits the
 result into the specified location.  Values of
 F_floating type can range from .29*10 -38 to 1.7*10 +38
 with approximately 7 decimal digits precision.

=title G_FLOAT Option
=include debug Dep_Vbl_Dialog_Box target
Converts the specified language expression to the
 G_floating type (length 8 bytes) and deposits the
 result into the specified location.  Values of type
 G_floating can range from .56*10 -308 to .9*10 +308
 with approximately 15 decimal digits precision.

=title H_FLOAT Option
=include debug Dep_Vbl_Dialog_Box target
Converts the specified language expression to the
 H_floating type (length 16 bytes) and deposits the
 result into the specified location.  Values of type
 H_floating can range from .84*10 -4932 to .59*10 +4932
 with approximately 33 decimal digits precision.

=title LONGWORD Option
=include debug Dep_Vbl_Dialog_Box target
Deposits a longword integer (length 4 bytes) into the
 specified location.

=title OCTAWORD Option
=include debug Dep_Vbl_Dialog_Box target
Deposits an octaword integer (length 16 bytes) into the
 specified location.

=title PACKED Option
=include debug Dep_Vbl_Dialog_Box length
=include debug Dep_Vbl_Dialog_Box target
Converts the specified language expression to a packed
 decimal representation and deposits the resulting value
 into the specified location.

 You specify the number of decimal digits by entering a
 decimal integer in the Length field.  Each digit
 occupies one nibble (4 bits).

=title QUADWORD Option
=include debug Dep_Vbl_Dialog_Box target
Deposits a quadword integer (length 8 bytes) into the
 specified location.

=title User Defined Option
=include debug Dep_Vbl_Dialog_Box user
=include debug Dep_Vbl_Dialog_Box target
Converts the specified language expression to a
 user-defined type, then deposits the resulting value
 into the specified location.

 You specify the type by entering the name of a type or
 variable that is declared in your program in the User
 Type field.

=title WORD Option
=include debug Dep_Vbl_Dialog_Box target
Deposits a word integer (length 2 bytes) into the
 specified location.

=title Length Field
=include debug Dep_Vbl_Dialog_Box target ascii
=include debug Dep_Vbl_Dialog_Box target packed
If you choose ASCII on the Target Datatype option menu,
 use this field to specify the number of bytes (ASCII
 characters) to be deposited.  Enter a decimal integer.

 If you choose PACKED on the Default Datatype option
 menu, use this field to specify the number of decimal
 digits to be deposited.

=title User Type Field
=include debug Dep_Vbl_Dialog_Box target user
If you choose User Defined on the Target Datatype option
 menu, use this field to specify the type.  You can
 specify a type or variable that is declared in your
 program.

=Title Examine Address or Register Dialog Box
=include debug g_ok_apply_cancel_buttons
Use this dialog box to display the current value stored
 at a memory address or in a register.  You can display
 the contents of any memory address or register that is
 accessible in your program.

 Proceed as follows:

 1.  Enter a memory address or a register symbol in the
     Address or Register field.

 2.  To interpret and display the entity at that
     location according to a particular type, choose
     that type on the Target Datatype option menu.

 3.  Click on OK or Apply to display the value in the
     output window.

Additional information available:

g examine addregg addreg fieldtargetlengthuserg radix option menu
g display button

=title Examining the Contents of Addresses or Registers
=include debug Addr_Menu_Examine_Button
=include debug Ex_Addr_Dialog_Box target
=include debug Examine_Status_L_Button
=include debug examine_button
=include debug The_Popup_Menu g_examine
=include debug Ex_Addr_Dialog_Box
 To examine the contents of a memory address or
 register, choose Addresses or Registers from the Data
 menu, then choose Examine Address or Register...  from
 the submenu.  A dialog box is displayed.

 When you examine an arbitrary address or register and
 the Target Datatype option menu is set to the Compiler
 Generated option, the debugger formats and displays the
 value at the specified location as follows:

  -  If the location has a symbolic name, the debugger
     formats and displays the value according to the
     compiler-generated type associated with that
     symbol---that is, as a variable of a particular
     type (if the symbol defines a data location) or as
     a VAX assembly-language instruction (if the symbol
     defines a code location).

  -  If the location does not have a symbolic name (and,
     therefore, no associated compiler-generated type),
     the debugger formats and displays the value in the
     type longword (4-byte) integer.  See Target
     Datatype Option Menu for details.

 You can interpret and display the value at the
 specified location in another type.  To do so, choose
 that type on the Target Datatype option menu.

 Use the Radix option menu to display data in a radix
 other than the default radix.

 The Current Entity field in the main window is updated
 whenever you examine an address, register, or symbolic
 address expression.

=title Address or Register Field
=include debug Ex_Addr_Dialog_Box g_radix_option_menu
=include debug Examine_Status_L_Button
=include debug g_intro_to_addrexpr
To specify a memory address enter an integer in the
 current radix.

 To specify a VAX register, enter a percent sign
 followed by the name of the register.  For example,
 enter %R2 to specify register R2, enter %PC to specify
 the PC register.

 You can also specify a byte offset from an address,
 register, or symbolic address expression.

 You can specify a list of addresses, registers, and
 byte offsets.  In such cases, separate the individual
 entities to be examined with commas.

 You can specify a range of addresses, using the
 following format:

    nnn:mmm

 The value of nnn must be less than mmm.

 If you specify a range of addresses, the debugger
 displays the entity specified by the first address, the
 logical successor, the next logical successor, and so
 on, until it displays the entity specified by the last
 address.

=title Target Datatype Option Menu
Use the Target Datatype option menu to override the
 default type associated with a specified location.

 If you choose an option other than Compiler Generated
 from the option menu, the debugger interprets and
 displays the value at the specified location according
 to that type.  For example, if you choose the ASCII
 option, the debugger interprets and displays the value
 as an ASCII string.

 If the Target Datatype option menu is not set to
 Compiler Generated when you open the Examine Addresses
 and Registers dialog box, then a default override type
 (of the type indicated on the menu) is in effect.  A
 default override type is established when you enter a
 SET TYPE/OVERRIDE command in the COMMAND box.

 See the Compiler Generated Option topic for complete
 information about that option.  The topic describes the
 effect of previously establishing a default type
 through the Datatype Defaults dialog box (Customize
 menu) or the SET TYPE/OVERRIDE command.

Additional information available:

ASCICASCIDASCII

asciwascizbytedefaultconditiond floatdate time
floatg floath floatlongwordoctawordpackedpsl
pswquadworduserword

=title ASCIC Option
=include debug Ex_Addr_Dialog_Box target
Interprets each examined entity as a counted ASCII
 string preceded by a 1-byte count field that gives the
 length of the string.  The string is then displayed.

=title ASCID Option
=include debug Ex_Addr_Dialog_Box target
Interprets each examined entity as the address of a
 string descriptor pointing to an ASCII string.  The
 Class and Dtype fields of the descriptor are not
 checked, but the Length and Pointer fields provide the
 character length and address of the ASCII string.  The
 string is then displayed.

=title ASCII Option
=include debug Ex_Addr_Dialog_Box length
=include debug Ex_Addr_Dialog_Box target
Interprets and displays each examined entity as an ASCII
 string.

 You can specify the length of the string (number of
 characters or bytes) by entering a decimal integer in
 the Length field.

 If you do not specify a length, the default value is 4
 characters.

=title ASCIW Option
=include debug Ex_Addr_Dialog_Box target
Interprets each examined entity as a counted ASCII
 string preceded by a 2-byte count field that gives the
 length of the string.  The string is then displayed.

=title ASCIZ Option
=include debug Ex_Addr_Dialog_Box target
Interprets each examined entity as a zero-terminated
 ASCII string.  The ending zero byte indicates the end
 of the string.  The string is then displayed.

=title BYTE Option
=include debug Ex_Addr_Dialog_Box target
Displays each examined entity in the byte integer type
 (length 1 byte).

=title Compiler Generated Option
=include debug Ex_Addr_Dialog_Box target
Interprets and displays the value at a specified
 location according its default type.

 The default type is:

  -  For locations that have a symbolic name:  the
     compiler-generated type.

  -  For locations that do not have a symbolic name:
     the type longword integer (length 4 bytes), by
     default; or the type (if any) previously
     established with the Datatype Defaults dialog box
     (Customize menu).

 To determine whether a location has a symbolic name,
 choose Symbolize Address or Register...  from the
 Address or Register submenu of the Data menu.

 Note that the Datatype Defaults dialog box (Customize
 menu) enables you to establish a new default type only
 for locations that do not have a symbolic name.

 If you have previously entered a SET TYPE/OVERRIDE
 command in the COMMAND box, that type is displayed by
 default on the Target Datatype option menu of the
 Examine Address or Register dialog box.  In such cases:

  -  The default type is applied to all locations,
     including those that have a symbolic name.

  -  The Compiler Generated option is dimmed, so that
     you cannot restore the compiler-generated type
     using this option.  To restore the
     compiler-generated type, you must enter a CANCEL
     TYPE/OVERRIDE command in the COMMAND box.

=title Condition Value Option
=include debug Ex_Addr_Dialog_Box target
Interprets each examined entity as a condition-value
 return status and displays the message associated with
 that return status.

=title D_FLOAT Option
=include debug Ex_Addr_Dialog_Box target
Displays each examined entity in the D_floating type
 (length 8 bytes).  Values of type D_floating can range
 from .29 * 10-38 to 1.7 * 108 with approximately 16
 decimal digits precision.

=title DATE_TIME Option
=include debug Ex_Addr_Dialog_Box target
Interprets each examined entity as a quadword integer
 (length 8 bytes) containing the internal VMS
 representation of date and time.  The value is
 displayed in the following format:

   dd-mmm-yyyy hh:mm:ss.xx.

=title FLOAT Option
=include debug Ex_Addr_Dialog_Box target
Displays each examined entity in the F_floating type
 (length 4 bytes).  Values of type F_floating can range
 from .29*10 -38 to 1.7*10 +38 with approximately 7
 decimal digits precision.

=title G_FLOAT Option
=include debug Ex_Addr_Dialog_Box target
Displays each examined entity in the G_floating type
 (length 8 bytes).  Values of type G_floating can range
 from .56*10 -308 to .9*10 +308 with approximately 15
 decimal digits precision.

=title H_FLOAT Option
=include debug Ex_Addr_Dialog_Box target
Displays each examined entity in the H_floating type
 (length 16 bytes).  Values of type H_floating can range
 from .84*10 -4932 to .59*10 +4932 with approximately 33
 decimal digits precision.

=title LONGWORD Option
=include debug Ex_Addr_Dialog_Box target
Displays each examined entity in the longword integer
 type (length 4 bytes).  This is the default type for
 program locations that do not have a compiler-generated
 type.

=title OCTAWORD Option
=include debug Ex_Addr_Dialog_Box target
Displays each examined entity in the octaword integer
 type (length 16 bytes).

=title PACKED Option
=include debug Ex_Addr_Dialog_Box length
=include debug Ex_Addr_Dialog_Box target
Interprets each examined entity as a packed decimal
 number.  Each digit occupies one nibble (4 bits).

 You can specify the number of digits by entering a
 decimal integer in the Length field.

 If you do not specify a length, the default value is 4
 digits.

=title PSL Option
=include debug Ex_Addr_Dialog_Box target
Displays each examined entity in PSL (processor status
 longword) format.

=title PSW Option
=include debug Ex_Addr_Dialog_Box target
Displays each examined entity in PSW (processor status
 word) format.  The PSW option is like the PSL option
 except that only the low order word (2 bytes) is
 displayed.

=title QUADWORD Option
=include debug Ex_Addr_Dialog_Box target
Displays each examined entity in the quadword integer
 type (length 8 bytes).

=title User Defined Option
=include debug Ex_Addr_Dialog_Box user
=include debug Ex_Addr_Dialog_Box target
Interprets and displays each examined entity according
 to a user defined type.

 You specify the type by entering the name of a type or
 variable that is declared in your program in the User
 Type field.

=title WORD Option
=include debug Ex_Addr_Dialog_Box target
Displays each examined entity in the word integer type
 (length 2 bytes).

=title Length Field
=include debug Ex_Addr_Dialog_Box target ascii
=include debug Ex_Addr_Dialog_Box target packed
If you choose ASCII on the Target Datatype option menu,
 use this field to specify the number of bytes (ASCII
 characters) to be examined.  Enter a decimal integer.
 The default value is 4.

 If you choose PACKED on the Default Datatype option
 menu, use this field to specify the number of decimal
 digits to be examined.  The default value is 4.

=title User Type Field
=include debug Ex_Addr_Dialog_Box target user
If you choose User Defined on the Target Datatype option
 menu, use this field to specify the type.  You can
 specify a type or variable that is declared in your
 program.

=title Radix Option Menu
=include debug g_radix
The debugger can interpret and display integer data in
 any one of four radixes:  binary, decimal, hexadecimal,
 and octal.  The input radix affects data entry.  The
 output radix affects data display.

 Use the Radix option menu to override the current
 output radix and display data in another radix.

 The current output radix is either the language default
 or the output radix that was last established by
 choosing Radix...  from the Customize menu, as
 applicable.  The language default is decimal for all
 languages except BLISS and MACRO.  It is hexadecimal
 for BLISS and MACRO.

 If you have previously established an output radix by
 choosing Radix...  from the Customize menu, the Radix
 option menu on the Examine Address or Variable dialog
 box is set to that radix, by default.

 The concept of radix applies strictly to integer data.
 However, note that you can also use the Radix option
 menu to display noninteger data as integer data in a
 particular radix.  This enables you to determine the
 contents of memory as integer data in that radix.

=title Display Button and AUTO Window
=include debug Wind_Dialog_Box g_predwnds g_auto
=include debug AUTO_Disp_Cmds_Menu_Entry
=include debug Cust_Menu_Windows_Button
By default, debugger output is displayed in the output
 window OUT.  When using the following dialog boxes, you
 can instead display debugger output in a predefined
 window named AUTO:

   Examine Variable
   Examine Address or Register
   Language Expressions

 To display output in window AUTO, click on the Display
 button of the dialog box instead of clicking on OK or
 Apply.  Clicking on Display does not close the window.

 See Predefined Automatic Window (AUTO) for more
 information.

=Title Examine Code Dialog Box
=include debug g_ok_apply_cancel_buttons
=include debug inst_Disp_Cmds_Menu_View_Src
Use the Examine Code dialog box to display the line of
 source code or the decoded VAX assembly-language
 instructions for a specified address expression.

 The address expression must be associated with code
 (one or more VAX instructions).  Routine names, program
 labels, and line numbers are symbolic address
 expressions that are associated with code.

Additional information available:

g display sourceg display instructionsg addr expression fieldg source code button
g inst buttonoperand values button

=title Displaying Source Code for a Code Location
=include debug Code_Menu_Examine_Button
=include debug g_source_notavailable
=include debug Examine_Status_L_Button
=include debug g_display_source
=include debug Ex_Code_Dialog_Box
 To display the line of source code for a code location
 (an address expression associated with VAX
 instructions), proceed as follows:

 1.  Choose Code from the Data menu in the main window,
     then choose Examine Code...  from the Code submenu.
     A dialog box is displayed.

 2.  Enter a code address expression in the Address
     Expression field of the dialog box.  Routine names,
     program labels, and line numbers are symbolic
     address expressions that are associated with code.

 3.  Click on the Source Code button

 4.  Click on OK or Apply.

 The output is displayed as follows:

  -  The source line for the specified address
     expression is displayed in the current source
     window (the source window with the source
     attribute).  This is the predefined window SRC, by
     default.  The source line is centered and boxed in
     the window.

     For example, if the address expression is a routine
     name, the source line that contains the routine
     declaration is displayed and boxed.

  -  If no source window has the source attribute, the
     source line is displayed in the output window.

 The Current Entity field in the main window is updated
 whenever you examine a code location or any other
 address expression.

=title Displaying VAX Instructions at a Code Location
=include debug Code_Menu_Examine_Button
=include debug g_display_predwnds
=include debug Examine_Status_L_Button g_examine_inst_buttons
=include debug Examine_Status_L_Button
=include debug g_display_instructions
=include debug inst_Disp_Cmds_Menu_View_Src
=include debug examine_button
=include debug The_Popup_Menu g_examine
=include debug Ex_Code_Dialog_Box
 To display the VAX assembly-language instructions at a
 code location (an address expression associated with
 instructions), proceed as follows:

 1.  Choose Code from the Data menu in the main window,
     then choose Examine Code...  from the Code submenu.
     A dialog box is displayed.

 2.  Enter a code address expression in the Address
     Expression field of the dialog box.  Routine names,
     program labels, and line numbers are symbolic
     address expressions that are associated with code.

     Or, to determine the instructions associated with a
     source line, you can first select that line from a
     source window and then open the dialog box.  The
     module name and line number are automatically
     inserted in the Address Expression field.

 3.  Click on the Instructions button.

 4.  To also display information about the instruction
     operands, choose the With Operand Values option
     (and the Full option for even more detailed
     information).

 5.  Click on OK or Apply.

 The output is displayed as follows:

  -  If an instruction window with the instruction
     attribute is displayed, the first instruction for
     the specified address expression is centered and
     boxed in the window.

  -  If no instruction window has the instruction
     attribute, the first instruction for the specified
     address expression is displayed in the current
     output window (window OUT, by default).

  -  If the With Operand Values button is on, operand
     information is displayed in the current output
     window.

 Note:  By default, the predefined instruction window
 INST is not displayed and does not have the instruction
 attribute.  See Displaying the Predefined Windows INST,
 REG, and AUTO.

 The Current Entity field in the main window is updated
 whenever you examine a code location or any other
 address expression.

=title Address Expression Field
=include debug g_selecting_code
=include debug g_specifying_code
=include debug g_intro_to_addrexpr
Enter a code address expression in this field (that is,
 an address expression that is associated with one or
 more VAX assembly-language instructions).

 You can fill this field automatically by selecting text
 in a window before opening the dialog box.

=title Source Code Button
=include debug Ex_Code_Dialog_Box g_display_source
Click on this button to display the line of source code
 (rather than the decoded VAX instruction) that is
 associated with the specified address expression.

=title Instructions Button
=include debug Ex_Code_Dialog_Box g_display_instructions
=include debug Ex_Code_Dialog_Box operand_values_button
Click on this button to display the decoded VAX
 instructions (rather than the source code) that is
 associated with the specified address expression.

=title With Operand Values Button, Full Button
=include debug Ex_Code_Dialog_Box g_inst_button
=include debug Ex_Code_Dialog_Box g_display_instructions
When displaying decoded VAX instructions with the
 Examine Code dialog box, use these buttons to vary the
 amount of instruction operand information displayed.
 The buttons are dimmed unless the Instructions button
 is on.

 Use of these buttons is described in the topic
 Displaying Decoded Instruction Operand Information.

=Title Examine Variable Dialog Box
=include debug Ex_Addr_Dialog_Box g_display_button
=include debug g_ok_apply_cancel_buttons
Use the Examine Variable dialog box to display the
 current value of one or more variables that are
 declared in your program.  Proceed as follows:

 1.  Enter the variable name in the Variable field.

     Or, before opening the dialog box, select the
     variable name in a window.  The name is
     automatically inserted in the Variable field.

 2.  To display the value using the variable's
     compiler-generated type (for example, as an
     integer, real, string, array, record, and so on),
     choose Compiler Generated from the Target Datatype
     option menu.  This is the default.

     To display the value in another type, choose that
     type from the option menu.

 3.  Click on OK or Apply to display the value of the
     variable in the output window.

Additional information available:

g examine varg var fieldtargetlengthuserg radix option menu

=title Examining (Displaying the Values of) Variables
=include debug Vbls_Menu_Examine_Button
=include debug g_specifying_variables
=include debug Ex_Vbl_Dialog_Box target
=include debug Examine_Status_L_Button
=include debug examine_button
=include debug The_Popup_Menu g_examine
=include debug Ex_Vbl_Dialog_Box
 To examine (display the value of) a variable, choose
 Variables from the Data menu, then choose Examine
 Variable...  from the Variables submenu.  A dialog box
 is displayed.

 Note:  You can also examine a variable that is selected
 in a window by clicking on the Examine button in the
 main window or by choosing Examine from the pop-up
 menu.  Many of the concepts discussed in the next
 paragraphs also apply to these uses of the Examine
 command.

 When you examine a variable, the debugger associates
 the name specified with a memory address or register
 and with the compiler-generated type for that variable
 (integer, real, string, array, record, and so on).  By
 default, it then interprets and displays the value at
 that location according to the variable's type.

 If you specify the name of an aggregate variable (a
 composite data structure such as an array or a record
 structure), the debugger displays the values of all
 elements.  For an array, the display shows the
 subscript (index) and value of each array element.  For
 a record, the display shows the name and value of each
 record component.

 To specify an individual array element, array slice, or
 record component, use the syntax of the source
 language.  For example, ARR[4] could denote element 4
 of array ARR in some languages.

 You can interpret and display the value at the location
 denoted by a variable name in another type.  To do so,
 choose that type on the Target Datatype option menu of
 the Examine Variable dialog box.

 Use the Radix option menu to display data in a radix
 other than the default radix.

 The Current Entity field in the main window is updated
 whenever you examine a variable or any other address
 expression.

=title Variable Field
=include debug g_selecting_variables
=include debug g_specifying_variables
Specify any of the following in this field, observing
 the syntax of the source language:

  -  The name of a variable (integer, real, Boolean,
     string, array, record, pointer, and so on).

  -  An individual element of a composite variable, such
     as an array or record.

  -  A range of elements of a composite variable.

  -  The entity designated (pointed to) by a pointer
     variable.

  -  A list of any of the above, separated by commas

 You can fill this field automatically by selecting text
 in a window before opening the dialog box.

=title Target Datatype Option Menu
Use the Target Datatype option menu to override the
 compiler-generated type associated with a variable.

 The Compiler Generated option interprets and displays
 the value of a variable according to its
 compiler-generated type.

 If you choose an option other than Compiler Generated
 from the option menu, the debugger interprets and
 displays the value at the memory address or register
 associated with the variable according to that type.
 For example, if you choose the ASCII option, the
 debugger interprets and displays the value as an ASCII
 string.

 If the Target Datatype option menu is not set to
 Compiler Generated when you open the Examine Variable
 dialog box, then a default override type (of the type
 indicated on the menu) is in effect.  A default
 override type is established when you enter a SET
 TYPE/OVERRIDE command in the COMMAND box.

 See Compiler Generated Option for complete information
 about that option.  The topic describes the effect of
 previously establishing a default type through the
 Datatype Defaults dialog box (Customize menu) or the
 SET TYPE/OVERRIDE command.

Additional information available:

ASCIDASCII

ascicasciwascizbytedefaultconditiond float
date timefloatg floath floatlongwordoctawordpacked
pslpswquadworduserword

=title ASCIC Option
=include debug Ex_Vbl_Dialog_Box target
Interprets each examined entity as a counted ASCII
 string preceded by a 1-byte count field that gives the
 length of the string.  The string is then displayed.

=title ASCID Option
=include debug Ex_Vbl_Dialog_Box target
Interprets each examined entity as the address of a
 string descriptor pointing to an ASCII string.  The
 CLASS and DTYPE fields of the descriptor are not
 checked, but the LENGTH and POINTER fields provide the
 character length and address of the ASCII string.  The
 string is then displayed.

=title ASCII Option
=include debug Ex_Vbl_Dialog_Box length
=include debug Ex_Vbl_Dialog_Box target
Interprets and displays each examined entity as an ASCII
 string.

 You can specify the length of the string (number of
 characters or bytes) by entering a decimal integer in
 the Length field.

 If you do not specify a length, the default value is 4
 characters.

=title ASCIW Option
=include debug Ex_Vbl_Dialog_Box target
Interprets each examined entity as a counted ASCII
 string preceded by a 2-byte count field that gives the
 length of the string.  The string is then displayed.

=title ASCIZ Option
=include debug Ex_Vbl_Dialog_Box target
Interprets each examined entity as a zero-terminated
 ASCII string.  The ending zero byte indicates the end
 of the string.  The string is then displayed.

=title BYTE Option
=include debug Ex_Vbl_Dialog_Box target
Displays each examined entity in the byte integer type
 (length 1 byte).

=title Compiler Generated Option
=include debug Ex_Vbl_Dialog_Box target
Interprets and displays the value of the variable
 according to its compiler-generated type.

 If the Target Datatype option menu is not set to
 Compiler Generated when you open the Examine Variable
 dialog box, then a default override type (of the type
 indicated on the menu) is in effect.  A default
 override type is established when you enter a SET
 TYPE/OVERRIDE command in the COMMAND box.

 In such cases, the Compiler Generated option is dimmed,
 and you cannot restore the compiler-generated type
 using this option.  To restore the compiler-generated
 type, enter the command CANCEL TYPE/OVERRIDE in the
 COMMAND box.

=title Condition Value Option
=include debug Ex_Vbl_Dialog_Box target
Interprets each examined entity as a condition-value
 return status and displays the message associated with
 that return status.

=title D_FLOAT Option
=include debug Ex_Vbl_Dialog_Box target
Displays each examined entity in the D_floating type
 (length 8 bytes).  Values of type D_floating can range
 from .29 * 10-38 to 1.7 * 108 with approximately 16
 decimal digits precision.

=title DATE_TIME Option
=include debug Ex_Vbl_Dialog_Box target
Interprets each examined entity as a quadword integer
 (length 8 bytes) containing the internal VMS
 representation of date and time.  The value is
 displayed in the following format:

   dd-mmm-yyyy hh:mm:ss.xx.

=title FLOAT Option
=include debug Ex_Vbl_Dialog_Box target
Displays each examined entity in the F_floating type
 (length 4 bytes).  Values of type F_floating can range
 from .29*10 -38 to 1.7*10 +38 with approximately 7
 decimal digits precision.

=title G_FLOAT Option
=include debug Ex_Vbl_Dialog_Box target
Displays each examined entity in the G_floating type
 (length 8 bytes).  Values of type G_floating can range
 from .56*10 -308 to .9*10 +308 with approximately 15
 decimal digits precision.

=title H_FLOAT Option
=include debug Ex_Vbl_Dialog_Box target
Displays each examined entity in the H_floating type
 (length 16 bytes).  Values of type H_floating can range
 from .84*10 -4932 to .59*10 +4932 with approximately 33
 decimal digits precision.

=title LONGWORD Option
=include debug Ex_Vbl_Dialog_Box target
Displays each examined entity in the longword integer
 type (length 4 bytes).  This is the default type for
 program locations that do not have a compiler-generated
 type.

=title OCTAWORD Option
=include debug Ex_Vbl_Dialog_Box target
Displays each examined entity in the octaword integer
 type (length 16 bytes).

=title PACKED Option
=include debug Ex_Vbl_Dialog_Box length
=include debug Ex_Vbl_Dialog_Box target
Interprets each examined entity as a packed decimal
 number.  Each digit occupies one nibble (4 bits).

 You can specify the number of digits by entering a
 decimal integer in the Length field.

 If you do not specify a length, the default value is 4
 digits.

=title PSL Option
=include debug Ex_Vbl_Dialog_Box target
Displays each examined entity in PSL (processor status
 longword) format.

=title PSW Option
=include debug Ex_Vbl_Dialog_Box target
Displays each examined entity in PSW (processor status
 word) format.  The PSW option is like the PSL option
 except that only the low order word (2 bytes) is
 displayed.

=title QUADWORD Option
=include debug Ex_Vbl_Dialog_Box target
Displays each examined entity in the quadword integer
 type (length 8 bytes).

=title User Defined Option
=include debug Ex_Vbl_Dialog_Box user
=include debug Ex_Vbl_Dialog_Box target
Interprets and displays each examined entity according
 to a user defined type.

 You specify the type by entering the name of a type or
 variable that is declared in your program in the User
 Type field.

=title WORD Option
=include debug Ex_Vbl_Dialog_Box target
Displays each examined entity in the word integer type
 (length 2 bytes).

=title Length Field
=include debug Ex_Vbl_Dialog_Box target ascii
=include debug Ex_Vbl_Dialog_Box target packed
If you choose ASCII on the Target Datatype option menu,
 use this field to specify the number of bytes (ASCII
 characters) to be examined.  Enter a decimal integer.
 The default value is 4.

 If you choose PACKED on the Default Datatype option
 menu, use this field to specify the number of decimal
 digits to be examined.  The default value is 4.

=title User Type Field
=include debug Ex_Vbl_Dialog_Box target user
If you choose User Defined on the Target Datatype option
 menu, use this field to specify the type.  You can
 specify a type or variable that is declared in your
 program.

=title Radix Option Menu
=include debug g_radix
The debugger can interpret and display integer data in
 any one of four radixes:  binary, decimal, hexadecimal,
 and octal.  The input radix affects data entry.  The
 output radix affects data display.

 Use the Radix option menu to override the current
 output radix and display data in another radix.

 The current output radix is either the language default
 or the output radix that was last established by
 choosing Radix...  from the Customize menu, as
 applicable.  The language default is decimal for all
 languages except BLISS and MACRO.  It is hexadecimal
 for BLISS and MACRO.

 If you have previously established an output radix by
 choosing Radix...  from the Customize menu, the Radix
 option menu on the Examine Variable dialog box is set
 to that radix, by default.

 The concept of radix applies strictly to integer data.
 However, note that you can also use the Radix option
 menu to display noninteger data as integer data in a
 particular radix.  This enables you to determine the
 contents of memory as integer data in that radix.

=Title Language Expressions Dialog Box
=include debug Ex_Addr_Dialog_Box g_display_button
=include debug g_ok_apply_cancel_buttons
=include debug g_langexpr
=include debug The_Popup_Menu g_evaluate
Use the Language Expressions dialog box to evaluate a
 language expression.  Proceed as follows:

 1.  Specify an expression that is valid in the
     currently set language in the Language Expression
     field.

 2.  If desired, choose another radix from the Radix
     option menu.  By default integer data is displayed
     in decimal format for all languages except BLISS
     and MACRO (it is displayed in hexadecimal format
     for BLISS and MACRO).

 3.  Click on OK or Apply to display the value in the
     output window.

Additional information available:

g language expression fieldg radix option menu

=title Language Expression Field
=include debug g_langexpr
You can specify any language expression that is valid in
 the current language.

 For most languages, the expression can include the name
 of a simple (single-valued) variable but not the name
 of an aggregate variable (such as an array or record).
 If the expression contains symbols with different
 compiler-generated types, the debugger uses the rules
 of the current language to evaluate the expression.

 If the expression is an ASCII string, you must enclose
 it in quotation marks (") or apostrophes (').  If the
 string contains quotation marks or apostrophes, use the
 other delimiter to enclose the string.  If the string
 has more characters (1-byte ASCII) than can fit into
 the program location denoted by the address expression,
 the debugger truncates the extra characters from the
 right.  If the string has fewer characters, the
 debugger pads the remaining characters to the right of
 the string by inserting ASCII space characters.

=title Radix Option Menu
=include debug g_radix
The debugger can interpret and display integer data in
 any one of four radixes:  binary, decimal, hexadecimal,
 and octal.  The input radix affects data entry.  The
 output radix affects data display.

 Use the Radix option menu to override the current
 output radix and display data in another radix.

 The current output radix is either the language default
 or the output radix that was last established by
 choosing Radix...  from the Customize menu, as
 applicable.  The language default is decimal for all
 languages except BLISS and MACRO.  It is hexadecimal
 for BLISS and MACRO.

 If you have previously established an output radix by
 choosing Radix...  from the Customize menu, the Radix
 option menu on the Language Expressions dialog box is
 set to that radix, by default.

 The concept of radix applies strictly to integer data.
 However, note that you can also use the Radix option
 menu to display noninteger data as integer data in a
 particular radix.  This enables you to determine the
 contents of memory as integer data in that radix.

=Title Go Dialog Box
=include debug g_ok_apply_cancel_buttons
=include debug go_button
=include debug The_Popup_Menu g_go
Use the Go dialog box to start program execution from a
 specified location.  Proceed as follows:

 1.  Enter an address expression that is associated with
     code (VAX instructions) in the Address Expression
     field.  Routine names, program labels, and line
     numbers are symbolic address expressions that are
     associated with code.

 2.  Click on OK or Apply to start execution.

 Note that starting execution from a location other than
 the current location can produce unexpected results,
 because it alters the normal control flow of your
 program.  For example, during a debugging session you
 can restart execution from the beginning of the program
 by specifying the address expression %LINE 1.  However,
 because the program has executed, the values of some
 variables might now be different from when you first
 ran the program.

Additional information available:

g gog address expression field

=title Starting and Resuming Execution (Go Command)
=include debug go_button
=include debug The_Popup_Menu g_go
=include debug Ctrl_Menu_Go_Button
=include debug Go_Dialog_Box
To start or resume program execution from the current
 location, click on the Go button in the main window.

 To start execution from another location, choose Go...
 from the Control menu and specify the location in the
 Go dialog box.

 After it is started with the Go command, program
 execution continues until one of the following events
 occurs:

  -  The program completes execution

  -  A breakpoint is reached

  -  A watchpoint is activated

  -  An exception is signaled

  -  You click on the Stop button in the main window

 Note that starting execution from a location other than
 the current location can produce unexpected results,
 because it alters the normal control flow of your
 program.  For example, during a debugging session you
 can restart execution from the beginning of the
 program.  However, because the program has executed,
 the values of some variables might now be different
 from when you first ran the program.

 Go is one of the four debugger commands that you can
 use to execute your program.  The others are:

  -  Step (on the Control or pop-up menu, or the Step
     button in the main window)

  -  Call (on the Control menu)

  -  Exit (on the File menu of the debugger windows)

=title Address Expression Field
=include debug g_selecting_code
=include debug g_specifying_code
=include debug g_intro_to_addrexpr
Enter a code address expression in this field (that is,
 an address expression that is associated with one or
 more VAX assembly-language instructions).

 You can fill this field automatically by selecting text
 in a window before opening the dialog box.

=Title Images Dialog Box
=include debug g_ok_apply_cancel_buttons
=include debug g_Symb_share
=include debug g_DST_GST_RST
=include debug g_symb_mod_set
=include debug Show_Vbl_Dialog_Box g_show_var
=include debug g_Symb
Use the Images dialog box to debug a shareable image
 that is linked with your program.  You do not need to
 use this dialog box if you are debugging only the main
 (executable) image of your program.

 Use the Images dialog box to set or cancel images, or
 to identify the current image.

 To set an image, proceed as follows:

 1.  Choose 'Set selected image' from the Set/Cancel
     option menu.

 2.  Click on the name of the image in the list box.

     Or, type the image name in the Image field.

 3.  Click on OK or Apply.

 To cancel an image, proceed as follows:

 1.  Choose 'Cancel selected image' from the Set/Cancel
     option menu.

 2.  Click on the name of the image in the list box.

 3.  Click on OK or Apply.

 Setting an image means to load symbol information about
 the modules of an image into that image's run-time
 symbol table (RST).  Setting an image also establishes
 that image as the current image.  The current image is
 the context for looking up symbols that you specify
 while debugging.

 The list box of the Images dialog box identifies the
 executable image of the program and any shareable
 images that are linked with the executable image.  The
 word 'set' at the left of a name indicates that the
 image is set.  The asterisk at the left of a name
 identifies the current image.

Additional information available:

set cancelg image fieldg image list box

=title Set/Cancel Option Menu
Use the Set/Cancel option menu to specify whether you
 want to set or cancel one or more images.

=title Image Field
Use this field to specify one or more images to be set
 or canceled.

 You can specify a list of image names, separated by
 commas, but do not use the asterisk wildcard character
 (*).

 If text was selected when you opened the dialog box,
 the Image field is filled automatically.

=title Image List Box
The list box identifies the executable image of the
 program and any shareable images that are linked with
 the executable image.

 The word 'set' at the left of a name indicates that the
 image is set.

 The asterisk at the left of a name identifies the
 current image.  By default, the main (executable) image
 is the current image.

=Title View Source Dialog Box
=include debug g_ok_apply_cancel_buttons
=include debug g_display_source
=include debug g_source_notavailable
Use the View Source dialog box to display, in the
 current source window, the source code associated with
 a compiler-generated line number or with a range of
 line numbers.

 To display source code in the module whose code is
 currently displayed in the source window, proceed as
 follows:

  -  To center a single source line in the source
     window, enter the line number in the Line Number
     Expression field.  For example, to display line 47,
     enter the number 47.

  -  To display a range of source lines, enter the
     starting and ending line numbers separated by a
     colon (:).  For example, to display lines 31
     through 37, enter 31:37.

 To display source code in an arbitrary module, specify
 the module name as a path name prefix.  For example:

  -  SWAP\47 specifies line 47 in module SWAP

  -  SWAP31:37 specifies lines 31 through 37 in module
     SWAP

=Title Logging Dialog Box
=include debug g_ok_apply_cancel_buttons
=include debug g_log_file
Use the Logging dialog box for the following purposes:

 1.  To control whether a debugging session is logged
     into a file, and to specify the log file:

      -  To enable logging, choose the Logging Enabled
         option.

      -  Specify a log file in the Log File field.  The
         default specification is SYS$DISK:[]DEBUG.LOG.

         The current log file is identified in the Log
         File field when you open the dialog box.


 2.  To control whether debugger commands are echoed in
     the current output window as they are executed, in
     the following situations:

      -  When the debugger executes a command procedure

      -  When the debugger executes commands that were
         specified in the Action field of various dialog
         boxes (for example, Break, Watch)

     To echo debugger commands, choose the Include I/O
     from Command Procedures option.

=Title Modules Dialog Box
=include debug g_ok_apply_cancel_buttons
=include debug g_symb_mod_set
=include debug g_DST_GST_RST
=include debug Show_Vbl_Dialog_Box g_show_var
=include debug g_Symb
=include debug g_Symb_share
Use the Modules dialog box to set or cancel modules, or
 to identify the modules that are currently set.

 To set a module, proceed as follows:

 1.  Choose 'Set selected module' from the Set/Cancel
     option menu.

 2.  Click on name of the module in the list box.

     Or, type the module name in the Module field.

 3.  Click on OK or Apply.

 To cancel a module, proceed as follows:

 1.  Choose 'Cancel selected module' from the Set/Cancel
     option menu.

 2.  Click on the name of the module in the list box.

 3.  Click on OK or Apply.


 A module corresponds to a compilation unit for most
 languages.  Setting a module means to load the
 compiler-generated symbol records of a module into the
 run-time symbol table (RST) for that module's image.

 The list box of the Modules dialog box identifies all
 the modules in the current image.  The word 'set' at
 the left of a module name indicates that the module is
 currently set.

Additional information available:

set cancelg module fieldg module list boxg include related modules button

=title Set/Cancel Option Menu
=include debug g_symb_mod_set
=include debug g_Symb_share
=include debug Scopes_Status_L_Button
Use the Set/Cancel option menu to specify whether you
 want to set or cancel one or more modules.

 Use the option 'Set the modules on the call stack' to
 set all the modules that currently have routines on the
 call stack.  This is useful when you are using the Call
 Frame arrow buttons in the main window.

 The options 'Set all modules' and 'Cancel all modules'
 set and cancel, respectively, all of the modules in the
 current image.

 When you cancel all modules, only global symbols (as
 resolved by the linker) are available.

=title Module Field
Use this field to specify one or more modules of the
 current image to be set or canceled.

 You can specify a list of module names, separated by
 commas, but do not use the asterisk wildcard character
 (*).

 If text was selected when you opened the dialog box,
 the Module field is filled automatically.

=title Module List Box
The list box identifies all the modules in the current
 image.

 The word 'set' at the left of a name indicates that the
 module is set.

=title Include Related Modules Button
Note:  This feature applies only to Ada programs.

 Use this button to control whether the debugger
 automatically sets modules that are related to a
 specified module through a with-clause or through a
 subunit relationship.

 Button on (default for Ada programs):

    Sets related modules as well as those that you
    specify.  This makes names (symbols) declared in
    related modules visible so that you can reference
    them exactly as they can be referenced within the
    Ada source code.

 Button off:

    Sets only the modules that you specify (no related
    modules are set).

=Title Other Attributes Dialog Box
=include debug g_ok_apply_cancel_buttons
Use this dialog box to establish miscellaneous settings
 as explained in the additional topics.

 Default settings are established for the various items
 when you invoke the debugger.  If you change a setting
 through this dialog box, that change remains in effect
 for the rest of the debugging session.

 To establish a different default setting at debugger
 startup, store the corresponding command in a debugger
 initialization file.  This is a debugger command
 procedure that is assigned the logical name DBG$INIT
 and is executed every time you invoke the debugger.
 The appropriate command is listed with each item's
 description in the additional topics.

Additional information available:

dyn mod setasts enabledsymbolizedyn procint procdouble precision float
inst operandsdisp code

=title Dynamic Module and Image Setting Button
=include debug g_symb_mod_set
=include debug Other_Dialog_Box symbolize
=include debug Other_Dialog_Box disp_code
Button on (default):
 Equivalent Command:  SET MODE DYNAMIC

    Enables dynamic module and image setting.  The
    debugger sets modules and images automatically
    during program execution so that you typically do
    not have to set modules or images explicitly by
    choosing Modules...  or Images...  from the Data
    menu.

    Specifically, whenever execution is interrupted, the
    debugger automatically sets the module and image
    that contain the routine in which execution is
    currently suspended.  If the module or image is
    already set, dynamic module and image setting has no
    effect on that module or image.  The debugger issues
    an informational message when its sets a module or
    image.

 Button off:
 Equivalent command:  SET MODE NODYNAMIC

    Disables dynamic module and image setting.  Because
    additional memory is allocated when a module or
    image is set, you might want to disable dynamic
    module and image setting if performance becomes a
    problem.

    You can also free up memory by canceling modules and
    images, by choosing Modules...  or Images...  from
    the Data menu.  When dynamic module and image
    setting is disabled, you must set modules and images
    explicitly.

=title ASTs Enabled Button
=include debug Ctrl_Menu_Call_Button
Button on (default):
 Equivalent command:  ENABLE AST

    Enables the delivery of asynchronous system traps
    (ASTs) while your program is running, including any
    pending ASTs (ASTs waiting to be delivered).  If
    ASTs are delivered while the debugger is running
    (processing commands, and so on), they are queued
    and are delivered when control is returned to the
    program.

 Button off:
 Equivalent command:  DISABLE AST

    Disables the delivery of ASTs in your program and
    thereby prevents interrupts from occurring while the
    program is running.  If ASTs are delivered while the
    debugger is running (processing commands, and so
    on), they are queued and are delivered when control
    is returned to the program.

=title Symbolize Address Expressions Button
=include debug Other_Dialog_Box dyn_mod_set
=include debug Other_Dialog_Box disp_code
=include debug Addr_Menu_Symbolize_Button
=.!include gen g_DST_GST_RST
=include debug g_Symb
Button on (default):
 Equivalent command:  SET MODE SYMBOLIC

    Enables symbolic mode.  Therefore, the debugger
    displays the locations denoted by address
    expressions symbolically (if possible) and displays
    instruction operands symbolically (if possible).

 Button off:
 Equivalent command:  SET MODE NOSYMBOLIC

    Disables symbolic mode.  Therefore, the debugger
    does not attempt to symbolize numeric addresses (it
    does not cause the debugger to convert numbers to
    names).

    This is useful if you are interested in identifying
    numeric addresses rather than their symbolic names
    (if symbolic names exist for those addresses).  When
    symbolic mode is disabled, command processing might
    speed up somewhat, because the debugger does not
    need to convert numbers to names.

=title Dynamic Process Setting Button
=include debug Other_Dialog_Box int_proc
=include debug Process_Status_L_Button
=include debug g_multiproc
This feature applies only to a multiprocess debugging
 configuration.

 Button on (default):
 Equivalent command:  SET PROCESS/DYNAMIC

    Enables dynamic process setting.  Therefore,
    whenever the debugger suspends program execution,
    the process in which execution is suspended becomes
    the visible process automatically.

 Button off:
 Equivalent command:  SET PROCESS/NODYNAMIC

    Disables dynamic process setting.  Therefore, the
    visible process remains unchanged until you make
    another process the visible process explicitly (by
    using either the Visible Process arrow buttons in
    the main window or the Processes...  dialog box from
    the Data menu).

=title Interrupt Processes Button
=include debug Other_Dialog_Box dyn_proc
=include debug g_multiproc
This feature applies only to a multiprocess debugging
 configuration.

 Button on (default):
 Equivalent command:  SET MODE INTERRUPT

    Specifies that, when program execution is suspended
    in any process, the debugger interrupts execution in
    any other processes that were executing images.

 Button off:
 Equivalent command:  SET MODE NOINTERRUPT

    Specifies that, when program execution is suspended
    in any process, the debugger take the following
    action:

     -  If execution was suspended because of an
        unhandled exception, the debugger interrupts
        execution in any other processes that were
        executing images.

     -  If execution was suspended because of a
        breakpoint or watchpoint or upon the completion
        of a step, the debugger lets execution proceed
        in any other processes that were executing
        images.  As long as execution continues in any
        process, the debugger does not take control.  In
        such cases, click on the Stop button in the main
        window to interrupt all processes.

    The following example shows the effect of turning
    off the Interrupt Processes button.

    Assume you have set a breakpoint in each process
    that is currently under debugger control.  When you
    then enter a Go command, execution starts in all
    processes that are not on hold, and the debugger
    does not take control until the breakpoint is
    triggered in all processes that are not on hold.

=title Double-Precision Floating-Point Interpretation Buttons
=include debug Datatype_Dialog_Box
D_FLOAT button on (default):
 Equivalent command:  SET MODE NOG_FLOAT

    Specifies that the debugger interpret
    double-precision floating-point constants entered in
    expressions as D_FLOAT.

 G_FLOAT button on:
 Equivalent command:  SET MODE G_FLOAT

    Specifies that the debugger interpret
    double-precision floating-point constants entered in
    expressions as G_FLOAT.

 These settings do not affect the interpretation of
 variables declared in your program.

=title Instruction Operand Information Buttons
=include debug Ex_Code_Dialog_Box g_display_instructions
=include debug Examine_Status_L_Button g_examine_inst_buttons
=include debug Examine_Status_L_Button
=include debug g_display_instructions
None button on (default):
 Equivalent command:  SET MODE NOOPERANDS

    Specifies that, when you examine an instruction,
    only the instruction and its operands are displayed.

 Brief or Full button on:
 Equivalent command:  SET MODE OPERANDS=BRIEF (or =FULL)

    Specifies that, when you examine an instruction, the
    address and contents of the instruction's operands
    are displayed in addition to the instruction and its
    operands.  The level of information displayed
    depends on whether you click on Brief or Full.

=title Display Code Locations Buttons
=include debug Other_Dialog_Box dyn_mod_set
=include debug Other_Dialog_Box symbolize
=include debug Addr_Menu_Symbolize_Button
By Line Number button on (default):
 Equivalent command:  SET MODE LINE

    Specifies that the debugger display program
    locations in terms of line numbers, if possible (for
    example, %LINE 27).

 By Routine Offset button on:
 Equivalent command:  SET MODE NOLINE

    Specifies that the debugger display program
    locations as routine-name + byte-offset rather than
    in terms of line numbers.

=Title Radix Dialog Box
=include debug g_ok_apply_cancel_buttons
=include debug g_radix
Use the Radix dialog box to establish the radix for the
 entry or display of integer data (the input radix and
 the output radix, respectively).

 The Input Radix and Output Radix option menus of the
 Radix dialog box show the current radix settings for
 data entry and display, respectively.  The default
 radix is decimal for all languages except BLISS and
 MACRO.  It is hexadecimal for BLISS and MACRO.

 To establish another radix, proceed as follows:

 1.  Choose the input radix and output radix to be
     established from the appropriate option menu.

 2.  Click on OK or Apply.


 The following dialog boxes have option menus that
 enable you to override the output radix, but only for
 the command that you enter when you click on OK or
 Apply:

  -  Examine Variable (choose Variables from the Data
     menu, then choose Examine Variable from the
     submenu).

  -  Examine Address or Register (choose Addresses or
     Registers from the Data menu, then choose Examine
     Addresss or Register from the submenu).

  -  Language Expressions (choose Language
     Expressions...  from the Data menu).

Additional information available:

input radixg output radix

=title Input Radix Option Menu
=include debug Radix_Dialog_Box output_radix
Use this option menu to set the input radix (the radix
 for entering integer data) as follows:

  Binary       Sets the radix to binary.

  Decimal      Sets the radix to decimal. This is the
               default for all languages except BLISS and
               MACRO.

  Octal        Sets the radix to octal.

  Hexadecimal  Sets the radix to hexadecimal. This is
               the default for BLISS and MACRO.

=title Output Radix Option Menu
=include debug Radix_Dialog_Box input_radix
Use this option menu to set the output radix (the radix
 for displaying integer data) as follows:

  Binary       Sets the radix to binary.

  Decimal      Sets the radix to decimal. This is the
               default for all languages except BLISS and
               MACRO.

  Octal        Sets the radix to octal.

  Hexadecimal  Sets the default radix to hexadecimal.
               This is the default for BLISS and MACRO.

=Title Show Address Dialog Box
=include debug g_ok_apply_cancel_buttons
Use this dialog box to display the memory address or
 register for a specified address expression.

 If, prior to opening the dialog box, you selected text
 in a source or instruction window, a path name for that
 selection is automatically inserted in the following
 form in the Address Expression field (n is the line
 number of the selected text):

    module-name\%LINE n

 Clicking on the OK or Apply button displays the address
 of the first instruction for the selected line.

 Although this dialog box is displayed by choosing Code
 from the Data menu, you can enter an address expression
 that is associated with either code (VAX instructions)
 or data (for example, a variable name).  Routine names,
 program labels, and line numbers are symbolic address
 expressions that are associated with code.

Additional information available:

g address expression field

=title Address Expression Field
=include debug g_selecting_code
=include debug g_specifying_code
=include debug g_specifying_variables
=include debug g_intro_to_addrexpr
Enter a code address expression in this field (that is,
 an address expression that is associated with one or
 more VAX assembly-language instructions).

 You can fill this field automatically by selecting text
 in a window before opening the dialog box.

=Title Show Variable Dialog Box
=include debug g_ok_apply_cancel_buttons
=include debug g_Symb
=include debug g_DST_GST_RST
=include debug g_resolve_symb
Use the Show Variable dialog box to display information
 about one or more variable names (or other symbols)
 that are currently in the debugger's run-time symbol
 table (RST).

 Proceed as follows:

 1.  Enter the variable name in the Variable field.

     Or, before opening the dialog box, select the
     variable name in a window.  The name is
     automatically inserted in the Variable field.

 2.  Click on one of the buttons (Symbol, Type, and so
     on), to specify whether you want to display the
     path name prefix for that variable, or additional
     information such as the variable's type or address.

 3.  If applicable, specify a scope (for example, a
     module or routine name) in which the debugger is to
     look for the variable.

 4.  Click on OK or Apply.

Additional information available:

g show varg variable fieldg symbol buttong type button
g address computation buttong virtual memory address buttong scope field

=title Obtaining Information about Variables and Other Symbols
=include debug Vbls_Menu_Show_Button
=include debug g_DST_GST_RST
=include debug g_resolve_symb
=include debug g_Symb
=include debug g_symb_share
=include debug Show_Vbl_Dialog_Box
 To display information that the debugger has about a
 given variable or other symbol in the current image,
 choose Variables from the Data menu, then choose Show
 Variable...  from the Variables submenu.  A dialog box
 is displayed.

 Note:  The current image is either the main image, by
 default, or the image established as the current image
 through the Images dialog box (Data menu).

 The information that the debugger displays about a
 symbol might not be the same as what the compiler had
 or even what you see in your source code.  Nonetheless,
 it is useful for understanding why the debugger might
 act as it does when handling symbols.

 Symbols are displayed with their path names.  The Show
 Variable dialog box enables you to list all possible
 declarations or definitions of a specified symbol that
 exist in the RST for the current image---that is, in
 all set modules and in the GST for that image.

 Use the Scope field to indicate that the debugger
 should identify only the specified symbols that are
 declared in a particular scope rather than the entire
 run-time symbol table (RST).

=title Variable Field
=include debug g_selecting_variables
=include debug g_specifying_variables
=include debug g_Symb
Enter text into this field as follows:

  -  In addition to a variable name, you can specify any
     symbol declared in your program (routine name,
     label, and so on).

  -  You can specify one or more symbols.  Use commas to
     separate symbols.

  -  You can use the asterisk (*) wildcard character
     within a symbol name.

  -  You can specify the asterisk character by itself to
     denote all symbols.

  -  Do not specify a compound name such as might be
     used to denote an array element or a record
     component (for example, ARR[3] or
     EMPLOYEE.ADDRESS).

  -  When specifying a numeric label, use the %LABEL
     built-in symbol (for example, %LABEL 35 denotes
     label 35).

 You can fill this field automatically by selecting text
 in a window before opening the dialog box.

=title Symbol Button
Choose the Symbol button to display the specified symbol
 with its path name prefix.

=title Type Button
Choose the Type button to display the specified symbol
 (with its path name prefix) and also data type
 information about the symbol.

=title Address Computation Button
Choose the Address Computation button to display the
 specified symbol (with its path name prefix) and also
 the computation that the debugger uses to locate the
 symbol.

 The address computation might simply be a memory
 address, or it might be an offset from a register (for
 example, the offset .%FP-24 denotes a location 24 bytes
 from the address that is contained in the frame pointer
 register).

 Some symbols have address specifications too
 complicated to present in any understandable way.
 These address specifications are labeled "complex
 address specifications."

=title Virtual Memory Address Button
Choose the Virtual Memory Address button to display the
 virtual memory address or register that is associated
 with the specified symbol.

=title Scope Field
=include debug g_resolve_symb
Use this field to indicate that the debugger should
 identify only the specified symbols that are declared
 in a particular scope rather than the entire run-time
 symbol table (RST).

 You can specify any of the following:

  -  A symbol that denotes a lexical scope in your
     program, such as a module name or a routine name,
     including its path name prefix (for example,
     PROG2\SWAP).

  -  A numeric scope, consisting of a decimal integer
     from 0 to N, to denote a level on the call stack.
     0 denotes the routine in which execution is
     currently suspended; 1 denotes the caller routine,
     and so on.

  -  A search list consisting of any of the above,
     separated by commas.

 The scopes specified must be in set modules in the
 current image.

 The debugger displays only those symbols in the RST for
 the current image that both match the specified name
 and are declared within the lexical entity specified by
 the scope parameter.  If the scope parameter is
 omitted, all set modules and the global symbol table
 (GST) for the current image are searched for symbols
 that match the entry in the Variable field.

=Title Source Files Dialog Box
=include debug g_ok_apply_cancel_buttons
=include debug g_source_notavailable
=include debug g_display_source
Use the Source Files dialog box to specify where the
 debugger is to search for source files that have been
 moved to another directory after being compiled.

Additional information available:

g directory list field

=title Directory List Field
In this field, specify any part of a VMS file
 specification (typically a device and directory) that
 the debugger uses by default when searching for a
 source file.

 A full VMS file specification consists of the following
 fields:

 node::device:[directory]file-name.file-type;version-number

 For any part of a full file specification that you do
 not supply, the debugger uses the file specification
 stored in the module's symbol record---that is, the
 file specification that the source file had at compile
 time.

 You can create a source directory search list by
 specifying more than one directory.  Separate directory
 names with commas.

 The debugger handles a source directory search list by
 searching the first directory specified to locate
 source files, then the second directory specified, then
 the next, and so on, until it either locates the source
 file or exhausts the list of directories.

 You can also specify a search list logical name that is
 defined at your process level.  For example, the
 following command defines the logical name
 DEBUG_SOURCES.  If you then specify DEBUG_SOURCES in
 the Directory List field, the debugger looks for source
 files first in your current default directory, then in
 the directory DISK2:[PROJECT_SOURCES]:

 $ DEFINE DEBUG_SOURCES SYS$DISK:[],DISK2:[PROJECT_SOURCES]

 To specify a source directory search list in a debugger
 command procedure or initialization file, use the SET
 SOURCE command.

=Title Step Dialog Box
=include debug g_ok_apply_cancel_buttons
=include debug Step_Button
=include debug The_Popup_Menu
Use the Step dialog box to:

  -  Specify options for a single Step command and
     execute that command

  -  Set default options for all subsequent Step
     commands without executing a Step command

 The Step command executes the program one or more step
 units at a time.

 When opened, the Step dialog box indicates the current
 default options for the Step command.

Additional information available:

g stepset one stepset default stepstep setstep unitnotification
step units fieldinstructions fieldwithin called routines button
jsb routines buttonshareable routines buttonsystem routines button

=title Executing the Program by Step Unit (Step Command)
=include debug Step_Button
=include debug The_Popup_Menu
=include debug Ctrl_Menu_Step_Button
To execute one step unit of your program, click on the
 Step button in the main window.

 By default, a step unit is one line of source code;
 and, by default, the debugger notifies you of the
 completion of a Step command by displaying a "stepped
 to..." message and the source line where execution is
 suspended.

 To specify other options for the Step command, choose
 Step...  from the Control menu.  For example, you can
 make the default step unit signify "execute one
 instruction".

 Note the following additional points about the Step
 command:

  -  When used to execute the program in units of one or
     more source lines, the Step command executes one or
     more executable lines at a time, skipping over any
     other lines.

     Executable lines are those for which instructions
     were generated by the compiler (for example, lines
     with routine calls or assignment statements).
     Examples of nonexecutable lines are comment lines
     or lines with variable declarations without value
     assignments.

  -  When execution is suspended at a routine call,
     clicking on the Step button executes the call in
     one step, by default, suspending execution at the
     next source line in the calling routine.

     You can override this behavior to execute the
     routine in steps by choosing Step Into Routine from
     the pop-up menu, and then clicking on the Step
     button after execution is within the routine.

 Step is one of the four debugger commands that you can
 use to execute your program.  The others are:

  -  Go (on the Control or pop-up menu, or the Go button
     in the main window)

  -  Call (on the Control menu)

  -  Exit (on the File menu of the debugger windows)

=title Specifying Options for a Single Step Command
=include debug Step_Dialog_Box set_default_step
=include debug Step_Dialog_Box g_step
To specify options for a single Step command:

 1.  Choose Step...  from the Control menu.

 2.  Choose Step from the upper-left (Step/Set) option
     menu of the Step dialog box.

 3.  Choose one or more options from the dialog box.
     Start with the upper-right (Step Unit) option menu.

 4.  Click on OK or Apply to enter the Step command.
     Any new options you choose override the previously
     established step defaults, but only for that
     command.

=title Setting Defaults for All Subsequent Step Commands
=include debug Step_Dialog_Box set_one_step
=include debug Step_Dialog_Box g_step
To set default options for all subsequent Step commands:

 1.  Choose Step...  from the Control menu.

 2.  Choose 'Set default step' from the upper-left
     (Step/Set) option menu of the Step dialog box.

 3.  Choose one or more options from the dialog box.
     Start with the upper-right (Step Unit) option menu.

 4.  Click on OK or Apply.  No Step command is issued.

=title Step/Set (Upper-Left) Option Menu
=include debug Step_Dialog_Box set_one_step
=include debug Step_Dialog_Box set_default_step
=include debug Step_Dialog_Box step_unit
=include debug Step_Dialog_Box g_step
Use the Step/Set option menu as follows:

  -  Choose Step to specify that you are establishing
     one or more new options for the next Step command.
     Any new options you then choose override the
     previously established step defaults, but only for
     that command.

  -  Choose 'Set default step' to specify that you are
     establishing one or more new defaults for
     subsequent Step commands.  Any options you then
     choose override the previously established step
     defaults and remain in effect until you end the
     debugging session or establish new defaults with
     this dialog box.

=title Step Unit (Upper-Right) Option Menu
=include debug Step_Dialog_Box g_step
Use the Step Unit option menu to specify the step unit,
 which is the unit of execution for the Step command
 (for example, step to the next line, next specified VAX
 instruction, and so on).

Additional information available:

next linenext instnext RETnext CALLnext branchspec instnext excep

=title 'to the next source line' Option
=include debug Step_Dialog_Box step_unit
Executes the program to the next source line encountered
 during program execution.

 When used to execute the program in units of one or
 more source lines, the Step command executes one or
 more executable lines at a time, skipping over any
 other lines.

 Executable lines are those for which instructions were
 generated by the compiler (for example, lines with
 routine calls or assignment statements).  Examples of
 nonexecutable lines are comment lines or lines with
 variable declarations without value assignments.

=title 'to the next instruction' Option
=include debug Step_Dialog_Box step_unit
Executes the program to the next VAX assembly-language
 instruction encountered during program execution.

=title 'to the next RET instruction' Option
=include debug Step_Dialog_Box step_unit
Executes the program to the RET (return) instruction of
 the routine in which execution is currently suspended;
 that is, up to the point just prior to transferring
 control back to the calling routine.

 This enables you to inspect the local environment (for
 example, obtain the values of local variables) before
 the RET instruction deletes the routine's call frame
 from the call stack.

 If you specify an integer N in the Step Unit(s) field,
 the Step command executes the program up N levels of
 the call stack.

=title 'to the next CALL instruction' Option
=include debug Step_Dialog_Box step_unit
Executes the program to the next call or return (RET)
 instruction encountered during program execution.

=title 'to the next branch instruction' Option
=include debug Step_Dialog_Box step_unit
Executes the program to the next branch instruction
 encountered during program execution.

 These include BEQL, BGTR, BLEQ, BGEQ, BLSS, BGTRU,
 BLEQU, BVC, BVS, BGEQU, BLSSU, BRB, BRW, JMP, BBS, BBC,
 BBSS, BBCS, BBSC, BBCC, BBSSI, BBCCI, BLBS, BLBC, ACBB,
 ACBW, ACBL, ACBF, ACBD, ACBG, ACBH, AOBLEQ, AOBLSS,
 SOBGEQ, SOBGTR, CASEB, CASEW, and CASEL.

=title 'to the specified instruction(s)' Option
=include debug Step_Dialog_Box step_unit
Executes the program to the next VAX instruction whose
 opcode is specified in the Instructions field and is
 encountered during program execution.

=title 'to the next exception' Option
=include debug Step_Dialog_Box step_unit
Executes the program to the next exception condition (if
 any) encountered during program execution.

=title Notification Option Menu
The Notification option menu controls the debugger
 output that is displayed upon completion of the Step
 command.

 The Notification options are as follows:

 On, with source display (default):
    The "stepped to..." message and the source line for
    the current location are displayed upon completion
    of the step.

 On, without source display:
    The "stepped to..." message is displayed upon
    completion of the step, but the source line for the
    current location is not displayed.

 Off:
    Neither the "stepped to..." message nor the source
    line for the current location are displayed upon
    completion of the step.

 If 'Set default step' was chosen on the Step/Set
 (upper-left) option menu, the default Notification
 option that is established also controls the debugger
 output when a breakpoint, tracepoint, or watchpoint is
 triggered.  You can override this default when setting
 individual breakpoints, tracepoints, and watchpoints
 (by choosing Break...  or Watch...  from the Control
 menu).

=title Step Unit(s) Field
=include debug Step_Dialog_Box step_unit
Use this field to specify the number of step units that
 the Step command is to execute.

 To specify a step unit, use the Step Unit (upper-right)
 option menu.

=title Instructions Field
=include debug Step_Dialog_Box step_unit
If you choose 'the specified instruction(s)' on the Step
 Unit (upper-right) option menu, use this field to
 specify a list of one or more VAX instructions
 (opcodes), separated by commas.

 This causes the debugger to execute the program to the
 next instruction whose opcode is specified in the list,
 if encountered during execution.

=title Within Called Routines Button
=include debug Step_Dialog_Box jsb_routines_button
=include debug Step_Dialog_Box shareable_routines_button
=include debug Step_Dialog_Box system_routines_button
The behavior of this button depends on whether you are
 specifying an option for only the next Step command or
 establishing defaults for subsequent Step
 commands---that is, whether you choose Step or Set
 default step on the Step (upper-left) option menu.

 If you are specifying an option for only the next Step
 command:

  -  Changing the setting of the Within Called Routines
     button has an effect only if program execution is
     currently suspended at a routine call.

  -  If execution is suspended at a routine call:

      +  Button on:
         Executes the program up to the start of that
         routine.  This enables you to step into, and
         then through, the called routine.  You can
         choose to have the Step command step "over"
         routines that are called by JSB instructions,
         routines in shareable images, or system service
         routines (by means of the corresponding
         buttons, which are displayed below this
         button).

      +  Button off (default):
         Executes the called routine up to and including
         the routine's RET instruction (steps over the
         routine).


 If you are establishing defaults for subsequent Step
 commands:

  -  Button on:
     Causes the Step command to execute the program step
     by step within called routines as well as within
     the routine in which execution is currently
     suspended.

  -  Button off (default):
     Causes the Step command to execute the program step
     by step only within the routine in which execution
     is currently suspended.  The Step command executes
     any called routine up to and including its RET
     instruction (steps over the routine).

=title Within Routines Called by a JSB Instruction
=include debug Step_Dialog_Box within_called_routines_button
This button applies only when the Within Called Routines
 button is on.

 Button on (default for all languages except DIBOL):
    Causes the Step command to execute the program step
    by step within routines that are called by the JSB
    or CALL instruction.

 Button off (DIBOL default):
    Causes the Step command to execute routines that are
    called by a JSB instruction in only one step, up to
    and including their RET instructions.  In DIBOL,
    user-written routines are called by the CALL
    instruction and DIBOL run-time library routines are
    called by the JSB instruction.

=title Within Called Routines in Shareable Images
=include debug Step_Dialog_Box within_called_routines_button
This button applies only when the Within Called Routines
 button is on.

 Button on (default):
    Causes the Step command to execute the program step
    by step within called routines in shareable images.

 Button off:
    Causes the Step command to execute called routines
    in shareable images in only one step, up to and
    including their RET instructions.

=title Within Called System Service Routines
=include debug Step_Dialog_Box within_called_routines_button
This button applies only when the Within Called Routines
 button is on.

 Button on (default):
    Causes the Step command to execute the program step
    by step within called system service routines.

 Button off:
    Causes the Step command to execute called system
    service routines in only one step, up to and
    including their RET instructions.

=Title Symbolize Address or Register Dialog Box
=include debug g_ok_apply_cancel_buttons
=include debug g_Symb
=include debug g_intro_to_addrexpr
Use this dialog box to display the symbolic name (if
 any) that is associated with a memory address or
 register.  The name is displayed with its path name
 prefix.

 Proceed as follows:

 1.  Enter an address or a register symbol in the
     Address Expression field.

 2.  Click on OK or Apply to display the symbol in the
     output window.

 If the address is a static address, it is symbolized as
 the nearest preceding symbol name, plus an offset.  If
 the address is also a code address and a line number
 can be found that covers the address, the line number
 is included in the symbolization.  If the address is a
 register address, the debugger displays all symbols in
 all set modules that are bound to that register.  The
 full path name of each such symbol is displayed.  The
 register name itself ("%R5", for example) is also
 displayed.

 If the address is a stack location in the call frame of
 a routine in a set module, the debugger searches for
 all symbols in that routine whose addresses are
 relative to the Frame Pointer or the Stack Pointer.
 The closest preceding symbol name plus an offset is
 displayed as the symbolization of the address.  A
 symbol whose address specification is too complex is
 ignored.

 If the debugger can find no symbolization for the
 address, a message is displayed.

=Title Watch Dialog Box
=include debug g_ok_apply_cancel_buttons
Use the Watch dialog box to set, identify, or cancel
 watchpoints.

 A watchpoint is a memory address, register, or
 (typically) a variable declared in the program whose
 value is monitored during program execution.  If the
 value changes, the debugger suspends execution and
 reports the old and new values.

 Note that you can set a watchpoint on a nonstatic
 (stack or register) variable only when program
 execution is currently suspended within the scope of
 its defining routine---that is, when the defining
 routine is active on the call stack.  See Static and
 Nonstatic (Stack or Register) Watchpoints.

Additional information available:

behavior watch dialogg set watchidentify watchcancel watchstatic nonstatic watch
global sec watchset canceladdress expression fieldwatchpoint list box
notificationtrigger in calls buttoncondition fieldafter passes field
action field

=title Debugger Behavior at Watchpoints
Whenever an instruction causes the modification of a
 watchpoint location, the debugger takes the following
 action:

 1.  Suspends program execution after that instruction
     has completed execution.

 2.  If an integer value was specified in the After
     field when the watchpoint was set, checks the
     current count.  If the specified number of counts
     has not been reached, execution is resumed and the
     debugger does not perform the remaining steps.

 3.  Evaluates the expression that was specified in the
     Condition field, if any, when the watchpoint was
     set.  If the value of the expression is false,
     execution is resumed and the debugger does not
     perform the remaining steps.

 4.  Reports that execution has reached the watchpoint
     location by issuing a "watch..." message, unless
     the 'off' option was specified in the Notification
     option menu.

 5.  Reports the old (unmodified) value at the
     watchpoint location.

 6.  Reports the new (modified) value at the watchpoint
     location.

 7.  Displays the line of source code in which execution
     is suspended, unless the 'off' or 'on, without
     source display' option was specified in the
     Notification option menu, either in the Watch
     dialog box or, previously, as a Step command
     default in the Step dialog box.

 8.  Executes the debugger commands specified in the
     Action field, if any were specified when the
     watchpoint was set.  If a Go command was specified,
     execution continues.

=title Setting Watchpoints
=include debug Watch_Dialog_Box static_nonstatic_watch
=include debug Watch_Dialog_Box global_sec_watch
=include debug Watch_Dialog_Box
 To set a watchpoint with the Watch dialog box, proceed
 as follows:

 1.  Choose the appropriate 'Set...' option from the
     Set/Cancel (upper-left) option menu.  In most cases
     you want to choose the Set watchpoint option.

     A temporary watchpoint disappears after it is
     triggered.  The watchpoint does not remain
     permanently set.

 2.  Enter an address expression in the Address
     Expression field to specify the watchpoint
     location.  In general, you can specify an address
     expression that is associated with either data or
     code (VAX instructions).  However, for high-level
     languages, you usually specify a variable name (a
     symbolic address expression that is associated with
     data).

     Or, before opening the dialog box, select the
     variable name in a window.  The name is
     automatically inserted in the Address Expression
     field.

 3.  Choose any additional options from the dialog box,
     then click on OK or Apply.

 Any watchpoints that are currently set are identified
 in the list box.

=title Identifying the Current Watchpoints
Any watchpoints that are currently set are identified in
 the list box of the Watch dialog box.

 If you established a watchpoint using the After field,
 the current value of the decimal integer N is displayed
 (that is, the originally specified integer value minus
 one for each time the watchpoint location was reached).
 The debugger decrements N each time the watchpoint
 location is reached until the value of N is zero, when
 the debugger takes watch action.

=title Canceling Watchpoints
Any watchpoints that are currently set are identified in
 the list box.  To cancel a watchpoint:

 1.  In the list box, click on the watchpoint to be
     canceled.

 2.  Click on the Cancel selected option from the
     Set/Cancel (upper) option menu.

 3.  Click on OK or Apply.

 Note that a nonstatic watchpoint (a watchpoint set on a
 stack or register variable) is canceled automatically
 when execution leaves the routine where that variable
 is defined.

=title Static and Nonstatic (Stack or Register) Watchpoints
=include debug Watch_Dialog_Box set_cancel static
=include debug Watch_Dialog_Box trigger_in_calls_button
=include debug g_resolve_symb_using_callframe
=include debug Watch_Dialog_Box
 To set a watchpoint, choose Watch...  from the Control
 menu.

 The technique for setting a watchpoint depends on
 whether the variable is static or nonstatic.  A static
 variable is associated with the same memory address
 throughout execution of the program.  You can always
 set a watchpoint on a static variable throughout
 program execution.

 A nonstatic variable is allocated on the stack or in a
 register and has a value only when its defining routine
 is active (on the call stack).  Therefore, you can set
 a watchpoint on a nonstatic variable only when
 execution is suspended within the scope of the defining
 routine (including any routine called by the definining
 routine).

 Similarly, a nonstatic watchpoint is cancelled when
 execution returns from the defining routine.  The
 debugger notifies you if you try to set a watchpoint
 when a variable is not active and also when it cancels
 a nonstatic watchpoint.

 A common technique for setting a nonstatic watchpoint
 (for example, on a variable X) is to set a tracepoint
 on the defining routine, also specifying the command
 SET WATCH X in the Action field of the Break dialog
 box.  Thus, whenever the routine is called, the
 tracepoint is triggered, and the watchpoint is
 automatically set on the local variable.

 In addition to storage allocation, another distinction
 between static and nonstatic watchpoints is speed of
 execution.  To watch a static variable, the debugger
 write-protects the page containing the variable.  If
 your program attempts to write to that page, an access
 violation occurs and the debugger handles the
 exception, determining whether the watched variable was
 modified.  Except when writing to that page, the
 program executes at normal speed.

 To watch a nonstatic variable, the debugger traces
 every instruction in the variable's defining routine
 and checks the value of the variable after each
 instruction has been executed.  Because this
 significantly slows down execution, the debugger issues
 a message when you set a nonstatic watchpoint.

 As explained in the next paragraphs, the Watch dialog
 box provides options that enable you to exercise some
 control over speed of execution and other factors when
 watching variables.

 The debugger determines whether a variable is static or
 nonstatic by checking how it is allocated.  Typically,
 a static variable is in P0 space (0 through 3FFFFFFF,
 hexadecimal); a nonstatic variable is in P1 space
 (40000000 through 7FFFFFFF) or in a register.  By
 default, the debugger issues a warning if you try to
 set a watchpoint on a variable that is allocated in P1
 space or in a register when execution is not currently
 suspended within the scope of the defining routine.

 The option 'Set nonstatic watchpoint' on the Set/Cancel
 (upper) option menu of the Watch dialog box enables you
 to override the default behavior in certain conditions.
 For example, if you have allocated your own stack in P0
 space, choose 'Set nonstatic watchpoint' when setting a
 watchpoint on a variable that is allocated on that
 stack.  This enables the debugger to treat the
 watchpoint as a nonstatic watchpoint.

 When using the Watch dialog box, you can also control
 the execution speed for nonstatic watchpoints by means
 of the button labeled Trigger Watchpoint in Called
 Routines.

=title Global Section Watchpoints
You can set watchpoints on variables or arbitrary
 program locations in global sections.  A global section
 is a region of memory that is shared among all
 processes of a multiprocess program.  A watchpoint that
 is set on a location in a global section (a global
 section watchpoint) triggers when any process modifies
 the contents of that location.

 You set a global section watchpoint just as you would
 set a watchpoint on a static variable.  However, when
 setting watchpoints on arrays or records, performance
 is improved if you specify individual elements rather
 than the entire structure in the Address Expression
 field of the Watch dialog box.

 If you set a watchpoint on a location that is not yet
 mapped to a global section, the watchpoint is treated
 as a static watchpoint.  When the location is
 subsequently mapped to a global section, the watchpoint
 is automatically treated as a global section watchpoint
 (an informational message is issued).  The watchpoint
 is then visible from each process of the multiprocess
 program.

=title Set/Cancel (Upper) Option Menu
Use the Set/Cancel option menu to specify that you want
 to set or cancel one or more watchpoints.

 A temporary watchpoint disappears after it is
 triggered.  The watchpoint does not remain permanently
 set.

 Use the 'Cancel selected watchpoint' option to cancel a
 watchpoint that you selected in the list box:

 1.  In the list box, click on the watchpoint to be
     canceled.

 2.  Click on the Cancel selected watchpoint option from
     the Set/Cancel option menu.

 3.  Click on OK or Apply.

Additional information available:

static

=title 'Set nonstatic watchpoint' Option
=include debug Watch_Dialog_Box static_nonstatic_watch
=include debug Watch_Dialog_Box set_cancel
The 'Set nonstatic watchpoint' option (and 'Set
 temporary nonstatic watchpoint' option) on the
 Set/Cancel (upper) option menu enable you to override
 the debugger's default determination of whether a
 specified variable (watchpoint location) is static or
 nonstatic.

 Use these options to specify that the debugger should
 treat the variable as a nonstatic variable, even though
 it might be allocated in P0 space.  This causes the
 debugger to monitor the location by tracing every
 instruction.

 Exercise caution when using these options.

=title Address Expression Field
=include debug g_selecting_variables
=include debug g_specifying_variables
=include debug g_specifying_code
=include debug g_intro_to_addrexpr
You can fill this field automatically by selecting text
 in a window before opening the dialog box.

 For high-level language programs, the address
 expressions you specify as watchpoints in this field
 are typically the names of variables.

 In the case of structured variables (arrays, records,
 and so on), you can specify either the entire aggregate
 or an individual element.  A watchpoint set on an
 aggregate triggers if any element changes.  Thus, you
 do not need to set watchpoints on individual array
 elements or record components.  Note, however, that you
 cannot set an aggregate watchpoint on a variant record.

 If you specify a memory address that is associated with
 a compiler-generated type, the debugger symbolizes the
 address and uses the length in bytes associated with
 that type to determine the length in bytes of the
 watchpoint location.

 If you specify a memory address that the debugger
 cannot associate with a compiler-generated type, the
 debugger monitors 4 bytes (1 longword) of memory, by
 default, beginning at the byte identified by the
 address.  You can change this length, however, by
 setting the default type to either WORD (length 2
 bytes) or BYTE (length 1 byte) by choosing Datatype
 Defaults...  from the Customize menu.

=title Watchpoint List Box
The list box identifies the watchpoints that are
 currently set.

 If you established a watchpoint using the After field,
 the current value of the decimal integer N is displayed
 (that is, the originally specified integer value minus
 one for each time the watchpoint location was reached).
 The debugger decrements N each time the watchpoint
 location is reached until the value of N is zero, when
 the debugger takes watch action.

=title Notification Option Menu
The Notification option menu controls the debugger
 output that is displayed when the watchpoint is
 triggered.

 On, with source display (default):
    The "watch..." message and the source line for the
    current location are displayed at the watchpoint.

 On, without source display:
    The "watch..." message is displayed at the
    watchpoint, but the source line for the current
    location is not displayed.

 Off:
    Neither the "watch..." message nor the source line
    for the current location are displayed at the
    watchpoint.

 Note that the default Notification option that is
 established for the Step command in the Step dialog box
 also affects the debugger output when any breakpoint,
 tracepoint, or watchpoint is triggered.  The
 Notification option you choose in the Watch dialog box
 overrides the default established in the Step dialog
 box, but only for the watchpoint that you are setting.

=title Trigger Watchpoint in Called Routines Button
This button enables you to control the execution speed
 for nonstatic watchpoints in called routines.

 Button on:
    Specifies that the debugger monitors a nonstatic
    variable by tracing instructions not only within the
    defining routine, but also within a routine that is
    called from the defining routine (and any other such
    nested calls).  This enables you to monitor
    nonstatic variables within called routines more
    precisely than when the button is off.  But the
    speed of execution within called routines is faster
    when the button is off.

 Button off (default):
    Specifies that the debugger monitors a nonstatic
    variable by tracing instructions only within the
    defining routine.  As a result, the debugger
    executes a called routine at normal speed and
    resumes tracing instructions only when execution
    returns to the defining routine.  Execution is
    faster when the button is off.  But if a called
    routine modifies the watched variable, execution is
    interrupted only upon returning to the defining
    routine.

=title Condition Field
Use this field to specify a conditional expression in
 the currently set language that is to be evaluated when
 execution reaches the watchpoint.  If the expression is
 true, watch action occurs, and the debugger reports
 that a watchpoint has been triggered.  If the
 expression is false, watch action does not occur, and
 program execution is continued.

=title After ___ Pass Field
Use this field to specify that watch action not be taken
 until the Nth time the designated watchpoint is
 encountered (after N passes).  Specify N as a decimal
 integer.  The default is 1.

 Thereafter, watch action occurs every time the
 watchpoint is encountered provided that conditions in
 the Condition field (if specified) are true.

=title Action Field
=include debug g_cmd_mode
Use this field to specify one or more debugger commands
 to be executed when watch action is taken.  Use
 semicolons (;) to separate command strings.

=Title Windows Dialog Box
=include debug g_ok_apply_cancel_buttons
Use the Windows dialog box to modify or create the
 following kinds of debugger windows:

   Source windows, such as the predefined window SRC

   Output windows, such as the predefined window OUT

   Automatic windows, such as the predefined window AUTO

   Instruction windows, such as the predefined window INST

   Register windows, such as the predefined window REG

 Note:  You cannot manipulate other kinds of debugger
 windows, such as the main window or COMMAND box, with
 the Windows dialog box.

 When you open the Windows dialog box, any existing
 window of the kind specified is identified in the list
 box.  However, window AUTO is created (and listed) only
 after you open it by clicking on the Display button in
 any one of the following dialog boxes (accessible from
 the Data menu):

   Examine Variable
   Examine Address or Register
   Language Expressions

 You can use the debugger predefined windows as examples
 for your own window definitions.

 If you are debugging a multiprocess program, see Using
 Process-Specific Windows.  The Window Name Suffix
 buttons and the Process field are used with
 process-specific windows.

Additional information available:

g wkinds attribs actsg predwndsg modify wndg create wndg proc windows
g window fieldg display list boxg wkindsg wind attribg window name
g actiong process fieldg buffer size fieldg position in pixels fields
g dimension in pixels fields

=title Overview of Window Kinds, Attributes, and Actions
=include debug Cust_Menu_Windows_Button
=include debug Wind_Dialog_Box g_wkinds
=include debug Wind_Dialog_Box g_wind_attrib
=include debug Wind_Dialog_Box g_predwnds
=include debug Wind_Dialog_Box g_modify_wnd
=include debug Wind_Dialog_Box g_create_wnd
=include debug g_cmd_mode
=include debug g_display_source
=include debug g_display_instructions
By choosing Windows...  from the Customize menu, you can
 create or modify debugger windows of the following
 kinds.

   Source windows, such as the predefined window SRC

   Output windows, such as the predefined window OUT

   Automatic windows, such as the predefined window AUTO

   Instruction windows, such as the predefined window INST

   Register windows, such as the predefined window REG

 The window kind determines what type of information the
 window can capture and display:

  -  A source window displays the source code of your
     program.

  -  An instruction window displays the decoded VAX
     assembly-language instructions for the code that is
     actually executing.  If your program has been
     optimized during compilation, the instruction
     stream might not correspond to the source code
     displayed in the source window.  Thus, one use for
     instruction windows is to verify the path of
     execution when debugging optimized code.

  -  An output window is a general-purpose window that
     can display any debugger output that is not already
     directed to another, special purpose, window (such
     as a source or instruction window).

  -  An automatic window is a window whose definition
     includes one or more commands, as specified in the
     Action field of the Windows dialog box.  Whenever
     the debugger suspends execution, the commands are
     executed automatically, and the window is updated
     with the output of the commands.  For example, you
     can use an automatic window to display the current
     values of some variables during the course of a
     debugging session.

  -  A register window displays the contents of the VAX
     registers and related information.

 The window kind can also determine how the contents of
 the window are generated.  There are two possibilities:

  -  Some windows are automatically updated.  Their
     definition includes one or more debugger commands
     that are executed whenever the debugger gains
     control from the program.  The output of the
     commands forms the contents of those windows.

     Window SRC belongs to this category:  it is
     automatically updated so that an arrow centered in
     the window shows the source line at which execution
     is currently suspended.

     When you create this kind of window, you specify
     the debugger commands in the Action field of the
     Windows dialog box.

     You can determine the built-in commands for an
     existing window (for example, SRC or INST) by
     selecting its name from the Windows dialog box list
     box and looking at the Action field.

  -  Other windows, for example, the predefined window
     OUT, derive their contents from commands you enter
     interactively.  If you create a window of this
     general category, you must first assign one or more
     attributes to that window before anything can be
     written to it.  The attribute defines the type of
     information that is written to the window (source,
     instruction, output, echo input, messages).  The
     attributes you can assign to a window depend on the
     window kind.

     You can determine the attributes that are currently
     assigned to a window (if any) by selecting its name
     from the Windows dialog box list box and looking at
     the state of the Window Attributes buttons.

     When a window has a particular attribute, XXX, it
     is referred to as the current XXX window.  For
     example, the window that has the instruction
     attribute is the current instruction window.

 By default, attributes are assigned as follows to the
 debugger predefined windows:

    Attribute:     Window:
     Source         SRC
     Output         OUT
     Instruction    none
     Echo input     none
     Messages       OUT

 Although SRC is automatically updated by its own
 built-in command, it can also receive the output of
 certain interactive commands because it has the source
 attribute by default.  For example, if you choose View
 Source from the Commands menu of window SRC and specify
 a line number in the View Source dialog box, that
 source line is then centered and boxed in window SRC.

=title Debugger Predefined Windows (SRC, OUT, AUTO, INST, REG)
=include debug g_display_predwnds
=include debug Cust_Menu_WSetups_Entry
=include debug Cust_Menu_MPwind_Entry
=include debug Wind_Dialog_Box g_wkinds_attribs_acts
=include debug Wind_Dialog_Box g_wkinds
=include debug Wind_Dialog_Box g_wind_attrib
=include debug g_display_source
=include debug g_display_instructions
=include debug Wind_Dialog_Box g_modify_wnd
=include debug Wind_Dialog_Box g_create_wnd
=include debug The_Popup_Menu
The debugger provides the following predefined windows
 that you can use to capture and display different kinds
 of data:

  -  SRC, the predefined source window

  -  OUT, the predefined output window

  -  AUTO, the predefined automatic window (a special
     output window)

  -  INST, the predefined instruction window

  -  REG, the predefined register window

 Of these windows, only SRC and OUT are displayed, by
 default, at debugger startup.  See Displaying the
 Predefined Windows INST, REG, and AUTO.

 The basic features of the predefined windows are
 described in the additional topics.  You can change
 certain characteristics of these windows, such as
 buffer size or window attributes, by choosing
 Windows...  from the Customize menu in the main window.
 You can also create additional windows similar to the
 predefined windows from the Windows...  dialog box.

 Choosing Window Setups from the Customize menu enables
 you to quickly establish any of three useful window
 configurations by clicking on a layout.  The first
 layout is the default window configuration at debugger
 startup.

Additional information available:

g srcg outg autog instg reg

=title Predefined Source Window (SRC)
=include debug Wind_Dialog_Box g_predwnds
=include debug Wind_Dialog_Box g_wkinds
=include debug Wind_Dialog_Box g_wind_attrib
=include debug g_display_source
=include debug g_source_notavailable
=include debug SRC_Display_Menu_Bar
Window SRC, which is displayed by default at debugger
 startup, is an automatically updated source window.

 You can use SRC to display source code in two basic
 ways:

  -  By default, SRC automatically displays the source
     code for the module that contains the routine in
     which execution is currently suspended.  This
     enables you to quickly determine your current
     debugging context.

  -  In addition, because SRC has the source attribute
     by default, you can use it to display the source
     code for any part of your program.

 The name of the module whose source code is displayed
 is shown at the right of the window name, SRC.  The
 numbers displayed at the left of the source code are
 the compiler-generated line numbers, as they might
 appear in a compiler-generated listing file.

 As you execute the program under debugger control, SRC
 is updated automatically whenever execution is
 suspended.  The boxed line is the line to be executed
 next.  Specifically, execution is suspended at the
 first instruction associated with the boxed line.
 Thus, the boxed line corresponds to the current PC
 value.  The PC (program counter) is a VAX register that
 contains the memory address of the next instruction to
 be executed.

 If the debugger cannot locate source code for the
 routine in which execution is suspended (because, for
 example, the routine is a run-time library routine), it
 tries to display source code in the next routine down
 on the call stack for which source code is available.
 If the debugger can display source code for such a
 routine, it issues the following message:

  SOURCESCOPE, Source lines not available for .0\%PC.
    Displaying source in a caller of the current routine.

 In such cases, the boxed line in the source window
 identifies the line that contains code following the
 call statement in the calling routine.  See Making
 Source Code Available for Display for more information.

 The built-in command that automatically updates SRC is
 EXAMINE/SOURCE .%SOURCE_SCOPE\%PC.  This command causes
 SRC to display the source code for the routine that is
 identified in the Call Frame field in the main window,
 if source code is available for that routine.  By
 default, this is the routine in which execution is
 currently suspended (the routine at the top of the call
 stack).

 If your program was optimized during compilation, the
 source code displayed in SRC might not always represent
 the code that is actually executing.  See Debugging
 Optimized Code.

=title Predefined Output Window (OUT)
=include debug Wind_Dialog_Box g_predwnds
=include debug Wind_Dialog_Box g_wkinds
=include debug Wind_Dialog_Box g_wind_attrib
=include debug OUT_Display_Menu_Bar
Window OUT is a general purpose output window.

 By default, OUT has the output and messages attributes.
 Therefore, it displays the following information:

  -  Any debugger output that is not directed to windows
     SRC, INST, or AUTO.  For example, if window INST is
     not displayed or does not have the instruction
     attribute, any output that would otherwise update
     window INST is displayed in window OUT.

  -  Debugger diagnostic messages.  Messages with a
     severity level greater than I (informational) are
     also displayed in a message box.

 Note that, when displaying variable names, routine
 names, and other symbolic address expressions, the
 debugger adds a path name prefix to the name.  The path
 name prefix identifies the nesting program elements in
 which the entity was declared in the program.  For
 example, if you examined a variable K, whose value was
 26, in routine SWAP of module SWAP_PACK, the debugger
 might display the following output:

      SWAP_PACK\SWAP\K: 26

 In this case, SWAP_PACK\SWAP\ is the path name prefix.

 In most cases, you do not need to include a path name
 prefix when specifying symbolic address expressions.
 See Understanding Symbol Path Names.

=title Predefined Automatic Window (AUTO)
=include debug Wind_Dialog_Box g_predwnds
=include debug g_display_predwnds
=include debug Wind_Dialog_Box g_wkinds
=include debug Wind_Dialog_Box g_wind_attrib
=include debug AUTO_Display_Menu_Bar
=include debug AUTO_Disp_Cmds_Menu_Entry
Note:  By default, the predefined automatic window AUTO
 is not displayed.  See Displaying the Predefined
 Windows INST, REG, and AUTO.

 Window AUTO is an automatic window.

 You can use AUTO instead of window OUT to display the
 output from the following dialog boxes (which are
 accessible from the Data menu):

    Examine Variable
    Examine Address or Register
    Language Expressions

 Window AUTO is created when you first click on the
 Display button in any one of these dialog boxes.
 Thereafter, AUTO remains open until you close it.

 AUTO includes a debugger command list in its
 definition.  Every time the debugger gains control,
 AUTO is updated with the output of that command list.

 When AUTO is created, its command list consists of the
 Examine or Evaluate command that was generated when you
 clicked on the Display button, and it displays the
 output of that command.

 Subsequently, every time you click on the Display
 button in any of the three dialog boxes listed, the
 debugger appends the new command generated to the
 current command list and updates AUTO to display the
 output from the entire command list.

 The usual way to add or delete a command from the
 definition of a window such as AUTO is to choose
 Windows...  from the Customize menu and then update the
 command list in the Action field for that window.  As
 an alternative, the Commands menu on window AUTO
 enables you to quickly add or delete an Examine command
 from the command list for that window by selecting
 text, without having to open the Windows dialog box.

=title Predefined Instruction Window (INST)
=include debug Wind_Dialog_Box g_predwnds
=include debug g_display_predwnds
=include debug Wind_Dialog_Box g_wkinds
=include debug Wind_Dialog_Box g_wind_attrib
=include debug g_display_instructions
=include debug INST_Display_Menu_Bar
Note:  By default, the predefined instruction window
 INST is not displayed and does not have the instruction
 attribute.  See Displaying the Predefined Windows INST,
 REG, and AUTO.

 Window INST is an automatically updated instruction
 window.

 INST displays the decoded VAX assembly-language
 instruction stream of your program.  This is the exact
 code that is executing, including the effects of any
 compiler optimization.  The topic Debugging Optimized
 Code explains how to use INST with the source window
 SRC when debugging optimized code.

 You can use INST in two basic ways:

  -  By default, INST automatically displays the decoded
     instructions for the routine in which execution is
     currently suspended.  This enables you to quickly
     determine your current debugging context.

  -  In addition, if INST has the instruction attribute,
     you can use it to display the decoded instructions
     for any part of your program.

 The name of the routine whose instructions are
 displayed is shown at the right of the window name,
 INST.  The numbers displayed at the left of the
 instructions are the compiler-generated source line
 numbers.

 As you execute the program under debugger control, INST
 is updated automatically whenever execution is
 suspended.  The instruction at which execution is
 suspended (the instruction at the current PC value) is
 boxed.

 The built-in command that automatically updates INST is
 EXAMINE/INSTRUCTION .%INSTRUCTION_SCOPE\%PC.  This
 command causes INST to display the instructions for the
 routine that is identified in the Call Frame field in
 the main window.  By default, this is the routine in
 which execution is currently suspended (the routine at
 the top of the call stack).

=title Predefined Register Window (REG)
=include debug Wind_Dialog_Box g_predwnds
=include debug g_display_predwnds
=include debug Wind_Dialog_Box g_wkinds
=include debug REG_Display_Menu_Bar
Note:  By default, the predefined register window REG is
 not displayed.  See Displaying the Predefined Windows
 INST, REG, and AUTO.

 Window REG is an automatically updated window that
 displays the current values, in hexadecimal format, of
 the VAX general registers (R0 through R11, AP, FP, SP,
 and PC), the four condition code bits (C,V, Z, and N)
 of the processor status longword (PSL), and as many of
 the top stack values as can be displayed in the window.

 The register values displayed are for the routine in
 which execution is currently suspended.

 The register values are updated whenever the debugger
 takes control.

=title Modifying Debugger Windows
=include debug Cust_Menu_Windows_Button
=include debug Wind_Dialog_Box g_wkinds_attribs_acts
=include debug Wind_Dialog_Box g_create_wnd
=include debug Wind_Dialog_Box g_predwnds
=include debug Wind_Dialog_Box g_wkinds
=include debug Wind_Dialog_Box g_wind_attrib
=include debug g_cmd_mode
=include debug Cust_Menu_WSetups_Entry
=include debug Cust_Menu_MPwind_Entry
=include debug Wind_Dialog_Box g_proc_windows
=include debug g_display_source
=include debug g_display_instructions
To modify an existing window, proceed as follows:

 1.  Choose Windows...  from the Customize menu.

 2.  Click on the window name in the list box of the
     Windows dialog box.  This updates the dialog box
     with the selected window's name and its current
     parameters (window name, kind, attributes, action,
     position, dimension, and so on).

 3.  Modify the window parameters as desired.

 4.  Click on OK or Apply.

=title Creating Debugger Windows
=include debug Wind_Dialog_Box g_wkinds g_srcwk src
=include debug Wind_Dialog_Box g_wkinds g_outwk out
=include debug Wind_Dialog_Box g_wkinds g_autowk auto
=include debug Wind_Dialog_Box g_wkinds g_instwk inst
=include debug Wind_Dialog_Box g_wkinds g_regwk reg
=include debug Wind_Dialog_Box g_proc_windows create_wnd
=include debug Wind_Dialog_Box g_modify_wnd
The additional topics explain how to create debugger
 windows to capture and display specific data.

=title Using Process-Specific Windows
=include debug g_multiproc
=include debug Cust_Menu_Windows_Button
=include debug Process_Status_L_Button
=include debug Cust_Menu_MPwind_Entry
=include debug Wind_Dialog_Box g_wkinds_attribs_acts
=include debug Wind_Dialog_Box g_predwnds
 Note:  Process-specific windows are used to debug
 multiprocess programs.

 In a multiprocess debugging configuration, the
 predefined windows SRC, INST, OUT, and REG are
 associated with the visible process.  For example,
 window SRC shows the source code where execution is
 suspended in the visible process, window OUT shows the
 output of commands executed in the context of the
 visible process, and so on.

 Similarly, any windows you create with the Windows
 dialog box are associated with the visible process,
 unless you specify a process in the Process field.

 In a multiprocess configuration, the predefined
 tracepoint on process activation automatically creates
 a new source window and a new instruction window for
 each new process that comes under debugger control.
 The windows have the names SRC_n and INST_n,
 respectively, where n is the process number.

 These predefined process-specific source and
 instruction windows are not displayed, by default.
 However you can open them by choosing Multiprocess
 Window Setups from the Customize menu.

 You can also use several predefined keypad-key
 sequences to manipulate these process-specific windows
 (see Entering Debugger Commands from the Keypad).

 The contents of a process-specific window are generated
 and modified in the context of that process.

 Any process-specific source and instruction windows
 that are created by the debugger on process activation
 are automatically canceled by the predefined tracepoint
 on process termination.

Additional information available:

create wnd

=title Creating Process-Specific Windows
=include debug Cust_Menu_Windows_Button
=include debug Wind_Dialog_Box g_proc_windows
=include debug Wind_Dialog_Box g_wkinds
=include debug Wind_Dialog_Box g_wind_attrib
=include debug Wind_Dialog_Box g_create_wnd
=include debug g_multiproc
In a multiprocess configuration, the predefined
 tracepoint on process activation automatically creates
 a new source window and a new instruction window for
 each new process that comes under debugger control.
 The windows have the names SRC_n and INST_n,
 respectively, where n is the process number.

 In addition to using these windows, you can create your
 own process-specific windows and make existing windows
 process specific.  You can make windows of any window
 kind process specific (source, instruction, output,
 automatic, or register).

 To create a process-specific window:

 1.  Choose Windows...  from the Customize menu.

 2.  Specify the window name in the Window field of the
     Windows dialog box.

 3.  Specify the window kind, attributes, and action, as
     applicable.  You assign attributes to
     process-specific windows in the same way that you
     assign them to windows that are not process
     specific.

 4.  Specify the process-specification to be associated
     with that window in the Process field.

 5.  Specify any other options.

 6.  Click on OK or Apply.

 The following example shows how to create an
 automatically updated source window named 3SOURCE that
 is specific to process 3.  The window thus created
 displays the source code where execution is suspended
 in process 3.

 1.  Specify 3SOURCE in the Window field.

 2.  Specify the Source Window Kind (and Window
     Attribute, if desired).

 3.  Specify the command EXAM/SOURCE .%SOURCE_SCOPE\%PC
     in the Action field.  This command shows the source
     code where execution is suspended (or the source
     code for the caller routine, if no source code is
     available for display).

 4.  Specify %PROC 3 in the Process field.

 5.  Specify None under the Window Name Suffix label.

 The Window Name Suffix label and buttons are another
 multiprocess-debugging feature of the Windows dialog
 box.  Use these buttons to automatically append a
 process-specific suffix to the window name specified in
 the Window field.

 The suffix denotes the visible process at the time that
 the window is created or modified.  The suffix can be
 either the debugger assigned process number, the VMS
 process name, or the VMS process identifier number
 (PID).  Note that the process number and name of the
 visible process are displayed in the Visible Process
 field of the main window.

=title Window Field
Use this field to specify the name of a window that you
 want to modify or create.

 Note:  With the Windows dialog box, you can manipulate
 only debugger source, instruction, output, automatic,
 and register windows.  You cannot use the dialog box to
 manipulate other debugger windows (the main window, the
 COMMAND box, and so on).

 You can specify a window name in any of these ways:

  -  Type the window name in the Window field.

  -  Click on a window name in the list box.  The window
     field is filled automatically with that name.

  -  If text was selected when you opened the dialog
     box, the Window field is filled automatically.

=title Window List Box
=include debug Wind_Dialog_Box g_predwnds
=include debug g_display_predwnds
The list box lists the names of all debugger source,
 instruction, output, automatic, and register windows
 that currently exist.

 At debugger startup, only the following predefined
 debugger windows are listed:

   SRC   predefined source window
   OUT   predefined output window
   INST  predefined instruction window
   REG   predefined register window

 Note:  By default, windows INST, REG, and AUTO are not
 displayed.  See Displaying the Predefined Windows INST,
 REG, and AUTO.

=title Window Kinds (Source, Output, Automatic, Instr, Reg)
=include debug Cust_Menu_Windows_Button
=include debug Wind_Dialog_Box g_wind_attrib
=include debug Wind_Dialog_Box g_wkinds_attribs_acts
=include debug Wind_Dialog_Box g_predwnds
You can create and modify the following kinds of windows
 by choosing Windows...  from the Customize menu:

   Source windows, such as the predefined window SRC

   Output windows, such as the predefined window OUT

   Automatic windows, such as the predefined window AUTO

   Instruction windows, such as the predefined window INST

   Register windows, such as the predefined window REG

 The window kind determines what type of information a
 window can capture and display and how that information
 is generated.

 To specify the window kind, click on the appropriate
 button under the Window Kind label in the Windows
 dialog box.

 You can modify the window kind of an existing window.

Additional information available:

g srcwkg outwkg autowkg instwkg regwk

=title Source Windows
=include debug Wind_Dialog_Box g_wkinds
=include debug Wind_Dialog_Box g_wind_attrib
=include debug Wind_Dialog_Box g_predwnds
=include debug g_display_source
=include debug SRC_Display_Menu_Bar
The source window kind specifies a window that displays
 source code as it might appear in a compiler-generated
 listing.

 The predefined window SRC is an example of a source
 window.

 If your program has been optimized during compilation,
 the source code displayed in a source window might not
 always reflect the code that is actually executing.
 See Debugging Optimized Code.

 In a source window, the numbers to the left of the
 source code are line numbers, as in a compiler listing.
 The box around a source line can indicate any of the
 following, depending on the command that last updated
 the displayed information:

  -  The source line at which execution is currently
     suspended (the line to be executed next)

  -  The source line that follows a routine call
     statement, if source code for a calling routine is
     being displayed

  -  The source line corresponding to an address
     expression that was specified through the Examine
     Code or View Instructions dialog box

Additional information available:

src

=title Creating a Source Window
=include debug Cust_Menu_Windows_Button
=include debug Wind_Dialog_Box g_wkinds g_srcwk
=include debug Wind_Dialog_Box g_wkinds
=include debug Wind_Dialog_Box g_wind_attrib
=include debug Wind_Dialog_Box g_wkinds_attribs_acts
=include debug Wind_Dialog_Box g_predwnds
=include debug g_display_source
=include debug g_cmd_mode
=include debug Wind_Dialog_Box g_proc_windows
=include debug Wind_Dialog_Box g_create_wnd
 To create a source window:

 1.  Choose Windows...  from the Customize menu.

 2.  Specify the window name in the Window field of the
     Windows dialog box.

 3.  Choose the Source option under the Window Kind
     label.

 4.  If you want the source window to be updated
     whenever you enter commands to display source code,
     choose the Source attribute.  This makes the window
     the current source window.

 5.  If you want the source window to be updated
     automatically by a built-in TYPE or EXAMINE/SOURCE
     command whenever the debugger takes control,
     specify that command in the Action field.

     Window SRC is an automatically updated source
     window.  You can determine its built-in command by
     selecting the name SRC from the Windows dialog box
     list box and looking at the Action field.  See The
     Debugger's Command Interface for details on command
     syntax.

 6.  Specify any other options.

 7.  Click on OK or Apply.

=title Output Windows
=include debug Wind_Dialog_Box g_wkinds
=include debug Wind_Dialog_Box g_wind_attrib
=include debug Wind_Dialog_Box g_predwnds
=include debug OUT_Display_Menu_Bar
The output window kind specifies a general purpose
 window that can capture and display any debugger output
 that is not directed to another window (according to
 the attributes assigned to various windows).

 The predefined window OUT is an example of an output
 window.  By default, OUT has the output and messages
 attributes.

 If no source window has the source attribute, the
 current output window displays source code that results
 from the following actions (and would otherwise update
 the current source window):

  -  Clicking on View Current Location from the pop-up
     menu.

  -  Using the View Source dialog box (from the Commands
     menu of a source window).

  -  Using the Examine Code dialog box with the Source
     Code option (from the Data menu).

  -  Entering a TYPE or EXAMINE/SOURCE command in the
     COMMAND box.

 If no instruction window has the instruction attribute,
 the current output window displays instructions that
 result from the following actions (and would otherwise
 update the current instruction window):

  -  Clicking on View Current Location from the pop-up
     menu.

  -  Using the View Instructions dialog box (from the
     Commands menu of an instruction window).

  -  Using the Examine Code dialog box with the
     Instructions option (from the Data menu).

  -  Entering an EXAMINE/INSTRUCTION command in the
     COMMAND box.

Additional information available:

out

=title Creating an Output Window
=include debug Cust_Menu_Windows_Button
=include debug Wind_Dialog_Box g_wkinds g_outwk
=include debug Wind_Dialog_Box g_wkinds
=include debug Wind_Dialog_Box g_wind_attrib
=include debug Wind_Dialog_Box g_wkinds_attribs_acts
=include debug Wind_Dialog_Box g_predwnds
=include debug Wind_Dialog_Box g_proc_windows
=include debug Wind_Dialog_Box g_create_wnd
 To create an output window:

 1.  Choose Windows...  from the Customize menu.

 2.  Specify the window name in the Window field of the
     Windows dialog box.

 3.  Choose the Output option under the Window Kind
     label.

 4.  Assign any number of the following three attributes
     by choosing the appropriate option under the Window
     Attribute label:

       Output attribute
       Echo input attribute
       Messages attribute


 5.  Specify any other options.

 6.  Click on OK or Apply.

=title Automatic Windows
=include debug Wind_Dialog_Box g_wkinds
=include debug Wind_Dialog_Box g_wind_attrib
=include debug Wind_Dialog_Box g_predwnds
=include debug Wind_Dialog_Box g_action
=include debug AUTO_Display_Menu_Bar
=include debug AUTO_Disp_Cmds_Menu_Entry
The automatic window kind specifies an automatically
 updated window that displays the output from one or
 more debugger commands (specified in the Action field
 of the Windows dialog box).  The commands are executed
 in the order listed whenever the debugger takes
 control.

 The predefined window AUTO that is optionally invoked
 from the Examine Variable, Examine Address or Register,
 and Language Expressions dialog boxes is an example of
 an automatic window.

 The Commands menu on an automatic window enables you to
 quickly add or delete an Examine command from the
 command list for that window without having to open the
 Windows dialog box.

Additional information available:

auto

=title Creating an Automatic Window
=include debug Cust_Menu_Windows_Button
=include debug Wind_Dialog_Box g_wkinds g_autowk
=include debug Wind_Dialog_Box g_wkinds
=include debug Wind_Dialog_Box g_wkinds_attribs_acts
=include debug Wind_Dialog_Box g_predwnds
=include debug g_cmd_mode
=include debug Wind_Dialog_Box g_proc_windows
=include debug Wind_Dialog_Box g_create_wnd
 To create an automatic window:

 1.  Choose Windows...  from the Customize menu.

 2.  Specify the window name in the Window field of the
     Windows dialog box.

 3.  Choose the Automatic option under the Window Kind
     label.

 4.  Specify one or more commands in the Action field.
     Separate multiple commands with semicolons (;).

 5.  Specify any other options.

 6.  Click on OK or Apply.

=title Instruction Windows
=include debug Wind_Dialog_Box g_wkinds
=include debug Wind_Dialog_Box g_wind_attrib
=include debug Wind_Dialog_Box g_predwnds
=include debug g_display_predwnds
=include debug g_display_instructions
=include debug INST_Display_Menu_Bar
The instruction window kind specifies a window that
 displays the decoded VAX assembly-language instruction
 stream for the image that is being debugged.

 Because an instruction window shows the exact code that
 is executing, it is particularly useful in helping you
 debug optimized code.  See Debugging Optimized Code.

 The predefined window INST is an example of an
 instruction window.  By default, INST is not displayed
 and does not have the instruction attribute.  See
 Displaying the Predefined Windows INST, REG, and AUTO.

 In an instruction window, the numbers to the left of
 the instructions are compiler-generated line numbers.
 The box around an instruction can indicate any of the
 following, depending on the command that last updated
 the displayed information:

  -  The instruction at which execution is currently
     suspended (the next instruction to be executed)

  -  The instruction that called a routine, if
     instructions for a calling routine are being
     displayed

  -  The instruction corresponding to an address
     expression that was specified through the Examine
     Code or View Instructions dialog boxes

Additional information available:

inst

=title Creating an Instruction Window
=include debug Cust_Menu_Windows_Button
=include debug Wind_Dialog_Box g_wkinds g_instwk
=include debug Wind_Dialog_Box g_wkinds
=include debug Wind_Dialog_Box g_wind_attrib
=include debug Wind_Dialog_Box g_wkinds_attribs_acts
=include debug Wind_Dialog_Box g_predwnds
=include debug g_display_instructions
=include debug g_cmd_mode
=include debug Wind_Dialog_Box g_proc_windows
=include debug Wind_Dialog_Box g_create_wnd
 To create an instruction window:

 1.  Choose Windows...  from the Customize menu.

 2.  Specify the window name in the Window field of the
     Windows dialog box.

 3.  Choose the Instruction option under the Window Kind
     label.

 4.  If you want the instruction window to be updated
     whenever you enter commands to display
     instructions, choose the Instruction attribute.
     This makes the window the current instruction
     window.

 5.  If you want the instruction window to be updated
     automatically by a built-in EXAMINE/INSTRUCTION
     command whenever the debugger takes control,
     specify that command in the Action field.

     Window INST is an automatically updated instruction
     window.  You can determine its built-in command by
     selecting the name INST from the Windows dialog box
     list box and looking at the Action field.  See The
     Debugger's Command Interface for details on command
     syntax.

 6.  Specify any other options.

 7.  Click on OK or Apply.

=title Register Windows
=include debug Wind_Dialog_Box g_wkinds
=include debug Wind_Dialog_Box g_wind_attrib
=include debug Wind_Dialog_Box g_predwnds
=include debug g_display_predwnds
=include debug REG_Display_Menu_Bar
The register window kind specifies an automatically
 updated window that shows the contents of the VAX
 registers and related information.

 A register window displays the current values (in
 hexadecimal format) of the VAX general registers (R0
 through R11, AP, FP, SP, PC), the four condition code
 bits (C,V, Z, and N) of the processor status longword
 (PSL), and as many of the top stack values as can be
 displayed through the window.

 The register values displayed are for the routine in
 which execution is currently suspended.

 The predefined window REG is an example of a register
 window.  By default, window REG is not displayed.  See
 Displaying the Predefined Windows INST, REG, and AUTO.

 The values contained in the registers are updated
 whenever the debugger takes control.

Additional information available:

reg

=title Creating a Register Window
=include debug Cust_Menu_Windows_Button
=include debug Wind_Dialog_Box g_wkinds g_regwk
=include debug Wind_Dialog_Box g_wkinds
=include debug Wind_Dialog_Box g_wkinds_attribs_acts
=include debug Wind_Dialog_Box g_predwnds
=include debug Wind_Dialog_Box g_proc_windows
=include debug Wind_Dialog_Box g_create_wnd
 To create a register window:

 1.  Choose Windows...  from the Customize menu.

 2.  Specify the window name in the Window field of the
     Windows dialog box.  To create a register window:

 3.  Choose the Register option under the Window Kind
     label.

 4.  Specify any other options.

 5.  Click on OK or Apply.

=title Window Attributes
=include debug Cust_Menu_Windows_Button
=include debug Wind_Dialog_Box g_wkinds
=include debug Wind_Dialog_Box g_wkinds_attribs_acts
=include debug Wind_Dialog_Box g_predwnds
To assign one or more attributes to a debugger window,
 choose Windows...  from the Customize menu.

 The attributes that can be assigned to windows are as
 follows:

   Source
   Output
   Instruction
   Echo input
   Messages

 Each attribute represents some type of data (source
 code, input commands, diagnostic messages, and so on).
 Assigning an attribute to a window causes that window
 to receive and display that type of data.

 The attributes you can assign to a window depend on the
 window kind.

 To assign attributes to a window, proceed as follows:

 1.  Choose Windows...  from the Customize menu.

 2.  Enter the window name in the Window field of the
     Windows dialog box.

 3.  Click on the appropriate window kind button
     (source, instruction, output, automatic, or
     register).

 4.  Choose one or more window attributes, if applicable
     to that window kind.

 5.  Click on OK or Apply.

 By default, attributes are assigned as follows to the
 debugger predefined windows:

    Attribute:     Window:
     Source         SRC
     Output         OUT
     Instruction    none
     Echo input     none
     Messages       OUT

Additional information available:

g srcwag outwag instwag inpwag msgwa

=title Source Attribute
=include debug Wind_Dialog_Box g_wkinds
=include debug Wind_Dialog_Box g_wind_attrib
=include debug g_callframe_buttons_display_src
=include debug g_display_source
Assigning the source attribute establishes the specified
 window as the current source window.  The current
 source window is updated whenever you display source
 code through the following means:

  -  Click on View Current Location from the pop-up
     menu.

  -  Click on the Call Frame arrow buttons in the main
     window.

  -  Use the View Source dialog box (from the Commands
     menu of a source window).

  -  Use the Examine Code dialog box with the Source
     Code option (from the Data menu).

  -  Enter a TYPE or EXAMINE/SOURCE command in the
     COMMAND box or in an Action field of a dialog box.

 The source attribute can be assigned only to a source
 window.

 The predefined source window SRC has the source
 attribute by default.

 If no window has the source attribute, the output of
 these commands is directed at the current output
 window.

=title Output Attribute
=include debug Wind_Dialog_Box g_wkinds
=include debug Wind_Dialog_Box g_wind_attrib
Assigning the output attribute establishes the specified
 window as the current output window.  The current
 output window displays any debugger output that is not
 otherwise directed to another window.

 The output attribute can be assigned only to an output
 window.

 The predefined output window OUT has the output
 attribute, by default.

 If no window has the output attribute, debugger output
 that would otherwise be directed at the current output
 window is suppressed.

=title Instruction Attribute
=include debug Wind_Dialog_Box g_wkinds
=include debug Wind_Dialog_Box g_wind_attrib
=include debug g_callframe_buttons_display_inst
=include debug g_display_instructions
=include debug Cust_Menu_WSetups_Entry
Assigning the instruction attribute establishes the
 specified window as the current instruction window.
 The current instruction window is updated whenever you
 display instructions through the following means:

  -  Click on View Current Location from the pop-up
     menu.

  -  Click on the Call Frame arrow buttons in the main
     window.

  -  Use the View Instructions dialog box (from the
     Commands menu of an instruction window).

  -  Use the Examine Code dialog box with the
     Instructions option (from the Data menu).

  -  Enter an EXAMINE/INSTRUCTION command in the COMMAND
     box or in an Action field of a dialog box.

 The instruction attribute can be assigned only to an
 instruction window.

 No window has the instruction attribute by default.

 If no window has the instruction attribute, the output
 of these commands is directed at the current output
 window.

 You can assign the instruction attribute to the
 predefined instruction window INST in any of the
 following ways:

  -  Use the Windows dialog box.

  -  Choose Window Setups from the Customize menu, then
     click on one of the two setups that include INST.
     This action automatically assigns the instruction
     attribute to INST.

=title Echo Input Attribute
=include debug Wind_Dialog_Box g_wkinds
=include debug Wind_Dialog_Box g_wind_attrib
=include debug Cust_Hide_Show_Command_DB
=include debug g_cmd_mode
=include debug g_log_file
An action that you direct at the debugger through the
 DECwindows interface (for example, by clicking on OK in
 a dialog box) is translated into a debugger command
 before it is processed by the debugger.

 You can determine the command that is issued in the
 following ways:

  -  Assign the echo input attribute to an output
     window.  This establishes the specified window as
     the current echo input window.  The current echo
     input window echoes the commands that are issued to
     the debugger.

     The current echo input window also echoes any
     commands that you enter directly in the COMMAND
     box.

  -  Open the COMMAND box by choosing Show Command...
     from the Customize menu.  Commands are echoed at
     the debugger prompt, DBG>.

 The echo input attribute can be assigned only to an
 output window.

 No window has the echo input attribute by default.

 If no window has the echo input attribute, commands are
 echoed only in the COMMAND box.

 You can assign the echo input attribute to the
 predefined output window OUT by using the Windows
 dialog box.

 Note that a debugger log file contains a record of the
 commands issued during a debugging session and the
 corresponding debugger output.

=title Messages Attribute
=include debug Wind_Dialog_Box g_wkinds
=include debug Wind_Dialog_Box g_wind_attrib
Assigning the messages attribute establishes the
 specified window as the current message window.  Under
 those conditions, debugger diagnostic messages (of all
 severity levels) are displayed in both a normal message
 window and the current message window.

 The messages attribute can be assigned only to an
 output window.

 The predefined output window OUT has the messages
 attribute, by default.

 If no window has the messages attribute, debugger
 diagnostic messages are displayed in both a normal
 message window and the COMMAND box, if the latter is
 displayed.  To open the COMMAND box, choose Show
 Command...  from the Customize menu.

 Messages displayed in a message box show only the
 message text.  Also, only those messages whose severity
 level is greater than I (informational) are displayed
 in a message box.

 Messages displayed in the COMMAND box or in the current
 message window show the message text, ident, severity,
 and facility (DEBUG).

 You can assign the messages attribute to the predefined
 output window OUT by using the Windows dialog box.

=title Window Name Suffix
=include debug Wind_Dialog_Box g_proc_windows
=include debug Wind_Dialog_Box g_process_field
=include debug Process_Status_L_Button
=include debug g_multiproc
=include debug Cust_Menu_MPwind_Entry
Note:  This feature applies only to multiprocess
 programs.

 Use the Window Name Suffix buttons to append a
 process-specific suffix to the window name specified in
 the Window field.  The suffix denotes the visible
 process at the time that the window is created or
 modified.

 The following Window Name Suffix options are available:

 None            No suffix is appended to the window name.

 Process Number  The process number of the visible process
                 is appended to the window name. It is the
                 process number that is displayed in the
                 Visible Process field of the main window.

 Process Name    The process name of the visible process
                 is appended to the window name. It is the
                 process name that is displayed in the
                 Visible Process field of the main window.

 Process ID      The VMS process identifier number (PID)
                 of the visible process is appended to
                 the window name.
 See Using Process-Specific Windows for more information
 about windowing features for multiprocess debugging.

=title Action Field
=include debug Wind_Dialog_Box g_wkinds
=include debug Wind_Dialog_Box g_wind_attrib
=include debug Wind_Dialog_Box g_wkinds_attribs_acts
=include debug g_cmd_mode
Use this field to specify one or more debugger commands
 for an automatic, source, or instruction window.

 The commands are executed, and thereby update the
 window, whenever the debugger takes control.

 Use semicolons (;) to separate command strings.

 See the additional topic for information about the
 debugger command syntax and other aspects of the
 debugger's command interface.

=title Process Field
=include debug Wind_Dialog_Box g_proc_windows
=include debug Wind_Dialog_Box g_window_name
=include debug Process_Status_L_Button
=include debug g_multiproc
=include debug Cust_Menu_MPwind_Entry
Note:  This feature applies only to multiprocess
 programs.

 Use this field to specify a process when creating or
 modifying a process-specific window.

 See Specifying Processes of a Multiprocess Program for
 the syntax.

=title Buffer Size Field
Each debugger source, instruction, output, automatic,
 and register window has a memory buffer.  The buffer
 size is independent of the window size and can be
 adjusted to hold more or fewer lines of text.  The
 default buffer size is 100 lines for output windows and
 64 lines for other windows.

 Use the Buffer Size field to specify the maximum number
 of text lines that the window's buffer can hold.

 By scrolling a source window or an instruction window,
 you can see all the lines of source code of the
 associated module or all the instructions of the
 associated routine, respectively, regardless of the
 size of the memory buffer.  This is because the
 necessary information is paged into the buffer as
 needed.  For such windows, the buffer size affects only
 performance (according to the extent of paging
 necessary).

 For output and automatic windows, the buffer size
 defines the maximum number of lines that the window can
 hold.  If more text (debugger output) is added to the
 window, the oldest lines are discarded to make room for
 the new text.  You cannot retrieve the lost lines by
 scrolling the window.

=title Position in Pixels Fields
Use the Horizontal and Vertical fields to specify the
 position of the upper left corner of a window, in
 pixels.  The coordinates (0,0) specify the upper left
 corner of the workstation screen.

 See your workstation documentation for the screen
 dimensions, in pixels.

 Specify the position as an integer literal in these
 fields.  Do not use debugger built-in symbols, such as
 %PAGE or %WIDTH.

=title Dimension in Pixels Fields
Use the Height and Width fields to specify the height
 and width of the window, in pixels.

 See your workstation documentation for the screen
 dimensions, in pixels.

 Specify the dimension as an integer literal in these
 fields.  Do not use debugger built-in symbols, such as
 %PAGE or %WIDTH.

=Title Tasks Dialog Box
=include debug g_ok_apply_cancel_buttons
=include debug g_lang
Note:  Use the Tasks dialog box to debug a VAX Ada
 tasking program.

 Use the Tasks dialog box to display information about
 specified tasks and to control the tasking environment.
 Proceed as follows:

 1.  Choose an option from the Task option menu.

 2.  Specify a task in the Task field:

      -  By default, the task identifier of the visible
         task is displayed.  A task identifier consists
         of the built-in symbol %TASK followed by an
         integer (for example, %TASK 3).

      -  To specify another task, select it from the
         list box (click on the task identifier) or type
         a task specification in the Task field.


 3.  Set the task priority on the Priority scale, if
     applicable.

 4.  Click on OK or Apply.

 See the VAX Ada documentation for complete information
 about debugging tasking programs.

Additional information available:

task optiong task fieldg task list boxg priority scale

=title Task Option Menu
Use the Task option menu to:

  -  Set the active task

  -  Set the visible task

  -  Put a task on hold or release a task from the hold
     state

  -  Set a task's priority

  -  Display brief or detailed information about a task

  -  Display statistics about the tasking environment

  -  Abort a task

Additional information available:

active taskset visible taskhold taskset task priorityshow task
show statisticsabort task

=title Setting the Active Task
=include debug Task_Dialog_Box task_option hold_task
=include debug Task_Dialog_Box task_option
Use the Set active option to set the active task.  This
 is the task that runs when you enter a command that
 starts execution (for example, Step or Go).

 Making a task the active task causes a task switch to
 the new active task and makes that task the visible
 task.  The specified task must be in either the RUNNING
 or READY state.

 When using this option, specify only one task in the
 Task field.

 See Holding and Releasing a Task for a description of
 the effect of setting the active task on a task that is
 in the hold state.

=title Setting the Visible Task
=include debug Task_Dialog_Box task_option
Use the Set visible option to set the visible task.
 This is the task whose stack and register set are the
 current context for looking up names, calls, and so on.
 For example, examine and deposit operations are
 directed at the visible task.

 When using this option, specify only one task in the
 Task field.

=title Holding and Releasing a Task
=include debug Task_Dialog_Box task_option active_task
=include debug Task_Dialog_Box task_option
Use the Hold option to put a task on hold (and thereby
 prevent task switching).  Use the Release option to
 release a task from the hold state.

 If no task is specified in the Task field, the Hold
 option puts the visible task on hold, and the Release
 option releases the visible task from that state.

 Putting a task on hold prevents it from entering the
 RUNNING state.  A task that is on hold is allowed to
 make other state transitions.  In particular, it can
 change from the SUSPENDED to the READY state.

 A task that is already in the RUNNING state (the active
 task) can continue to execute as long as it remains in
 the RUNNING state, even though it is on hold.  If the
 task leaves the RUNNING state for any reason (including
 expiration of a time slice, if timeslicing is enabled),
 it might not return to the RUNNING state until it is
 released from the hold state.

 You can force a task into the RUNNING state by making
 it the active task, even if the task is on hold.

 Putting all tasks on hold freezes the state of all
 tasks except the active task.  A useful debugging
 technique is to put all tasks on hold and then make a
 particular task the active task in order to observe its
 behavior in isolation (through a Step or Go command).

=title Setting a Task's Priority
=include debug Task_Dialog_Box task_option
If pragma PRIORITY was not specified in the program, the
 default priority for a task is 7.

 To set a task's priority:

 1.  Specify the task in the Task field.  If no task is
     specified, the priority of the visible task is set.

 2.  Choose Set priority on the Task option menu.

 3.  Set the priority on the priority scale (from 0 to
     15, inclusive).

 4.  Click on OK or Apply.

 Note that this does not prevent the task's priority
 from later changing in the course of execution, for
 example, while executing a rendezvous.

=title Displaying Information About a Task
=include debug Task_Dialog_Box task_option
Use the Show brief and Show detailed options to display
 brief and detailed information, respectively, about one
 or more specified tasks.

 You can specify any task that is currently in existence
 (namely, any task that was created and whose master has
 not yet terminated).

 The brief display provides one line of basic
 information for each specified task.  For example:

    task id   pri hold state   substate        task object
  * %TASK 1    7       RUN                   122624
    %TASK 2    7  HOLD SUSP  Accept          H4.MONITOR
    %TASK 3    6       READY Entry call      H4.CHECK_IN

 Tasks are listed by their task identifiers (task id).
 The active task is marked with an asterisk and is
 always the task that is in the RUN state.

 The detailed display provides several lines of
 information.

=title Displaying Tasking Statistics
=include debug Task_Dialog_Box task_option
Use the Show statistics option to display tasking
 statistics for the entire tasking system.

 You can use this information to measure the performance
 of your tasking program.  The larger the number of
 total schedulings (also known as context switches), the
 more tasking overhead there is.

 Do not specify a task when using this option.

=title Aborting a Task
=include debug Task_Dialog_Box task_option
Use the Abort option to abort one or more tasks.  If no
 task is specified, the visible task is aborted.

 When aborted, a task is marked for termination but is
 not immediately terminated.  The effect is identical to
 executing the Ada statement abort task-name, and causes
 the specified tasks to become abnormal.

=title Task Field
Use this field to specify one or more tasks of the
 tasking program.

 By default, the task identifier of the visible task is
 displayed in this field.  A task identifier consists of
 the built-in symbol %TASK followed by an integer.

 When referring to tasks, you can use any of the
 following task specifications (see the VAX Ada
 documentation for more details):

  -  An Ada language expression for a task value (for
     example, a task object name).  You can use a path
     name.

  -  The task identifier (for example, %TASK 2), as
     indicated in the list box or in debugger output.

  -  A task built-in symbol (%ACTIVE_TASK, %CALLER_TASK,
     %NEXT_TASK, or %VISIBLE_TASK).


 When using the 'Set active' or 'Set visible' option on
 the Task option menu, specify only one task.

 When specifying several tasks, separate the
 specifications with commas.

 Do not use the asterisk wildcard character (*) in this
 field.

=title Task List Box
The list box identifies all the currently existing tasks
 of the program.

 The asterisk character (*) at the left of a task
 specification indicates the visible task.

 Each task's priority (a decimal integer from 0 to 15,
 inclusive) is indicated at the right of the task
 specification.

 If a task is on hold, the word HOLD is diplayed between
 the task specification and the task priority.

=title Priority Scale
Use the priority scale when setting the priority of a
 specified task.

 You can choose a (decimal) value from 0 to 15,
 inclusive.

 A task's priority is indicated in the list box, at the
 right of the task specification.

=Title Processes Dialog Box
=include debug g_ok_apply_cancel_buttons
=include debug g_multiproc
=include debug Process_Status_L_Button
=include debug Cust_Menu_Misc_Setting_Button
Note:  Use the Processes dialog box to debug a
 multiprocess program.

 Use the Processes dialog box to display information
 about processes that are currently under control of the
 debugger and to control the multiprocess environment.
 Proceed as follows:

 1.  Choose an option from the Process option menu.

 2.  Specify a process in the Process field:

      -  By default, the visible process is specified in
         this field, in the form %PROCESS_NUMBER n
         (where n is the process number assigned by the
         debugger).

      -  To specify another process, select it from the
         list box (click on the process specification),
         or type a process specification in the Process
         field.


 3.  Click on OK or Apply.

Additional information available:

proc optg process fieldg process list box

=title Process Option Menu
Use the Process option menu to:

  -  Set the visible process

  -  Put a process on hold or release a process from the
     hold state

  -  Display brief or detailed information about a
     process

  -  Terminate a process (Exit)

Additional information available:

visprochold procshowexit proc

=title Setting the Visible Process
=include debug Process_Status_L_Button
=include debug Proc_Dialog_Box proc_opt
Use the Set visible option to establish the visible
 process.  This is the process that is currently the
 context for issuing process-specific commands.  It is
 identified in the Visible Process field of the main
 window.

 When using this option, specify only one process.

 You can reset the visible process to the next or
 previous process on the debugger's list of processes by
 means of the Visible Process arrow buttons in the main
 window.

=title Holding and Releasing a Process
=include debug Proc_Dialog_Box proc_opt
Use the Hold option to put a process on hold.  This
 prevents images in that process from executing when you
 enter a Go, Step, or Call command, unless the process
 is the visible process.  A hold condition in the
 visible process is ignored.

 Use the Release option to release a process from a hold
 condition.  This permits images in that process to
 execute when you enter a Go, Step, or Call command,
 regardless of which process is the visible process.

 The word "HOLD" next to a process name in the list box
 of the Processes dialog box indicates that a process is
 on hold.  The condition is also indicated in a Show
 brief or Show detailed display chosen from the dialog
 box.

=title Displaying Process Information
=include debug Wind_Dialog_Box g_proc_windows
=include debug Cust_Menu_MPwind_Entry
=include debug Proc_Dialog_Box proc_opt
=include debug g_multiproc
 To display information about one or more processes and
 any images running in those processes, choose
 Processes...  from the Data menu, then use the Show
 brief or Show detailed options from the Processes
 dialog box.

 You must specify a process that is currently under
 debugger control (a process that is identified in the
 list box of the Processes dialog box).

 The brief display provides one line of information for
 each specified process.  For example:

   Number  Name      Hold  State    Current PC
  *    2 JONES_TWA3  HOLD  break    SCREEN\%LINE 47

 The detailed display provides several lines of
 information.

 The following information is provided in a brief
 display, starting from the left:

  -  The asterisk character (*), if displayed as in the
     previous example, marks the visible process.

  -  The Number field shows the process number assigned
     by the debugger (process 2, in the example).  A
     process number is assigned sequentially, starting
     with process 1, to each process that comes under
     debugger control.  If a process is terminated by
     choosing Exit from the Processes option menu, its
     process number is not reused during that debugging
     session.

  -  The Name field shows the VMS process name
     (JONES_TWA3, in the example).

  -  The Hold field shows the word "HOLD" if the process
     is on hold, as in the example.

  -  The State field shows the current debugging state
     for that process.  In the example, the image's
     execution is suspended at a breakpoint (break
     state).  See Debugging States for Multiprocess
     Programs.

  -  The Current PC field shows the location, symbolized
     if possible, at which execution is suspended.  It
     is suspended at line 47 of module SCREEN in the
     example.

=title Terminating a Process
=include debug Proc_Dialog_Box proc_opt
Use the Exit option to terminate one or more processes.

 After it is terminated with the Exit option, a process
 is no longer identified in the list box of the
 Processes dialog box.

 Terminating the last process ends the debugging
 session.

=title Process Field
=include debug Process_Status_L_Button
Use this field to specify one or more processes of the
 multiprocess program.

 See Specifying Processes of a Multiprocess Program for
 the syntax.

 You must specify a process that is under debugger
 control.  The list box of the Processes dialog box
 identifies all processes that are currently under
 debugger control.  Processes are listed sequentially by
 their debugger-assigned process numbers.

 By default, the visible process is specified in this
 field, in the form %PROCESS_NUMBER n (where n is the
 process number assigned by the debugger).

 When using the 'Set visible' option on the Process
 option menu, specify only one process.

 When specifying several processes, separate the
 specifications with commas.  You can use the asterisk
 wildcard character (*) to specify all processes.

=title Process List Box
=include debug Process_Status_L_Button
The list box of the Processes dialog box identifies all
 processes that are currently under debugger control.
 Processes are listed sequentially by their
 debugger-assigned process numbers.

 One line of information is provided for each process.
 For example:

    *  2  HOLD  JONES_TWA3

 The following information is provided, starting from
 the left:

  -  The asterisk character (*), if displayed as in the
     example, marks the visible process.

  -  The number indicates the process number assigned by
     the debugger (process 2, in the example).  A
     process number is assigned sequentially, starting
     with process 1, to each process that comes under
     debugger control.  If a process is terminated by
     choosing Exit from the Processes option menu, its
     process number is not reused during that debugging
     session.

  -  The word "HOLD", if displayed as in the example,
     indicates that the process is on hold.

  -  The last item shown is the VMS process name
     (JONES_TWA3, in this example).

=Title Source Window
=include debug SRC_Display_Menu_Bar

=Title Source Window Menu Bar
=include debug Disp_File_Menu_entry
=include debug Disp_Edit_Menu_Entry
=include debug SRC_Disp_Cmds_Menu_Entry
Use the pull-down menus in the source window as follows:

  -  Choose the File menu to close the window, end the
     debugging session, or terminate a process of a
     mutiprocess program (if the window is process
     specific).

  -  Choose the Edit menu to copy data selected in a
     window to the clipboard.

  -  Choose the Commands menu to view one or more
     specified lines of source code (through the View
     Source...  menu item).

=Title Commands Menu on Source Window
=include debug SRC_Disp_Cmds_Menu_View_Src
Choose View Source...  from the Commands menu to view
 one or more specified lines of source code.

=Title Commands Menu on Source Window
=include debug SRC_Disp_Cmds_Menu_View_Src
Choose View Source...  from the Commands menu to view
 one or more specified lines of source code.

=Title View Source...  Item on Commands Menu (Source Window)
=include debug Linenum_Dialog_Box
=include debug g_display_source
Choose View Source...  to view one or more specified
 lines of source code.

=Title Instruction Window
=include debug INST_Display_Menu_Bar

=Title Instruction Window Menu Bar
=include debug Disp_File_Menu_entry
=include debug Disp_Edit_Menu_Entry
=include debug INST_Disp_Cmds_Menu_Entry
Use the pull-down menus in the instruction window as
 follows:

  -  Choose the File menu to close the window, end the
     debugging session, or terminate a process of a
     mutiprocess program (if the window is process
     specific).

  -  Choose the Edit menu to copy data selected in a
     window to the clipboard.

  -  Choose the Commands menu to display the decoded VAX
     assembly-language instructions associated with a
     specified address expression.

=Title Commands Menu on Instruction Window
=include debug INST_Disp_Cmds_Menu_View_Src
Choose View Instructions...  from the Commands menu to
 display the decoded VAX assembly-language instructions
 associated with a specified address expression.

=Title Commands Menu on Instruction Window
=include debug INST_Disp_Cmds_Menu_View_Src
Choose View Instructions...  from the Commands menu to
 display the decoded VAX assembly-language instructions
 associated with a specified address expression.

=Title View Instructions...  on Commands Menu (Inst Window)
=include debug Address_Dialog_Box
=include debug g_display_instructions
Choose View Instructions...  to display the decoded VAX
 assembly-language instructions associated with a
 specified address expression.

=Title Output Window
=include debug OUT_Display_Menu_Bar
=include debug Wind_Dialog_Box g_predwnds g_out

=Title Output Window Menu Bar
=include debug Disp_File_Menu_entry
=include debug Disp_Edit_Menu_Entry
=include debug Wind_Dialog_Box g_predwnds g_out
Use the pull-down menus in the output window as follows:

  -  Choose the File menu to close the window, end the
     debugging session, or terminate a process of a
     mutiprocess program (if the window is process
     specific).

  -  Choose the Edit menu to copy data selected in a
     window to the clipboard.

=Title Register Window
=include debug REG_Display_Menu_Bar
=include debug Wind_Dialog_Box g_predwnds g_reg

=Title Register Window Menu Bar
=include debug Disp_File_Menu_entry
=include debug Disp_Edit_Menu_Entry
=include debug Wind_Dialog_Box g_predwnds g_reg
Use the pull-down menus in the register window as
 follows:

  -  Choose the File menu to close the window, end the
     debugging session, or terminate a process of a
     mutiprocess program (if the window is process
     specific).

  -  Choose the Edit menu to copy data selected in a
     window to the clipboard.

=Title Automatic Window
=include debug AUTO_Display_Menu_Bar
=include debug Wind_Dialog_Box g_predwnds g_auto

=Title Automatic Window Menu Bar
=include debug Disp_File_Menu_Entry
=include debug Disp_Edit_Menu_Entry
=include debug AUTO_Disp_Cmds_Menu_Entry
=include debug Wind_Dialog_Box g_predwnds g_auto
Use the pull-down menus in the automatic window as
 follows:

  -  Choose the File menu to close the window, end the
     debugging session, or terminate a process of a
     mutiprocess program (if the window is process
     specific).

  -  Choose the Edit menu to copy data selected in a
     window to the clipboard.

  -  Choose the Commands menu to add or delete an
     Examine command to or from the command list for the
     automatic window.

=Title Commands Menu on Automatic Window
=include debug AUTO_Disp_Cmds_Menu_Add_Sele
=include debug AUTO_Disp_Cmds_Menu_Del_Sele
=include debug Wind_Dialog_Box g_predwnds g_auto
=include debug Cust_Menu_Windows_Button
Use the Commands menu to add or delete an Examine
 command to or from the command list for the automatic
 window.

 The command is added or deleted by selecting text from
 a window.  This is a quick alternative to using the
 Windows...  item on the Customize menu.

=Title Commands Menu on Automatic Window
=include debug AUTO_Disp_Cmds_Menu_Add_Sele
=include debug AUTO_Disp_Cmds_Menu_Del_Sele
=include debug Wind_Dialog_Box g_predwnds g_auto
=include debug Cust_Menu_Windows_Button
Use the Commands menu on the automatic window as
 follows:

  -  Choose Add Selected to add an Examine command to
     the command list that is associated with the
     automatic window

  -  Choose Delete Selected to delete an Examine command
     from the command list

 The command to be added or deleted is specified by
 selecting text from a window.

 When you want to add or delete an Examine command (as
 opposed to other commands), this technique is a quick
 alternative to the more general procedure for modifying
 an automatic window:

 1.  Choose Windows...  from the Customize menu.  A
     dialog box is displayed.

 2.  Specify the automatic window in the Window field.

 3.  Add or delete the command to or from the command
     list that is currently specified in the Action
     field.

=Title Add Selected Item on Commands Menu (Auto Window)
=include debug Wind_Dialog_Box g_predwnds g_auto
=include debug g_cmd_mode
=include debug Cust_Menu_Windows_Button
Choose Add Selected to add an Examine command to the
 command list that is associated with the automatic
 window.

 You specify the entity to be examined by selecting text
 in a window.  The entity is typically a variable name,
 but it may be any symbolic address expression that is
 declared in the program being debugged (for example, a
 routine name).

 For example, proceed as follows to add an Examine
 Variable command:

 1.  Select the variable name from any window, using the
     syntax of the source language.  For example,
     selecting ARR[4] specifies element 4 of array ARR
     in some languages.

 2.  Click on Add Selected from the automatic window's
     Commands menu.  The Examine command is
     automatically appended to the current command list
     associated with the automatic window.

 When you want to add an Examine command (as opposed to
 some other command), this technique is a quick
 alternative to the more general procedure for modifying
 an automatic window:

 1.  Choose Windows...  from the Customize menu.  A
     dialog box is displayed.

 2.  Specify the automatic window in the Window field.

 3.  Add the Examine command to the command list that is
     currently specified in the Action field.

 You can verify the effect of using Add Selected by
 looking at the command list in the Action field of the
 Windows dialog box (when the automatic window is
 specified in the Window field).  The debugger
 automatically precedes the appended command with the
 semicolon (;) command separator.

=Title Delete Selected Item on Commands Menu (Auto Window)
=include debug Wind_Dialog_Box g_predwnds g_auto
=include debug g_cmd_mode
=include debug Cust_Menu_Windows_Button
Choose Delete Selected to delete an Examine command from
 the command list that is associated with the automatic
 window.

 You specify the command to be deleted by selecting any
 part of the command's output in the automatic window.

 Proceed as follows to delete an Examine command:

 1.  Select any part of the Examine command's output
     from the automatic window.

 2.  Click on Delete Selected from the automatic
     window's Commands menu.  The Examine command is
     automatically deleted from the current command list
     associated with the automatic window.

 Note that you cannot modify a command when you use
 Delete Selected.  You can only delete a command.  For
 example, you cannot modify a command that examines an
 entire array variable into a command that examines only
 certain array elements, by selecting only part of the
 output.

 When you want to delete an Examine command (as opposed
 to some other command), this technique is a quick
 alternative to the more general procedure for modifying
 an automatic window:

 1.  Choose Windows...  from the Customize menu.  A
     dialog box is displayed.

 2.  Specify the automatic window in the Window field.

 3.  Delete the Examine command from the command list
     that is currently specified in the Action field.

 You can verify the effect of using Delete Selected by
 looking at the command list in the Action field of the
 Windows dialog box (when the !automatic window is
 specified in the Window field).  The debugger
 automatically deletes the semicolon (;) command
 separator along with command.

=Title File Menu (Source, Output, Auto, Inst, Reg, Windows)
=include debug Disp_File_Menu_Close_Button
=include debug Disp_File_Menu_Quit_Button
=include debug Disp_File_Menu_Exit_Button
Use the File menu as follows:

  -  Choose Close Window to close the window.

  -  Choose Quit to end the debugging session or
     terminate a process, with the option of also
     executing any exit handlers that are declared in
     the exiting image.

  -  Choose Exit to end the debugging session or
     terminate a process, also executing any exit
     handlers that are declared in the exiting image.

 If an exit handler is declared in your program, a
 dialog box gives you the option of executing that
 handler when you choose Quit.

=Title File Menu (Source, Output, Auto, Inst, Reg, Windows)
=include debug Disp_File_Menu_Close_Button
=include debug Disp_File_Menu_Quit_Button
=include debug Disp_File_Menu_Exit_Button
Use the File menu as follows:

  -  Choose Close Window to close the window.

  -  Choose Quit to end the debugging session or
     terminate a process, with the option of also
     executing any exit handlers that are declared in
     the exiting image.

  -  Choose Exit to end the debugging session or
     terminate a process, also executing any exit
     handlers that are declared in the exiting image.

 If an exit handler is declared in your program, a
 dialog box gives you the option of executing that
 handler when you choose Quit.

=Title Close Window Item on File Menu
Choose Close Window to close the window.

=Title Quit Item on File Menu
=include debug Disp_File_Menu_Exit_Button
Choose Quit to perform the following functions, with the
 option of also executing any exit handlers that are
 declared in the exiting image:

  -  For a one-process program:  end the debugging
     session.

  -  For a multiprocess program:  if the window is not
     process specific, terminate the visible process.

     If the window is process specific, terminate the
     process that is associated with the window.

 If an exit handler is declared in your program, a
 dialog box gives you the option of executing that
 handler when you choose Quit.

=Title Exit Item on File Menu
=include debug Disp_File_Menu_Quit_Button
Choose Exit to perform the following functions, also
 executing any exit handlers that are declared in the
 exiting image:

  -  For a one-process program:  end the debugging
     session.

  -  For a multiprocess program:  if the window is not
     process specific, terminate the visible process.

     If the window is process specific, terminate the
     process that is associated with the window.

=Title Edit Menu (Source, Output, Auto, Inst, Reg, Windows)
=include debug Disp_Edit_Menu_Copy_Button
Choose Copy from the Edit menu to copy data selected in
 a window to the clipboard.

=Title Edit Menu (Source, Output, Auto, Inst, Reg, Windows)
=include debug Disp_Edit_Menu_Copy_Button
Choose Copy from the Edit menu to copy data selected in
 a window to the clipboard.

=Title Copy Item on Edit Menu
Choose Copy to copy data selected in a window to the
 clipboard.

=Title Clear Item on Edit Menu
Choose Clear to clear data from the clipboard.

=Title Using the Pop-up Menu
To use the pop-up menu, proceed as follows:

 1.  Position the pointer cursor within a debugger
     window.

 2.  Press and hold MB2 to display the pop-up menu, then
     drag to the desired menu item and release MB2.

 The debugger's pop-up menu enables you to perform some
 common debugger operations without having to pull down
 a menu in the main window.

 Note that the behavior of the Examine, Evaluate, and
 Set Break menu items depends on whether you selected
 text before invoking the pop-up menu.

Additional information available:

g examineg evaluateg step intog step overg step returng step instruction
g step lineg breakg view curlocg go

=title Examine Item on Pop-Up Menu
=include debug g_specifying_variables
=include debug Examine_Status_L_Button
=include debug Ex_Vbl_Dialog_box g_examine_var
=include debug Data_Menu_Variables_Entry
=include debug Data_Menu_Code_Entry
=include debug Data_Menu_Addresses_Entry
=include debug Ex_Code_Dialog_Box g_display_instructions
=include debug g_display_predwnds
=include debug Examine_Button
=include debug The_Popup_Menu
 Choose Examine to display the current value of a
 variable or other symbolic address expression.

 To examine a variable, proceed as follows:

 1.  Select the variable name from any window, observing
     the syntax of the source language.  For example,
     selecting ARR[4] specifies element 4 of array ARR
     in some languages.

 2.  Press MB2 to display the pop-up menu, then choose
     Examine from the menu.

 The debugger displays the value of the selected
 variable in the current output window (window OUT, by
 default).

 If no entity is currently selected, Examine displays
 the value of the entity last examined or deposited into
 (if any).  This entity is identified in the Current
 Entity field of the main window.

 To display the value associated with an arbitrary
 address expression, choose Variables, Code, or
 Addresses or Registers from the Data menu (then choose
 the Examine item from the associated submenu).

 If you examine a routine name (or any other symbolic
 address expression that is associated with code---that
 is, VAX assembly-language instruction), the output is
 displayed as follows:

  -  If an instruction window with the instruction
     attribute is displayed, the first instruction for
     the specified address expression is centered and
     boxed in the window.

  -  If no instruction window has the instruction
     attribute, the first instruction for the specified
     address expression is displayed in the current
     output window (window OUT, by default).

 Note:  By default, the predefined instruction window
 INST is not displayed and does not have the instruction
 attribute.  See Displaying the Predefined Windows INST,
 REG, and AUTO.

=title Evaluate Item on Pop-Up Menu
=include debug g_langexpr
=include debug Data_Menu_Express_Button
=include debug The_Popup_Menu
 Choose Evaluate to display the value of a language
 expression that you have selected in a window.

 Proceed as follows:

 1.  Select a language expression (such as X + 5) from a
     window.

 2.  Press MB2 to display the pop-up menu, then choose
     Evaluate from the menu.

 The debugger evaluates the language expression in the
 currently set language and displays the resulting value
 in the current output window (window OUT, by default).

 If no entity is currently selected, the value last
 examined or evaluated by an examine, evaluate, or
 deposit operation (if any) is displayed.  This is the
 value currently defined by the built-in symbol %CURVAL.

 To evaluate an arbitrary language expression, choose
 Language Expressions...  from the Data menu in the main
 window.

=title Step Into Routine Item on Pop-Up Menu
=include debug Step_Dialog_Box g_step
=include debug step_button
=include debug Ctrl_Menu_Step_Button
=include debug The_Popup_Menu g_step_over
=include debug The_Popup_Menu
 If execution is currently suspended at a routine call,
 choose Step Into Routine to execute the program up to
 the start of that routine.  This enables you to step
 into, and then through, the called routine.

 If execution is not suspended at a routine call, Step
 Into Routine executes one default step unit, as if you
 had clicked on the Step button in the main window.  A
 default step unit is one line of source code, unless
 another default step unit was established by choosing
 Step...  from the Control menu in the main window.

=title Step Over Routine Item on Pop-Up Menu
=include debug Step_Dialog_Box g_step
=include debug step_button
=include debug Ctrl_Menu_Step_Button
=include debug The_Popup_Menu g_step_into
=include debug The_Popup_Menu
 If execution is currently suspended at a routine call,
 choose Step Over Routine to execute the called routine
 up to and including the routine's RET instruction (step
 over the routine).  This is the default behavior of the
 Step command.

 If execution is not suspended at a routine call, Step
 Over Routine executes one default step unit, as if you
 had clicked on the Step button in the main window.  A
 default step unit is one line of source code, unless
 another default step unit was established by choosing
 Step...  from the Control menu in the main window.

=title Step To Return Item on Pop-Up Menu
=include debug Step_Dialog_Box g_step
=include debug step_button
=include debug Ctrl_Menu_Step_Button
=include debug The_Popup_Menu
 Choose Step To Return to execute the program to the
 return (RET) instruction of the routine in which
 execution is currently suspended; that is, up to the
 point just prior to transferring control back to the
 calling routine.  This enables you to inspect the local
 environment (for example, obtain the values of local
 variables) before the RET instruction deletes the
 routine's call frame from the call stack.

=title Step By Instruction Item on Pop-Up Menu
=include debug Step_Dialog_Box g_step
=include debug step_button
=include debug Ctrl_Menu_Step_Button
=include debug g_display_instructions
=include debug The_Popup_Menu
 Choose Step By Instruction to execute the program to
 the next VAX assembly-language instruction encountered
 during program execution.

=title Step By Line Item on Pop-Up Menu
=include debug Step_Dialog_Box g_step
=include debug step_button
=include debug Ctrl_Menu_Step_Button
=include debug The_Popup_Menu
 Choose Step By Line to execute the program to the start
 of the next executable source line encountered during
 program execution.

 When used to execute the program in units of one or
 more source lines, the Step command executes one or
 more executable lines at a time, skipping over any
 other lines.  Executable lines are those for which
 instructions were generated by the compiler (for
 example, lines with routine calls or assignment
 statements).  Examples of nonexecutable lines are
 comment lines or lines with variable declarations
 without value assignments.

=title Set Break Item on Pop-Up Menu
=include debug Break_Dialog_Box g_breaktrace
=include debug Ctrl_Menu_Breakpoint_Button
=include debug The_Popup_Menu
 Choose Set Break to suspend execution at a location in
 your program (a breakpoint).

 The pop-up menu provides two options for quickly
 setting a breakpoint:

  -  To set a breakpoint on a line that you have
     selected in a window, proceed as follows:

     1.  Select a line in a source or instruction window

     2.  Press MB2 to display the pop-up menu, then
         choose Set Break from the menu


  -  To set a breakpoint on the line at which execution
     is currently suspended, proceed as follows:

     1.  Check that no text is selected within a source
         or instruction window

     2.  Press MB2 to display the pop-up menu, then
         choose Set Break from the menu


 When selecting a breakpoint location in a window, note
 the following points:

  -  Make the selection in a debugger source or
     instruction window, or in a window of another
     application that provides the same source
     correlation context (for example, an LSEDIT editor
     window).

  -  You can select any portion of a source line, but
     the line must result in executable code (VAX
     assembly-language instructions).  For example, a
     line that contains a routine declaration, routine
     call, assignment statement, or label results in
     executable code.

  -  If you select a source line that is not associated
     with code (for example, a comment line), the
     debugger issues a diagnostic message that
     identifies the previous or next executable line.

  -  If you select text in a window other than a source,
     instruction, or equivalent window (with source
     correlation context), the breakpoint is set on the
     line at which execution is currently suspended, as
     if no text had been selected.

 To set breakpoints on other locations, classes of
 instructions, or events, choose Break...  from the
 Control menu in the main window.

=title View Current Location Item on Pop-Up Menu
=include debug g_display_source
=include debug g_display_instructions
=include debug Scopes_Status_L_Button
=include debug The_Popup_Menu
 Choose View Current Location to display the source line
 or the decoded VAX assembly-language instruction at
 which execution is suspended in the current scope.

 The source line is centered and boxed in the current
 source window (the window with the source attribute).
 This is window SRC, by default.

 If an instruction window with the instruction attribute
 is displayed, the instruction is centered and boxed in
 the window.  If no window has the instruction
 attribute, the instruction is identified in the current
 output window (window OUT, by default).

 By default, the predefined instruction window INST is
 not displayed and does not have the instruction
 attribute.  See Displaying the Predefined Windows INST,
 REG, and AUTO.

 If the Call Frame field in the main window indicates a
 call frame other than 0, clicking on View Current
 Location displays the source code or instructions for
 that routine, and the boxed line identifies the call to
 the next routine up the call stack.  In such cases, to
 display the current location in the routine at the top
 of the call stack, click on the Call Frame up-arrow
 button until call frame 0 is displayed in the Call
 Frame field.

 If the debugger cannot locate source code for display,
 it tries to display source code in the next routine
 down on the call stack for which source code is
 available.  If the debugger can display source code for
 such a routine, it issues the following message:

    SOURCESCOPE, Source lines not available for .0\%PC.
      Displaying source in a caller of the current routine.

 In such cases, the boxed line in the source window
 identifies the line that contains code following the
 call statement in the calling routine.

=title Go Item on Pop-Up Menu
=include debug Go_Dialog_Box g_go
=include debug go_button
=include debug Ctrl_Menu_Go_Button
=include debug The_Popup_Menu
 Choose Go to start program execution from the current
 location.

 To start execution from another location, choose Go...
 from the Control menu in the main window and then
 specify the location in the Go dialog box.

=Title 'Execute Exit Handlers Upon Exit' Caution Box
=include debug Disp_File_Menu_Entry
=include debug Data_Menu_Handlers_Button
If your program contains application-declared exit
 handlers, you are asked whether to execute the exit
 handlers when you choose Quit to exit the debugger.

 If you choose Exit rather than Quit, any
 application-declared exit handlers are executed upon
 exiting the debugger.

 =Title Message Box

=Title 'Not yet implemented' Feature
=title Maximum Length Of A DECwindows Title With .RM+6
 ----> =title Maximum Length Of A DECwindows Title With
 .RM+0>