Ends a debugging session, or terminates one or more processes of
    a multiprocess program (similar to EXIT), but without allowing
    any application-declared exit handlers to run. If used within a
    command procedure or DO clause and no process is specified, it
    exits the command procedure or DO clause at that point.

    Format

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

1  –  Parameters

 process-spec

    (Kept debugger only.) Specifies a process currently under
    debugger control. Use any of the following forms:

    [%PROCESS_NAME] process-  The process name, if that name does not
    name                      contain spaces or lowercase characters.
                              The process name can include the
                              asterisk (*)  wildcard character.
    [%PROCESS_NAME]           The process name, if that name contains
    "process-name "           spaces or lowercase characters. You
                              can also use apostrophes (') instead of
                              quotation marks (").
    %PROCESS_PID process_id   The process identifier (PID, a
                              hexadecimal number).
    [%PROCESS_NUMBER]         The number assigned to a process when
    process-number            it comes under debugger control. A
    (or %PROC process-        new number is assigned sequentially,
    number)                   starting with 1, to each process. If
                              a process is terminated with the EXIT
                              or QUIT command, the number can be
                              assigned again during the debugging
                              session. Process numbers appear in a
                              SHOW PROCESS display. Processes are
                              ordered in a circular list so they can
                              be indexed with the built-in symbols
                              %PREVIOUS_PROCESS and %NEXT_PROCESS.
    process-set-name          A symbol defined with the
                              DEFINE/PROCESS_SET command to represent
                              a group of processes.
    %NEXT_PROCESS             The next process after the visible
                              process in the debugger's circular
                              process list.
    %PREVIOUS_PROCESS         The process previous to the visible
                              process in the debugger's circular
                              process list.
    %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.

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

2  –  Description

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

    Ending a Debugging Session:

    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 DCL level. You
    cannot then continue to debug your program by entering the DCL
    command DEBUG or CONTINUE (you must restart the debugger).

    Using the QUIT Command in Command Procedures and DO Clauses:

    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.

    Terminating Specified Processes:

    If you are debugging a multiprocess program, you can use the
    QUIT command to terminate specified processes 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 terminate one or more processes, enter the QUIT command,
    specifying these processes as parameters. This causes orderly
    termination of the images in these processes without executing
    any application-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.

    Related commands:

       DISCONNECT
       @ (Execute Procedure)
       Ctrl/C
       Ctrl/Y
       Ctrl/Z
       EXIT
       RERUN
       RUN
       SET ABORT_KEY
       SET PROCESS

3  –  Examples

    1.DBG> QUIT
      $

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

    2.all> QUIT %NEXT_PROCESS, JONES_3, %PROC 5
      all>

      This command causes orderly termination of three processes of
      a multiprocess program: the 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.