?? RIGHT := 110 ??                                                                                            
?? NEWTITLE := 'NOS/VE Dump Analyzer : Display Dump Information Command' ??                                   
MODULE dum$display_dump_info_command;                                                                         
                                                                                                              
{ PURPOSE:                                                                                                    
{   This module contains the code for the display_dump_information command.                                   
                                                                                                              
?? NEWTITLE := 'Global Declarations Referenced by This Module', EJECT ??                                      
?? PUSH (LISTEXT := ON) ??                                                                                    
*copyc due$exception_condition_codes                                                                          
*copyc dut$did_record_type                                                                                    
?? POP ??                                                                                                     
*copyc dup$new_page_procedure                                                                                 
*copyc clp$close_display                                                                                      
*copyc clp$evaluate_parameters                                                                                
*copyc clp$open_display_reference                                                                             
*copyc clp$put_display                                                                                        
*copyc osp$disestablish_cond_handler                                                                          
*copyc osp$establish_block_exit_hndlr                                                                         
*copyc osp$set_status_abnormal                                                                                
?? EJECT ??                                                                                                   
*copyc duv$dump_environment_p                                                                                 
*copyc duv$execution_environment                                                                              
*copyc duv$title_data                                                                                         
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'convert_byte_to_octal_string', EJECT ??                                                       
                                                                                                              
{ PURPOSE:                                                                                                    
{   This procedure converts a byte into an octal string.                                                      
                                                                                                              
  PROCEDURE convert_byte_to_octal_string                                                                      
    (    byte: 0 .. 0ff(16);                                                                                  
     VAR octal_string: string (5));                                                                           
                                                                                                              
    TYPE                                                                                                      
      t$byte_record = PACKED RECORD                                                                           
        fill: 0 .. 03(16),                                                                                    
        left: 0 .. 07(16),                                                                                    
        right: 0 .. 07(16),                                                                                   
      RECEND;                                                                                                 
                                                                                                              
    VAR                                                                                                       
      byte_record_p: ^t$byte_record,                                                                          
      octal_characters: [STATIC] ARRAY [0 .. 7] OF char := ['0', '1', '2', '3', '4', '5', '6', '7'];          
                                                                                                              
    byte_record_p := #LOC (byte);                                                                             
    octal_string (1) := octal_characters [byte_record_p^.left];                                               
    octal_string (2) := octal_characters [byte_record_p^.right];                                              
    octal_string (3) := '(';                                                                                  
    octal_string (4) := '8';                                                                                  
    octal_string (5) := ')';                                                                                  
                                                                                                              
  PROCEND convert_byte_to_octal_string;                                                                       
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'display_deadstart_channel', EJECT ??                                                          
                                                                                                              
{ PURPOSE:                                                                                                    
{   This procedure displays the deadstart channel of the dump.                                                
                                                                                                              
  PROCEDURE display_deadstart_channel                                                                         
    (    deadstart_channel: dut$did_identifier_entry;                                                         
     VAR display_control: clt$display_control);                                                               
                                                                                                              
    VAR                                                                                                       
      display_string: string (osc$max_string_size),                                                           
      ignore_status: ost$status,                                                                              
      octal_string: string (5),                                                                               
      string_length: integer;                                                                                 
                                                                                                              
    convert_byte_to_octal_string (deadstart_channel.value, octal_string);                                     
    STRINGREP (display_string, string_length, ' Deadstart channel = ', octal_string);                         
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);            
                                                                                                              
  PROCEND display_deadstart_channel;                                                                          
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'display_dump_number', EJECT ??                                                                
                                                                                                              
{ PURPOSE:                                                                                                    
{   This procedure displays the dump number of the dump.                                                      
                                                                                                              
  PROCEDURE display_dump_number                                                                               
    (    dump_number: dut$did_identifier_entry;                                                               
     VAR display_control: clt$display_control);                                                               
                                                                                                              
    VAR                                                                                                       
      display_string: string (osc$max_string_size),                                                           
      ignore_status: ost$status,                                                                              
      octal_string: string (5),                                                                               
      string_length: integer;                                                                                 
                                                                                                              
    convert_byte_to_octal_string (dump_number.value, octal_string);                                           
    STRINGREP (display_string, string_length, ' Dump number = ', octal_string);                               
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);            
                                                                                                              
  PROCEND display_dump_number;                                                                                
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'display_dump_taken_indicator', EJECT ??                                                       
                                                                                                              
{ PURPOSE:                                                                                                    
{   This procedure displays the dump taken indicator.                                                         
                                                                                                              
  PROCEDURE display_dump_taken_indicator                                                                      
    (    dump_taken_indicator: dut$did_identifier_entry;                                                      
     VAR display_control: clt$display_control);                                                               
                                                                                                              
    VAR                                                                                                       
      ignore_status: ost$status;                                                                              
                                                                                                              
    IF dump_taken_indicator.value <> 77(8) THEN                                                               
      clp$put_display (display_control, ' NOTE : First dump taken', clc$trim, ignore_status);                 
    ELSE                                                                                                      
      clp$put_display (display_control, ' NOTE : This is not the first dump taken', clc$trim, ignore_status); 
    IFEND;                                                                                                    
                                                                                                              
  PROCEND display_dump_taken_indicator;                                                                       
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'display_edd_revision_level', EJECT ??                                                         
                                                                                                              
{ PURPOSE:                                                                                                    
{   This procedure displays the EDD revision level.                                                           
                                                                                                              
  PROCEDURE display_edd_revision_level                                                                        
    (VAR display_control: clt$display_control);                                                               
                                                                                                              
    VAR                                                                                                       
      display_string: string (osc$max_string_size),                                                           
      ignore_status: ost$status,                                                                              
      string_length: integer;                                                                                 
                                                                                                              
    STRINGREP (display_string, string_length, ' EDD revision level = ',                                       
          duv$dump_environment_p^.dump_identifier.edd_revision_level);                                        
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);            
                                                                                                              
  PROCEND display_edd_revision_level;                                                                         
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'display_extended_memory', EJECT ??                                                            
                                                                                                              
{ PURPOSE:                                                                                                    
{   This procedure displays the extended memory of the dump.                                                  
                                                                                                              
  PROCEDURE display_extended_memory                                                                           
    (    extended_memory: dut$did_extended_memory;                                                            
     VAR display_control: clt$display_control);                                                               
                                                                                                              
    VAR                                                                                                       
      display_string: string (osc$max_string_size),                                                           
      ignore_status: ost$status,                                                                              
      octal_string: string (5),                                                                               
      octal_string_2: string (5),                                                                             
      string_length: integer;                                                                                 
                                                                                                              
    IF (extended_memory.entry.value_1 > 0) OR (extended_memory.entry.value_2 > 0) THEN                        
      convert_byte_to_octal_string (extended_memory.entry.value_1, octal_string);                             
      convert_byte_to_octal_string (extended_memory.entry.value_2, octal_string_2);                           
      STRINGREP (display_string, string_length, ' Number of 10000(8) word blocks of extended memory = ',      
            octal_string(1, 2), octal_string_2);                                                              
      clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);          
                                                                                                              
      { Display the extended memory channel.                                                                  
                                                                                                              
      convert_byte_to_octal_string (extended_memory.channel.value, octal_string);                             
      STRINGREP (display_string, string_length, ' Extended Memory channel = ', octal_string);                 
      clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);          
    IFEND;                                                                                                    
                                                                                                              
  PROCEND display_extended_memory;                                                                            
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'display_ipi_port_number', EJECT ??                                                            
                                                                                                              
{ PURPOSE:                                                                                                    
{   This procedure displays the IPI port number.                                                              
                                                                                                              
  PROCEDURE display_ipi_port_number                                                                           
    (    tape_information: dut$did_tape_information;                                                          
         ipi_tape_port_number: dut$did_identifier_entry;                                                      
     VAR display_control: clt$display_control);                                                               
                                                                                                              
    VAR                                                                                                       
      display_string: string (osc$max_string_size),                                                           
      ignore_status: ost$status,                                                                              
      octal_string: string (5),                                                                               
      string_length: integer;                                                                                 
                                                                                                              
    IF (tape_information.tape_type.value = 40(8)) OR (tape_information.tape_type.value = 41(8)) THEN          
      convert_byte_to_octal_string (ipi_tape_port_number.value, octal_string);                                
      STRINGREP (display_string, string_length, ' IPI tape port number = ', octal_string);                    
      clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);          
    IFEND;                                                                                                    
                                                                                                              
  PROCEND display_ipi_port_number;                                                                            
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'display_memory_option', EJECT ??                                                              
                                                                                                              
{ PURPOSE:                                                                                                    
{   This procedure displays the memory option of the dump.                                                    
                                                                                                              
  PROCEDURE display_memory_option                                                                             
    (    memory_option: dut$did_identifier_entry;                                                             
     VAR display_control: clt$display_control);                                                               
                                                                                                              
    VAR                                                                                                       
      ignore_status: ost$status;                                                                              
                                                                                                              
    IF memory_option.value = duc$did_all_180_state_memory THEN                                                
      clp$put_display (display_control, ' Full memory dump was selected', clc$trim, ignore_status);           
    ELSEIF memory_option.value = duc$did_no_180_state_memory THEN                                             
      clp$put_display (display_control, ' No 180-state memory dump was selected', clc$trim, ignore_status);   
    ELSEIF memory_option.value = duc$did_critical_180_state_mem THEN                                          
      clp$put_display (display_control, ' Critical memory dump was selected', clc$trim, ignore_status);       
    ELSE                                                                                                      
      clp$put_display (display_control, ' Unknown option value.', clc$trim, ignore_status);                   
    IFEND;                                                                                                    
                                                                                                              
  PROCEND display_memory_option;                                                                              
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'display_tape_information', EJECT ??                                                           
                                                                                                              
{ PURPOSE:                                                                                                    
{   This procedure displays the tape information of the dump.                                                 
                                                                                                              
  PROCEDURE display_tape_information                                                                          
    (    tape_information: dut$did_tape_information;                                                          
     VAR display_control: clt$display_control);                                                               
                                                                                                              
    VAR                                                                                                       
      display_string: string (osc$max_string_size),                                                           
      ignore_status: ost$status,                                                                              
      octal_string: string (5),                                                                               
      string_length: integer;                                                                                 
                                                                                                              
    clp$put_display (display_control, ' Tape Selections : ', clc$trim, ignore_status);                        
    IF tape_information.tape_type.value = 1 THEN                                                              
      clp$put_display (display_control, '     tape_type = 667, 669', clc$trim, ignore_status);                
      clp$put_display (display_control, '       density = 800 BPI',  clc$trim, ignore_status);                
    ELSEIF tape_information.tape_type.value = 2 THEN                                                          
      clp$put_display (display_control, '     tape_type = 677', clc$trim, ignore_status);                     
      clp$put_display (display_control, '       density = 800 BPI', clc$trim, ignore_status);                 
      clp$put_display (display_control, '     tape_type = 639, 679, 698(ccc)', clc$trim, ignore_status);      
      clp$put_display (display_control, '       density = 1600 BPI', clc$trim, ignore_status);                
    ELSEIF tape_information.tape_type.value = 3 THEN                                                          
      clp$put_display (display_control, '     tape_type = 639, 679, 698(ccc)', clc$trim, ignore_status);      
      clp$put_display (display_control, '       density = 6250 BPI', clc$trim, ignore_status);                
    ELSEIF tape_information.tape_type.value = 4 THEN                                                          
      clp$put_display (display_control, '     tape_type = 5680', clc$trim, ignore_status);                    
      clp$put_display (display_control, '       density = 38000 BPI', clc$trim, ignore_status);               
    ELSEIF tape_information.tape_type.value = 40(8) THEN                                                      
      clp$put_display (display_control, '     tape_type = 698(ipi)', clc$trim, ignore_status);                
      clp$put_display (display_control, '       density = 1600 BPI', clc$trim, ignore_status);                
    ELSEIF tape_information.tape_type.value = 41(8) THEN                                                      
      clp$put_display (display_control, '     tape_type = 698(ipi)', clc$trim, ignore_status);                
      clp$put_display (display_control, '       density = 6250 BPI', clc$trim, ignore_status);                
    IFEND;                                                                                                    
    convert_byte_to_octal_string (tape_information.tape_channel.value, octal_string);                         
    STRINGREP (display_string, string_length, '     channel   = ', octal_string);                             
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);            
    convert_byte_to_octal_string (tape_information.tape_equipment.value, octal_string);                       
    STRINGREP (display_string, string_length, '     equipment = ', octal_string);                             
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);            
    convert_byte_to_octal_string (tape_information.tape_unit.value, octal_string);                            
    STRINGREP (display_string, string_length, '     tape unit = ', octal_string);                             
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);            
                                                                                                              
  PROCEND display_tape_information;                                                                           
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'display_unload_option', EJECT ??                                                              
                                                                                                              
{ PURPOSE:                                                                                                    
{   This procedure displays the unload option of the dump.                                                    
                                                                                                              
  PROCEDURE display_unload_option                                                                             
    (    unload_option: dut$did_identifier_entry;                                                             
     VAR display_control: clt$display_control);                                                               
                                                                                                              
    VAR                                                                                                       
      ignore_status: ost$status;                                                                              
                                                                                                              
    IF unload_option.value <> duc$did_unload_dump_selected THEN                                               
      clp$put_display (display_control, ' Rewind dump selected', clc$trim, ignore_status);                    
    ELSE                                                                                                      
      clp$put_display (display_control, ' Unload dump selected', clc$trim, ignore_status);                    
    IFEND;                                                                                                    
                                                                                                              
  PROCEND display_unload_option;                                                                              
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'dup$display_dump_info_command', EJECT ??                                                      
                                                                                                              
{ PURPOSE:                                                                                                    
{   This procedure displays the information from the dump identifier record.                                  
                                                                                                              
  PROCEDURE [XDCL] dup$display_dump_info_command                                                              
    (    parameter_list: clt$parameter_list;                                                                  
     VAR status: ost$status);                                                                                 
                                                                                                              
{ PROCEDURE display_dump_information, display_dump_info, disdi (                                              
{   output, o: file = $optional                                                                               
{   title, t: string 1..31 = 'display_dump_information'                                                       
{   status)                                                                                                   
                                                                                                              
?? PUSH (LISTEXT := ON) ??                                                                                    
?? FMT (FORMAT := OFF) ??                                                                                     
  VAR                                                                                                         
    pdt: [STATIC, READ, cls$declaration_section] record                                                       
      header: clt$pdt_header,                                                                                 
      names: array [1 .. 5] of clt$pdt_parameter_name,                                                        
      parameters: array [1 .. 3] of clt$pdt_parameter,                                                        
      type1: record                                                                                           
        header: clt$type_specification_header,                                                                
      recend,                                                                                                 
      type2: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$string_type_qualifier,                                                                 
        default_value: string (26),                                                                           
      recend,                                                                                                 
      type3: record                                                                                           
        header: clt$type_specification_header,                                                                
      recend,                                                                                                 
    recend := [                                                                                               
    [1,                                                                                                       
    [90, 4, 16, 9, 39, 50, 817],                                                                              
    clc$command, 5, 3, 0, 0, 0, 0, 3, ''], [                                                                  
    ['O                              ',clc$abbreviation_entry, 1],                                            
    ['OUTPUT                         ',clc$nominal_entry, 1],                                                 
    ['STATUS                         ',clc$nominal_entry, 3],                                                 
    ['T                              ',clc$abbreviation_entry, 2],                                            
    ['TITLE                          ',clc$nominal_entry, 2]],                                                
    [                                                                                                         
{ PARAMETER 1                                                                                                 
    [2, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],                               
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$optional_parameter, 0
  , 0],                                                                                                       
{ PARAMETER 2                                                                                                 
    [5, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],                               
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 8,                          
  clc$optional_default_parameter, 0, 26],                                                                     
{ PARAMETER 3                                                                                                 
    [3, 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$file_type]],                                                                                  
{ PARAMETER 2                                                                                                 
    [[1, 0, clc$string_type], [1, 31, FALSE],                                                                 
    '''display_dump_information'''],                                                                          
{ PARAMETER 3                                                                                                 
    [[1, 0, clc$status_type]]];                                                                               
?? FMT (FORMAT := ON) ??                                                                                      
?? POP ??                                                                                                     
                                                                                                              
    CONST                                                                                                     
      p$output = 1,                                                                                           
      p$title = 2,                                                                                            
      p$status = 3;                                                                                           
                                                                                                              
    VAR                                                                                                       
      pvt: array [1 .. 3] of clt$parameter_value;                                                             
                                                                                                              
    VAR                                                                                                       
      cell_p: ^cell,                                                                                          
      cy2000_data_p: ^dut$did_edd_data,                                                                       
      display_control: clt$display_control,                                                                   
      display_string: string (osc$max_string_size),                                                           
      dual_state_data_p: ^dut$did_dual_state_data,                                                            
      edd_data_p: ^dut$did_edd_data,                                                                          
      es0_data_p: ^dut$did_edd_data,                                                                          
      ignore_status: ost$status,                                                                              
      octal_string: string (5),                                                                               
      octal_string_2: string (5),                                                                             
      output_display_opened: boolean,                                                                         
      restart_file_seq_p: ^SEQ ( * ),                                                                         
      ring_attributes: amt$ring_attributes,                                                                   
      string_length: integer,                                                                                 
      utility_p: ^dut$did_identifier_entry;                                                                   
                                                                                                              
*copy dup$abort_handler                                                                                       
?? NEWTITLE := 'clean_up', EJECT ??                                                                           
                                                                                                              
{ PURPOSE:                                                                                                    
{   This procedure is called from the abort handler to close the file.                                        
                                                                                                              
    PROCEDURE [INLINE] clean_up;                                                                              
                                                                                                              
      VAR                                                                                                     
        ignore_status: ost$status;                                                                            
                                                                                                              
      IF output_display_opened THEN                                                                           
        clp$close_display (display_control, ignore_status);                                                   
      IFEND;                                                                                                  
                                                                                                              
    PROCEND clean_up;                                                                                         
?? OLDTITLE ??                                                                                                
?? EJECT ??                                                                                                   
                                                                                                              
    status.normal := TRUE;                                                                                    
    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);                                  
    IF NOT status.normal THEN                                                                                 
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
                                                                                                              
    IF duv$dump_environment_p = NIL THEN                                                                      
      osp$set_status_abnormal (duc$dump_analyzer_id, due$no_restart_file, '', status);                        
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
                                                                                                              
    output_display_opened := FALSE;                                                                           
    osp$establish_block_exit_hndlr (^abort_handler);                                                          
                                                                                                              
   /display_opened/                                                                                           
    BEGIN                                                                                                     
                                                                                                              
      { Prepare the output display file.                                                                      
                                                                                                              
      IF pvt [p$output].specified THEN                                                                        
        ring_attributes.r1 := #RING (^ring_attributes);                                                       
        ring_attributes.r2 := #RING (^ring_attributes);                                                       
        ring_attributes.r3 := #RING (^ring_attributes);                                                       
        clp$open_display_reference (pvt [p$output].value^.file_value^, ^dup$new_page_procedure, fsc$list,     
              ring_attributes, display_control, status);                                                      
        IF NOT status.normal THEN                                                                             
          EXIT /display_opened/;  {---->                                                                      
        IFEND;                                                                                                
        output_display_opened := TRUE;                                                                        
      ELSE                                                                                                    
        display_control := duv$execution_environment.output_file.display_control;                             
        display_control.line_number := display_control.page_length + 1;                                       
      IFEND;                                                                                                  
                                                                                                              
      duv$title_data.build_title := TRUE;                                                                     
      duv$title_data.command_name := pvt [p$title].value^.string_value^;                                      
                                                                                                              
      IF NOT duv$dump_environment_p^.dump_identifier.available THEN                                           
        osp$set_status_abnormal (duc$dump_analyzer_id, due$data_not_on_dump, 'The specified record is',       
              status);                                                                                        
        EXIT /display_opened/;  {---->                                                                        
      IFEND;                                                                                                  
                                                                                                              
      restart_file_seq_p := duv$execution_environment.data_file_p^.segment_pointer.sequence_pointer;          
      cell_p := #ADDRESS (#RING (restart_file_seq_p), #SEGMENT (restart_file_seq_p),                          
            duv$dump_environment_p^.dump_identifier.first_byte);                                              
      RESET restart_file_seq_p TO cell_p;                                                                     
                                                                                                              
      clp$put_display (display_control, ' Dump File Information : ', clc$trim, ignore_status);                
      clp$put_display (display_control, ' ----------------------- ', clc$trim, ignore_status);                
                                                                                                              
      NEXT utility_p IN restart_file_seq_p;                                                                   
      IF utility_p = NIL THEN                                                                                 
        osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                          
        EXIT /display_opened/;  {---->                                                                        
      IFEND;                                                                                                  
                                                                                                              
      IF utility_p^.value = duc$did_dual_state_dump THEN                                                      
                                                                                                              
        { Display the 'dump created' message.                                                                 
                                                                                                              
        clp$put_display (display_control, ' Dump was created by *RUN ', clc$trim, ignore_status);             
        NEXT dual_state_data_p IN restart_file_seq_p;                                                         
        IF dual_state_data_p = NIL THEN                                                                       
          osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                        
          EXIT /display_opened/;  {---->                                                                      
        IFEND;                                                                                                
                                                                                                              
        display_memory_option (dual_state_data_p^.memory_option, display_control);                            
                                                                                                              
      ELSEIF utility_p^.value = duc$did_edd_dump THEN                                                         
                                                                                                              
        { Display the 'dump created' message.                                                                 
                                                                                                              
        clp$put_display (display_control, ' Dump was created by EDD ', clc$trim, ignore_status);              
        NEXT edd_data_p IN restart_file_seq_p;                                                                
        IF edd_data_p = NIL THEN                                                                              
          osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                        
          EXIT /display_opened/;  {---->                                                                      
        IFEND;                                                                                                
                                                                                                              
        display_edd_revision_level (display_control);                                                         
        display_memory_option (edd_data_p^.memory_option, display_control);                                   
        display_tape_information (edd_data_p^.tape_information, display_control);                             
        display_deadstart_channel (edd_data_p^.deadstart_channel, display_control);                           
        display_extended_memory (edd_data_p^.extended_memory, display_control);                               
        display_dump_number (edd_data_p^.dump_number, display_control);                                       
        display_unload_option (edd_data_p^.unload_option, display_control);                                   
        display_dump_taken_indicator (edd_data_p^.dump_taken_indicator, display_control);                     
        display_ipi_port_number (edd_data_p^.tape_information, edd_data_p^.ipi_tape_port_number,              
              display_control);                                                                               
                                                                                                              
      ELSEIF utility_p^.value = duc$did_cy2000_dump THEN                                                      
                                                                                                              
        { Display the 'dump created' message.                                                                 
                                                                                                              
        clp$put_display (display_control, ' Dump was created by the Cyber 2000 EDD',                          
              clc$trim, ignore_status);                                                                       
        NEXT cy2000_data_p IN restart_file_seq_p;                                                             
        IF cy2000_data_p = NIL THEN                                                                           
          osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                        
          EXIT /display_opened/;  {---->                                                                      
        IFEND;                                                                                                
                                                                                                              
        display_edd_revision_level (display_control);                                                         
        display_memory_option (cy2000_data_p^.memory_option, display_control);                                
        display_tape_information (cy2000_data_p^.tape_information, display_control);                          
        display_extended_memory (cy2000_data_p^.extended_memory, display_control);                            
        display_dump_number (cy2000_data_p^.dump_number, display_control);                                    
        display_unload_option (cy2000_data_p^.unload_option, display_control);                                
        display_ipi_port_number (cy2000_data_p^.tape_information, cy2000_data_p^.ipi_tape_port_number,        
              display_control);                                                                               
                                                                                                              
      ELSEIF utility_p^.value = duc$did_es0_dump THEN                                                         
                                                                                                              
        { Display the 'dump created' message.                                                                 
                                                                                                              
        clp$put_display (display_control, ' Dump was created by ES0 ', clc$trim, ignore_status);              
        NEXT es0_data_p IN restart_file_seq_p;                                                                
        IF es0_data_p = NIL THEN                                                                              
          osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                        
          EXIT /display_opened/;  {---->                                                                      
        IFEND;                                                                                                
                                                                                                              
        display_edd_revision_level (display_control);                                                         
        display_memory_option (es0_data_p^.memory_option, display_control);                                   
        display_tape_information (es0_data_p^.tape_information, display_control);                             
        display_dump_number (es0_data_p^.dump_number, display_control);                                       
        display_unload_option (es0_data_p^.unload_option, display_control);                                   
        display_dump_taken_indicator (es0_data_p^.dump_taken_indicator, display_control);                     
                                                                                                              
      ELSE                                                                                                    
        clp$put_display (display_control, ' Unknown utility value.', clc$trim, ignore_status);                
      IFEND;                                                                                                  
                                                                                                              
    END /display_opened/;                                                                                     
                                                                                                              
    IF output_display_opened THEN                                                                             
      clp$close_display (display_control, ignore_status);                                                     
    IFEND;                                                                                                    
    osp$disestablish_cond_handler;                                                                            
                                                                                                              
  PROCEND dup$display_dump_info_command;                                                                      
MODEND dum$display_dump_info_command;                                                                         
