?? RIGHT := 110 ??                                                                                            
?? NEWTITLE := 'NOS/VE Dump Analyzer : Quit Command' ??                                                       
MODULE dum$quit_command;                                                                                      
                                                                                                              
{ PURPOSE:                                                                                                    
{   This module contains the code for the quit command.                                                       
                                                                                                              
?? NEWTITLE := 'Global Declarations Referenced by This Module', EJECT ??                                      
?? PUSH (LISTEXT := ON) ??                                                                                    
*copyc duc$dump_analyzer_constants                                                                            
?? POP ??                                                                                                     
*copyc clp$end_include                                                                                        
*copyc clp$evaluate_parameters                                                                                
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'dup$quit_command', EJECT ??                                                                   
                                                                                                              
{ PURPOSE:                                                                                                    
{   This procedure contains the command to exit the analyze_dump utility.                                     
                                                                                                              
  PROCEDURE [XDCL] dup$quit_command                                                                           
    (    parameter_list: clt$parameter_list;                                                                  
     VAR status: ost$status);                                                                                 
                                                                                                              
{ PROCEDURE quit, qui (                                                                                       
{   status)                                                                                                   
                                                                                                              
?? PUSH (LISTEXT := ON) ??                                                                                    
?? FMT (FORMAT := OFF) ??                                                                                     
  VAR                                                                                                         
    pdt: [STATIC, READ, cls$declaration_section] record                                                       
      header: clt$pdt_header,                                                                                 
      names: array [1 .. 1] of clt$pdt_parameter_name,                                                        
      parameters: array [1 .. 1] of clt$pdt_parameter,                                                        
      type1: record                                                                                           
        header: clt$type_specification_header,                                                                
      recend,                                                                                                 
    recend := [                                                                                               
    [1,                                                                                                       
    [89, 5, 1, 14, 9, 40, 489],                                                                               
    clc$command, 1, 1, 0, 0, 0, 0, 1, ''], [                                                                  
    ['STATUS                         ',clc$nominal_entry, 1]],                                                
    [                                                                                                         
{ PARAMETER 1                                                                                                 
    [1, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_by_name],                                                         
    clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,                      
  clc$optional_parameter, 0, 0]],                                                                             
{ PARAMETER 1                                                                                                 
    [[1, 0, clc$status_type]]];                                                                               
?? FMT (FORMAT := ON) ??                                                                                      
?? POP ??                                                                                                     
                                                                                                              
    CONST                                                                                                     
      p$status = 1;                                                                                           
                                                                                                              
    VAR                                                                                                       
      pvt: array [1 .. 1] of clt$parameter_value;                                                             
                                                                                                              
    status.normal := TRUE;                                                                                    
    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);                                  
    IF NOT status.normal THEN                                                                                 
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
                                                                                                              
    clp$end_include (duc$utility_name, status);                                                               
                                                                                                              
  PROCEND dup$quit_command;                                                                                   
MODEND dum$quit_command;                                                                                      
