The EXIT command ends a debugging session,  or  releases  one  or
     more  processes  of a multiprocess program from debugger control,
     allowing any user-declared exit handlers to run.

     If used within a command procedure or DO clause and no process is
     specified,  the  EXIT  command  exits the command procedure or DO
     clause at that point.

     The EXIT command is one of the four debugger  commands  that  can
     cause  your  program  to  execute  (the  others are CALL, GO, and
     STEP).

 Format:

       EXIT  [process-spec[, . . . ]]

Additional information available:

Ending Debugging SessionExiting Command ProceduresReleasing Processes
ExamplesParameters

     To end a  debugging  session,  enter  the  EXIT  command  at  the
     debugger  prompt  without specifying any parameters.  This causes
     orderly termination of the session:  the program's  user-declared
     exit handlers (if any) are executed, the debugger exit handler is
     executed (closing log files,  restoring  the  screen  and  keypad
     states,  and  so  on),  and  control  is  returned to the command
     interpreter.  You cannot then continue to debug your  program  by
     entering  the  DCL  commands  DEBUG  or CONTINUE.  To restart the
     debugger, you must run the program again.

     Note that, since EXIT runs any user-declared exit  handlers,  you
     can  set  breakpoints  in such exit handlers, and the breakpoints
     are triggered upon typing EXIT.  EXIT can thus be used  to  debug
     your exit handlers.

     To end a debugging session without running any user-declared exit
     handlers, use the QUIT command instead of EXIT.

     When  the  debugger  executes  an  EXIT  command   (without   any
     parameters)  in  a  command  procedure,  control  returns  to the
     command stream that invoked the  command  procedure.   A  command
     stream  can  be  the  terminal,  an  outer  (containing)  command
     procedure, or  a  DO  clause  in  a  command  or  screen  display
     definition.   For  example,  if the command procedure was invoked
     from within a DO clause, control returns to that DO clause, where
     the  debugger  executes  the  next  command (if any remain in the
     command sequence).

     When  the  debugger  executes  an  EXIT  command   (without   any
     parameters)  in a DO clause, it ignores any remaining commands in
     that clause and displays its prompt.

     If you are using  the  multiprocess  debugging  configuration  to
     debug a multiprocess program (if the logical name DBG$PROCESS has
     the value MULTIPROCESS), you can use the EXIT command to  release
     selected  processes  from  debugger  control  without  ending the
     debugging session.   The  same  techniques  and  behavior  apply,
     whether you enter the EXIT command at the prompt or use it within
     a command procedure or DO clause.

     To release one or more processes from debugger control, enter the
     EXIT  command,  specifying  these  processes as parameters.  This
     causes orderly termination of  the  images  in  these  processes,
     executing  any  user-declared exit handlers associated with these
     images.  Subsequently, the  specified  processes  are  no  longer
     identified  in  a  SHOW  PROCESS/ALL  display.   If any specified
     processes were on HOLD, as  the  result  of  a  SET  PROCESS/HOLD
     command, the HOLD condition is ignored.

     When the specified  processes  begin  to  exit,  any  unspecified
     process  that is not on HOLD begins execution.  Once execution is
     started, the way in which it continues  depends  on  whether  the
     command  SET  MODE  [NO]INTERRUPT  was  entered  previously.   By
     default (SET MODE INTERRUPT), execution  continues  until  it  is
     suspended   in   any   process.   At  that  point,  execution  is
     interrupted in any other processes that  were  executing  images,
     and the debugger prompts for input.

     To release  selected  processes  from  debugger  control  without
     running  any  user-declared  exit  handlers or otherwise starting
     execution, use the QUIT command instead of EXIT.

     1   DBG> EXIT
         $

     This command ends the debugging session and returns  you  to  DCL
     command level.

     2   JONES_1> EXIT %NEXT_PROCESS, %PROCESS_NAME JONES_3, %PROC 5
         JONES_1>

     This command causes orderly termination of three processes  of  a
     multiprocess program:  the next process after the visible process
     on the process list, process JONES_3, and process 5.  Control  is
     returned  to  the  debugger  after  the  specified processes have
     exited.

 process-spec

     Note:   This  parameter  applies  to  a  multiprocess   debugging
     configuration (when DBG$PROCESS has the value MULTIPROCESS).

     Specifies a process.  Use any of the following forms:

     [%PROCESS_NAME] process-name    The VMS process name, if that
                                     name contains no spaces or
                                     lowercase characters[1].

     [%PROCESS_NAME] "process-name"  The VMS process name, if that
                                     name contains spaces or lowercase
                                     characters. You can also use
                                     apostrophes (') instead of
                                     quotation marks (").

     %PROCESS_PID process_id         The VMS process identification
                                     number (PID, a hexadecimal number).

     %PROCESS_NUMBER process-number  The number assigned to a process
     (or %PROC process-number)       when it comes under debugger control.
                                     Process numbers appear in a
                                     SHOW PROCESS display.

     process-group-name              A symbol defined with the
                                     DEFINE/PROCESS_GROUP command to
                                     represent a group of processes.

     %NEXT_PROCESS                   The next process in the debugger's
                                     circular process list after the
                                     visible process.

     %PREVIOUS_PROCESS               The previous process in the
                                     debugger's circular process list
                                     before the visible process.

     %VISIBLE_PROCESS                The process whose stack, register
                                     set, and images are the current
                                     context for looking up symbols,
                                     register values, routine calls,
                                     breakpoints, and so on.
     _______________________________________________________
     [1]The process name can include the asterisk wildcard
     character (*)

     You can also use the asterisk wilcard character  (*)  to  specify
     all processes.