»}.Function Key Definitions
════════════════════════
   <F1>       =  Help
   <F2>       =  Run    => Continue
   <F3>       =  Run    => Step
   <F4>       =  Run    => Go
   <F5>       =  Debug  => Call Stack
   <F6>       =  View   => Current Location
   <F7>       =  Toggle breakpoint at cursor
   <F8>       =  View   => User Screen
   <F9>       =  Debug  => List Breakpoints
   <F10>      =  System => Exit 


Menu Access
═══════════
  <Alt S>     =  Open System  menu
  <Alt V>     =  Open View    menu
  <Alt R>     =  Open Run     menu
  <Alt D>     =  Open Debug   menu
  <Alt O>     =  Open Options menu
  <Alt H>     =  Open  Help window
  <> <>     =  Move highlight bar up/down menu
  <Enter>     =  Perform selected menu function
  <Esc>       =  Close a menu 


Window Access
═════════════
  <Alt 1>     =  Switch to Source Window
  <Alt 2>     =  Switch to Dialog Window
  <Alt 3>     =  Switch to Command Window
  <> <>     =  Move cursor up/down one line
  <Esc>       =  Close Breakpoint, Help, & File Windows
  <PgUp>      =  Move up one page
  <PgDn>      =  Move down one page
  <Tab>       =  Move cursor to next data entry field
  <Alt X>     =  Exit MADE 


Command and Data Entry Editing
══════════════════════════════
  <>         =  Move cursor left one column
  <>         =  Move cursor right one column
  <Ctrl >    =  Move cursor left one word
  <Ctrl >    =  Move cursor right one word
  <Home>      =  Move cursor to beginning of line
  <End>       =  Move cursor to end of line
  <Backspace> =  Delete previous character
  <Del>       =  Delete current character
  <Ins>       =  Toggle Insert/Overstrike mode 


Debugger Command Action Keys
════════════════════════════
  <>         =  Retrieve previous command
  <>         =  Retrieve next command
  <Enter>     =  Execute command 


Data Entry Action Keys
══════════════════════
  <Esc>       =  Abort debugger function
  <Enter>     =  Accept data as entered 


Using the Mouse for Accessing Windows
═════════════════════════════════════
Click the left mouse button over a given window to select that window as the current one.  Also use the left button to access the scroll  bar in the Dialog Window.  Click the right button to close the  Breakpoint, Help, or File Windows. 


Using the Mouse for Accessing Menus
═══════════════════════════════════
Click the left mouse button over the menu bar to open a menu.  Click  the left mouse button again over a given menu selection to perform  that function.  Click the right mouse button to close menu opened  with left button.  Also, use the right mouse button to abort a Data  Entry function. 


Issuing MADE Functions and Commands
═══════════════════════════════════
Debugger actions can be selected from the menus or entered in the Command Window.  If a debugger function is selected from the menus, any necessary arguments are entered in a Data Entry Window.  While entering arguments, <Esc> or Right mouse button aborts the function. 

If a debugger command is entered in the Command Window, any necessary arguments must be enclosed in ( ) and separated by commas as in Ada subprogram calls. 

NOTE: Local variable names take precedence over debugger commands that you issue from the Command Window.  To issue a debugger command having the same name as a local variable, use: 

    debug.[command-name] 

as in "debug.ss". 


MADE Menu Functions and Debug Commands
══════════════════════════════════════
System => Dos Shell
    Invokes a DOS sub-shell. 

    Debug Command:  execute 

System => About...
    Displays information about MADE. 

System => Exit
    Terminates the current debugging session and
    returns to DOS. 

    Debug Command:  quit 

View => Source
    Switches to the Source Window at the top of the
    screen. 

View => Dialog
    Switches to the Dialog Window in the middle of the
    screen. 

View => Command
    Switches to the Command Window at the bottom of
    the screen. 

View => File
    Lets you choose a file whose text is then displayed
    in its own window.  Use the <Tab> key to move to the
    various fields in the File Selection Window.  Type
    the <Esc> key to close the File Window. 

View => Variable
    Displays the current value of the specified
    variable. 

    Debug Command:  <variable> 

View => Current Location
    Displays in the Source Window the line where
    execution is currently suspended. 

    Debug Command:  where 

View => User Screen
    Switches to the user screen where the current
    output from your program is displayed.  Type any
    character to return to the debugger screen. 

View => SubProgram
    Displays the code for the specified subprogram in
    the Source Window. 

    Debug Command:  print(<subprogram>) 

Run => Continue
    Continues execution from a breakpoint. 

    Debug Command:  c 

Run => Go
    Executes the next line in the current subprogram.
    This function is slightly different from the Step
    function as it skips over a subprogram call, while
    the Step function steps into the call. 

    Debug Command:  go 

Run => Go to Line
    Continues execution from a breakpoint until the
    specified line (within the current subprogram) is
    reached.  Two lines may be specified (separated by
    a comma) in which case execution stops whenever
    either line is reached. 

    A go function never executes past the end of the
    current subprogram, unless the current breakpoint
    is already at the end of a subprogram. 

    Debug Command:  go(<line #> [,<alternate line #>]) 

Run => Step
    Executes a single program step which typically
    causes the next line of code to be executed.  If a
    subprogram call is executed, the program is
    suspended at the start of the called subprogram. 

    Debug Command:  ss 

Run => Trace
    Sets a tracepoint in the specified subprogram
    which causes the debugger to display a message
    whenever the subprogram is called and when it
    returns. 

    Debug Command:  trace(<subprogram>) 

Run => Untrace
    Deletes a previously set tracepoint in the
    specified subprogram. 

    Debug Command:  untrace(<subprogram>) 

Run => Trace All
    Causes all subprograms to be traced so you can see
    when each subprogram is called and when it
    returns. 

    Debug Command:  traceall 

Run => Untrace All
    Cancels the effect of the Trace All function. 

    Debug Command:  untraceall 

Debug => Task Break
    When on, causes a debugger breakpoint to occur at
    each task context switch. 

    Debug Command:  taskbreak(<boolean>) 

Debug => Exception Break
    When on, causes a debugger breakpoint to occur
    whenever an exception is raised by the program. 

    Debug Command:  excbreak(<boolean>) 

Debug => Breakpoints
    Displays a list of the current breakpoints and
    then provides the following sub-menu functions: 

	Close     - close Breakpoint Window
	Add       - create a new breakpoint
	Delete    - delete an existing breakpoint
	Clear All - delete all breakpoints 

    Use the <Tab> key to select the desired breakpoint
    to clear from the breakpoint list. 

    When you add a breakpoint, in addition to specifying
    the line number, you can give one or more debugger
    commands (separated by semicolons ;) that will be
    performed just before that line is executed.  Often
    such a command is used to display the current value
    of a variable.  A breakpoint with an added command
    does not actually suspend the program at that point
    unless one of the added commands is the special
    "stop" command.  The "stop" command can be used in
    combination with the special "when" command to
    define a conditional breakpoint.  For example, to
    suspend the program when variable count is greater
    than 10 use "when(count > 10) stop". 

Debug => List Breakpoints
    Lists all previously set breakpoints, tracepoints
    and watches. 

    Debug Command:  list 

Debug => Call Stack
    Prints a "stack trace".  Information is displayed
    about the state of the call stack, which includes
    which subprograms have been called and with what
    parameter values. 

    Debug Command:  stack 

Debug => Dump
    When given a package or subprogram name, prints
    the values of all its variables and lists the
    names of all its subprograms. 

    Debug Command:  dump(<subprogram-or-package>) 

Debug => Dump All
    Displays the values of all local variables and
    subprograms in active subprograms followed by all
    global variables and subprograms in all units. 

    Debug Command:  dumpall 

Debug => Watch
    Monitors the value of the specified variable.
    When the value of this variable changes, a message
    is printed showing the original value of the
    variable and its new value, and a breakpoint
    occurs. 

    Debug Command:  watch(<variable>) 

Debug => Unwatch
    Deletes a previously set debugger watch over the
    specified variable. 

    Debug Command:  unwatch(<variable>) 

Options => Source Path
    Tells the debugger to search for source files in
    the specified directory path.  The debugger always
    searches the current directory first. 

    Debug Command:  source 

Options => Display 43/50
    Toggles the display between the standard 25 lines
    per screen and 43 (or 50) lines per screen
    depending on the type of monitor and video display
    adaptor your system has.  Note that not all PC
    systems have this capability. 

Help
    Displays the on-line help information in a special
    Help Window.  Type the Esc key to close the Help
    Window and return to debugging. 

    Debug Command:  help 


Additional MADE Commands
════════════════════════
Here are some additional MADE debugger commands that can be issued from the Command Window. 

<variable> := <expression>
    Assigns the value of the <expression> to the
    <variable>. 

<subprogram> [ ( <arg1>, <arg2> ... ) ]
    User subprogram is called with given arguments.
    If a function, its return value is displayed. 

autoskip(<boolean>)
    If set to true, causes the debugger single step
    function not to stop on lines for which no source
    code is available but to continue execution until
    a point is reach where the source code is
    available.  This is particularly useful when
    stepping through calls to subprograms instantiated
    from generic packages in text_io. 

execute(<string>)
    Invokes a DOS sub-shell which executes the DOS
    command given by the string parameter.  Note that
    the string must be enclosed in double quotes (""). 

settaskname(<task> [, <new-name>])
    Sets the "print name" of the specified task to be
    the specified string new-name.  If no new-name is
    specified, the current name is printed.  Useful
    for defining meaningful names for tasks declared
    as components of records or arrays or allocated
    via an access type. 


Differences Between the Meridian Debuggers
══════════════════════════════════════════
MADE does not support identifier completion and the special intra-line editing commands. 

MADE command history is not remembered across debugging sessions (no debug.hst file is created). 

MADE does not support the following line-oriented debugger commands: 

    at
    breakp
    find
    more
    raw
    set_input
    set_output
    silence
    unbreakp 

In MADE all line numbers are relative to the beginning of a source file whereas in the line-oriented debugger all line numbers are relative to the beginning of a subprogram. 
s.General Help