The QUIT command ends a debugging session,  or  releases  one  or
     more processes of a multiprocess program from debugger control.

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

     The QUIT command is like the EXIT command, except that QUIT  does
     not  cause  your  program  to  execute  and,  therefore, does not
     execute any user-declared exit handlers in your program.

 Format:

       QUIT  [process-spec[, . . . ]]

Additional information available:

Ending Debugging SessionExiting Command ProceduresReleasing Processes
ExamplesParameters

     To end a  debugging  session,  enter  the  QUIT  command  at  the
     debugger  prompt  without specifying any parameters.  This causes
     orderly termination of the session:  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.

     When  the  debugger  executes  a  QUIT   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  a  QUIT   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 QUIT command to  release
     selected  processes  from  debugger  control  without  ending the
     debugging session.   The  same  techniques  and  behavior  apply,
     whether you enter the QUIT 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
     QUIT  command,  specifying  these  processes as parameters.  This
     causes orderly termination  of  the  images  in  these  processes
     without executing any user-declared exit handlers associated with
     these images.   Subsequently,  the  specified  processes  are  no
     longer identified in a SHOW PROCESS/ALL display.

     In contrast to the EXIT command, the QUIT command does not  cause
     any process to start execution.

     1   DBG> QUIT
         $

     This command, when entered from the prompt,  ends  the  debugging
     session and returns you to DCL command level.

     2   JONES_1> QUIT %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.