?? RIGHT := 110 ??                                                                                            
?? NEWTITLE := 'NOS/VE Dump Analyzer : Read Dump File' ??                                                     
MODULE dum$read_dump_file;                                                                                    
                                                                                                              
{ PURPOSE:                                                                                                    
{   This module contains the code to read the dump file.                                                      
                                                                                                              
?? NEWTITLE := 'Global Declarations Referenced by This Module', EJECT ??                                      
?? PUSH (LISTEXT := ON) ??                                                                                    
*copyc clc$standard_file_names                                                                                
*copyc duc$dump_analyzer_constants                                                                            
*copyc due$exception_condition_codes                                                                          
*copyc dst$channel_protocol_type                                                                              
*copyc dut$dump_information                                                                                   
?? POP ??                                                                                                     
*copyc amp$get_next                                                                                           
*copyc amp$return                                                                                             
*copyc amp$set_segment_eoi                                                                                    
*copyc clp$put_display                                                                                        
*copyc dup$display_message                                                                                    
*copyc dup$retrieve_register                                                                                  
*copyc fsp$close_file                                                                                         
*copyc fsp$open_file                                                                                          
*copyc mmp$set_access_selections                                                                              
*copyc ofp$display_status_message                                                                             
*copyc osp$append_status_parameter                                                                            
*copyc osp$get_status_severity                                                                                
*copyc osp$set_status_abnormal                                                                                
*copyc pmp$zero_out_table                                                                                     
*copyc rmp$get_device_class                                                                                   
*copyc duv$dump_environment_p                                                                                 
*copyc duv$execution_environment                                                                              
?? EJECT ??                                                                                                   
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'Global Declarations Declared by This Module', EJECT ??                                        
                                                                                                              
  CONST                                                                                                       
    c$edd_tape_block_size = 3840;                                                                             
                                                                                                              
  TYPE                                                                                                        
    t$dump_label = RECORD                                                                                     
      read_label: boolean,                                                                                    
      record_name: dut$de_other_record_name,                                                                  
      CASE kind: t$dump_label_kind OF                                                                         
      = c$dlk_mem_label =                                                                                     
        first_word_address: 0 .. 0fffffff(16),                                                                
        length: 0 .. 0fffffff(16),                                                                            
      = c$dlk_ccm_label =                                                                                     
        page_number: 0 .. 0ffffffff(16),                                                                      
      = c$dlk_cpt_label =                                                                                     
        page_size_mask: 0 .. 0ff(16),                                                                         
        page_table_length: 0 .. 3ffff(16),                                                                    
      = c$dlk_did_label =                                                                                     
        edd_revision_level: string (3),                                                                       
      = c$dlk_iom_label, c$dlk_jom_label =                                                                    
        pp_number: 0 .. 99,                                                                                   
      = c$dlk_dom_label, c$dlk_eom_label =                                                                    
        cio_pp_number: 0 .. duc$de_max_cio_pp_memories,                                                       
      = c$dlk_pcs_label =                                                                                     
        shadow_control_store: boolean,                                                                        
        number_of_128_bit_regs: 0 .. 1fffff(16),                                                              
      = c$dlk_prf_label =                                                                                     
        register_file_size: 0 .. 3ffff(16),                                                                   
      = c$dlk_pmr_label, c$dlk_pr0_label, c$dlk_pr1_label,                                                    
            c$dlk_pxp_label, c$dlk_px0_label, c$dlk_px1_label,                                                
            c$dlk_jps_label, c$dlk_jp0_label, c$dlk_jp1_label,                                                
            c$dlk_mps_label, c$dlk_mp0_label, c$dlk_mp1_label =                                               
        radial_mci: 0 .. duc$de_maximum_mci_port,                                                             
      = c$dlk_other_label =                                                                                   
        record_type: dut$de_other_record_type,                                                                
        header_line_count: 0 .. 3ffff(16),                                                                    
        report_record_length: 0 .. 3ffff(16),                                                                 
      CASEND,                                                                                                 
    RECEND,                                                                                                   
                                                                                                              
    t$dump_label_kind = (c$dlk_pmr_label, c$dlk_pr0_label, c$dlk_pr1_label, c$dlk_mmr_label, c$dlk_mem_label, 
          c$dlk_imr_label, c$dlk_im1_label, c$dlk_iom_label, c$dlk_jom_label, c$dlk_dom_label,                
          c$dlk_eom_label, c$dlk_prf_label, c$dlk_pxp_label, c$dlk_px0_label, c$dlk_px1_label,                
          c$dlk_pcs_label, c$dlk_other_label, c$dlk_bc_label, c$dlk_jps_label, c$dlk_jp0_label,               
          c$dlk_jp1_label, c$dlk_cpt_label, c$dlk_ccm_label, c$dlk_mps_label, c$dlk_mp0_label,                
          c$dlk_mp1_label, c$dlk_ill_formatted_label, c$dlk_did_label, c$dlk_not_a_label),                    
                                                                                                              
    t$edd_code = PACKED RECORD                                                                                
      CASE boolean OF                                                                                         
      = TRUE =                                                                                                
        value: 0 .. 3ffff(16),                                                                                
      = FALSE =                                                                                               
        first_character: 0 .. 77(8),                                                                          
        second_character: 0 .. 77(8),                                                                         
        third_character: 0 .. 77(8),                                                                          
      CASEND,                                                                                                 
    RECEND,                                                                                                   
                                                                                                              
    t$edd_label = PACKED RECORD                                                                               
      code: t$edd_code,                                                                                       
      zero_parameter: 0 .. 3f(16),                                                                            
      first_parameter: 0 .. 3ffff(16),                                                                        
      second_parameter: 0 .. 3ffff(16),                                                                       
      message_field_1: 0 .. 01fffffffffff(16),                                                                
      message_field_2: 0 .. 01fffffffffff(16),                                                                
      message_field_3: 0 .. 01fffffffffff(16),                                                                
      message_field_4: 0 .. 01fffffffffff(16),                                                                
    RECEND;                                                                                                   
?? EJECT ??                                                                                                   
                                                                                                              
  VAR                                                                                                         
    v$display_control: clt$display_control,                                                                   
    v$dump_file_identifier: amt$file_identifier,                                                              
    v$file_name_p: ^fst$file_reference := NIL,                                                                
    v$file_position: amt$file_position,                                                                       
    v$last_bc_entry_p: ^dut$de_buffer_controlware_entry := NIL,                                               
    v$last_other_record_p: ^dut$de_other_record_entry := NIL;                                                 
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'get_next_data', EJECT ??                                                                      
                                                                                                              
{ PURPOSE:                                                                                                    
{   This procedure reads the next chunk of data from the input file.  It will accept bad tape blocks.         
                                                                                                              
  PROCEDURE get_next_data                                                                                     
    (    data_size: amt$working_storage_length;                                                               
     VAR data_buffer_p: ^SEQ ( * );                                                                           
     VAR bytes_read: amt$transfer_count;                                                                      
     VAR status: ost$status);                                                                                 
                                                                                                              
    VAR                                                                                                       
      file_byte_address: amt$file_byte_address;                                                               
                                                                                                              
    status.normal := TRUE;                                                                                    
                                                                                                              
    amp$get_next (v$dump_file_identifier, data_buffer_p, data_size, bytes_read, file_byte_address,            
          v$file_position, status);                                                                           
    IF NOT status.normal AND (status.condition = ame$accept_bad_block) THEN                                   
      status.normal := TRUE;                                                                                  
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
    IF NOT status.normal THEN                                                                                 
      dup$display_message (status, v$display_control);                                                        
      osp$set_status_abnormal (duc$dump_analyzer_id, due$dump_file_io_error, v$file_name_p^, status);         
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
                                                                                                              
  PROCEND get_next_data;                                                                                      
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'process_label_record', EJECT ??                                                               
                                                                                                              
{ PURPOSE:                                                                                                    
{   This procedure builds the dump label record from the EDD label which resides on the input sequence.       
                                                                                                              
  PROCEDURE process_label_record                                                                              
    (VAR data_buffer_seq_p: ^SEQ ( * );                                                                       
     VAR dump_label: t$dump_label);                                                                           
                                                                                                              
    TYPE                                                                                                      
      t$shadow_bit = PACKED RECORD                                                                            
        CASE boolean OF                                                                                       
        = TRUE =                                                                                              
          data: 0 .. 3ffff(16),                                                                               
        = FALSE =                                                                                             
          shadow_control_store: boolean,                                                                      
          unused: 0 .. 01ffff(16),                                                                            
        CASEND,                                                                                               
      RECEND,                                                                                                 
                                                                                                              
      t$three_characters = PACKED RECORD                                                                      
        CASE boolean OF                                                                                       
        = TRUE =                                                                                              
          together: 0 .. 3ffff(16),                                                                           
        = FALSE =                                                                                             
          first_character: 0 .. 77(8),                                                                        
          second_character: 0 .. 77(8),                                                                       
          third_character: 0 .. 77(8),                                                                        
        CASEND,                                                                                               
      RECEND;                                                                                                 
                                                                                                              
    CONST                                                                                                     
      c$a_display_code = 1,                                                                                   
      c$b_display_code = 2,                                                                                   
      c$c_display_code = 3,                                                                                   
      c$d_display_code = 4,                                                                                   
      c$e_display_code = 5,                                                                                   
      c$f_display_code = 6,                                                                                   
      c$g_display_code = 7,                                                                                   
      c$h_display_code = 8,                                                                                   
      c$i_display_code = 9,                                                                                   
      c$j_display_code = 10,                                                                                  
      c$k_display_code = 11,                                                                                  
      c$l_display_code = 12,                                                                                  
      c$m_display_code = 13,                                                                                  
      c$n_display_code = 14,                                                                                  
      c$o_display_code = 15,                                                                                  
      c$p_display_code = 16,                                                                                  
      c$q_display_code = 17,                                                                                  
      c$r_display_code = 18,                                                                                  
      c$s_display_code = 19,                                                                                  
      c$t_display_code = 20,                                                                                  
      c$u_display_code = 21,                                                                                  
      c$v_display_code = 22,                                                                                  
      c$w_display_code = 23,                                                                                  
      c$x_display_code = 24,                                                                                  
      c$y_display_code = 25,                                                                                  
      c$z_display_code = 26,                                                                                  
      c$zero_display_code = 27,                                                                               
      c$one_display_code = 28,                                                                                
      c$nine_display_code = 36,                                                                               
      c$space_display_code = 45,                                                                              
      c$numeric_bias = 48,                                                                                    
      c$alphabetic_bias = 65,                                                                                 
                                                                                                              
      c$bc_display_code  = (((c$b_display_code * 40(16)) + c$c_display_code) * 40(16)) + c$space_display_code,
      c$did_display_code = (((c$d_display_code * 40(16)) + c$i_display_code) * 40(16)) + c$d_display_code,    
      c$ccm_display_code = (((c$c_display_code * 40(16)) + c$c_display_code) * 40(16)) + c$m_display_code,    
      c$cpt_display_code = (((c$c_display_code * 40(16)) + c$p_display_code) * 40(16)) + c$t_display_code,    
      c$im1_display_code = (((c$i_display_code * 40(16)) + c$m_display_code) * 40(16)) + c$one_display_code,  
      c$imr_display_code = (((c$i_display_code * 40(16)) + c$m_display_code) * 40(16)) + c$r_display_code,    
      c$jp0_display_code = (((c$j_display_code * 40(16)) + c$p_display_code) * 40(16)) + c$zero_display_code, 
      c$jp1_display_code = (((c$j_display_code * 40(16)) + c$p_display_code) * 40(16)) + c$one_display_code,  
      c$jps_display_code = (((c$j_display_code * 40(16)) + c$p_display_code) * 40(16)) + c$s_display_code,    
      c$mem_display_code = (((c$m_display_code * 40(16)) + c$e_display_code) * 40(16)) + c$m_display_code,    
      c$mmr_display_code = (((c$m_display_code * 40(16)) + c$m_display_code) * 40(16)) + c$r_display_code,    
      c$mp0_display_code = (((c$m_display_code * 40(16)) + c$p_display_code) * 40(16)) + c$zero_display_code, 
      c$mp1_display_code = (((c$m_display_code * 40(16)) + c$p_display_code) * 40(16)) + c$one_display_code,  
      c$mps_display_code = (((c$m_display_code * 40(16)) + c$p_display_code) * 40(16)) + c$s_display_code,    
      c$pcs_display_code = (((c$p_display_code * 40(16)) + c$c_display_code) * 40(16)) + c$s_display_code,    
      c$pmr_display_code = (((c$p_display_code * 40(16)) + c$m_display_code) * 40(16)) + c$r_display_code,    
      c$pr0_display_code = (((c$p_display_code * 40(16)) + c$r_display_code) * 40(16)) + c$zero_display_code, 
      c$pr1_display_code = (((c$p_display_code * 40(16)) + c$r_display_code) * 40(16)) + c$one_display_code,  
      c$prf_display_code = (((c$p_display_code * 40(16)) + c$r_display_code) * 40(16)) + c$f_display_code,    
      c$px0_display_code = (((c$p_display_code * 40(16)) + c$x_display_code) * 40(16)) + c$zero_display_code, 
      c$px1_display_code = (((c$p_display_code * 40(16)) + c$x_display_code) * 40(16)) + c$one_display_code,  
      c$pxp_display_code = (((c$p_display_code * 40(16)) + c$x_display_code) * 40(16)) + c$p_display_code;    
                                                                                                              
    VAR                                                                                                       
      edd_label_p: ^t$edd_label,                                                                              
      first_ascii_char: char,                                                                                 
      length: integer,                                                                                        
      local_status: ost$status,                                                                               
      max_pp_memories: integer,                                                                               
      pp_number: integer,                                                                                     
      second_ascii_char: char,                                                                                
      shadow_bit: t$shadow_bit,                                                                               
      third_ascii_char: char,                                                                                 
      three_characters: t$three_characters;                                                                   
                                                                                                              
?? NEWTITLE := 'convert_display_to_ascii', EJECT ??                                                           
                                                                                                              
{ PURPOSE:                                                                                                    
{   This function converts a display character to an ascii character.                                         
                                                                                                              
    FUNCTION convert_display_to_ascii (display_character: 0 .. 3f(16)): char;                                 
                                                                                                              
      IF (display_character >= c$zero_display_code) AND (display_character <= c$nine_display_code) THEN       
        convert_display_to_ascii := $CHAR (c$numeric_bias + (display_character - c$zero_display_code));       
      ELSEIF display_character = c$space_display_code THEN                                                    
        convert_display_to_ascii := ' ';                                                                      
      ELSE                                                                                                    
        convert_display_to_ascii := $CHAR (c$alphabetic_bias + (display_character - c$a_display_code));       
      IFEND;                                                                                                  
                                                                                                              
    FUNCEND convert_display_to_ascii;                                                                         
                                                                                                              
?? OLDTITLE, EJECT ??                                                                                         
                                                                                                              
    RESET data_buffer_seq_p;                                                                                  
    NEXT edd_label_p IN data_buffer_seq_p;                                                                    
    dump_label.read_label := FALSE;                                                                           
                                                                                                              
    CASE edd_label_p^.code.value OF                                                                           
    = c$bc_display_code =                                                                                     
      dump_label.kind := c$dlk_bc_label;                                                                      
                                                                                                              
    = c$did_display_code =                                                                                    
      dump_label.kind := c$dlk_did_label;                                                                     
      three_characters.together := edd_label_p^.second_parameter;                                             
      first_ascii_char := convert_display_to_ascii (three_characters.first_character);                        
      second_ascii_char := convert_display_to_ascii (three_characters.second_character);                      
      third_ascii_char := convert_display_to_ascii (three_characters.third_character);                        
      STRINGREP (dump_label.edd_revision_level, length, first_ascii_char, second_ascii_char,                  
            third_ascii_char);                                                                                
                                                                                                              
    = c$pmr_display_code, c$pr0_display_code, c$pr1_display_code,                                             
          c$pxp_display_code, c$px0_display_code, c$px1_display_code,                                         
          c$jps_display_code, c$jp0_display_code, c$jp1_display_code,                                         
          c$mps_display_code, c$mp0_display_code, c$mp1_display_code =                                        
      CASE edd_label_p^.code.value OF                                                                         
      = c$pmr_display_code =                                                                                  
        dump_label.kind := c$dlk_pmr_label;                                                                   
      = c$pr0_display_code =                                                                                  
        dump_label.kind := c$dlk_pr0_label;                                                                   
      = c$pr1_display_code =                                                                                  
        dump_label.kind := c$dlk_pr1_label;                                                                   
      = c$pxp_display_code =                                                                                  
        dump_label.kind := c$dlk_pxp_label;                                                                   
      = c$px0_display_code =                                                                                  
        dump_label.kind := c$dlk_px0_label;                                                                   
      = c$px1_display_code =                                                                                  
        dump_label.kind := c$dlk_px1_label;                                                                   
      = c$jps_display_code =                                                                                  
        dump_label.kind := c$dlk_jps_label;                                                                   
      = c$jp0_display_code =                                                                                  
        dump_label.kind := c$dlk_jp0_label;                                                                   
      = c$jp1_display_code =                                                                                  
        dump_label.kind := c$dlk_jp1_label;                                                                   
      = c$mps_display_code =                                                                                  
        dump_label.kind := c$dlk_mps_label;                                                                   
      = c$mp0_display_code =                                                                                  
        dump_label.kind := c$dlk_mp0_label;                                                                   
      ELSE  { = c$mp1_display_code = }                                                                        
        dump_label.kind := c$dlk_mp1_label;                                                                   
      CASEND;                                                                                                 
      IF (edd_label_p^.zero_parameter < c$zero_display_code) OR                                               
            (edd_label_p^.zero_parameter > (c$zero_display_code + duc$de_maximum_mci_port)) THEN              
        dump_label.radial_mci := 0;                                                                           
      ELSE                                                                                                    
        dump_label.radial_mci := edd_label_p^.zero_parameter - c$zero_display_code;                           
      IFEND;                                                                                                  
                                                                                                              
    = c$mmr_display_code =                                                                                    
      dump_label.kind := c$dlk_mmr_label;                                                                     
                                                                                                              
    = c$mem_display_code =                                                                                    
      dump_label.kind := c$dlk_mem_label;                                                                     
      dump_label.first_word_address := edd_label_p^.first_parameter * 200(16);                                
      dump_label.length := edd_label_p^.second_parameter * 200(16);                                           
                                                                                                              
    = c$cpt_display_code =                                                                                    
      dump_label.kind := c$dlk_cpt_label;                                                                     
      dump_label.page_size_mask := edd_label_p^.first_parameter;                                              
      dump_label.page_table_length := edd_label_p^.second_parameter;                                          
                                                                                                              
    = c$ccm_display_code =                                                                                    
      dump_label.kind := c$dlk_ccm_label;                                                                     
      dump_label.page_number := (edd_label_p^.first_parameter * 40000(16)) + edd_label_p^.second_parameter;   
                                                                                                              
    = c$imr_display_code =                                                                                    
      dump_label.kind := c$dlk_imr_label;                                                                     
                                                                                                              
    = c$im1_display_code =                                                                                    
      dump_label.kind := c$dlk_im1_label;                                                                     
                                                                                                              
    = c$prf_display_code =                                                                                    
      dump_label.kind := c$dlk_prf_label;                                                                     
      dump_label.register_file_size := edd_label_p^.second_parameter;                                         
                                                                                                              
    = c$pcs_display_code =                                                                                    
      dump_label.kind := c$dlk_pcs_label;                                                                     
      shadow_bit.data := edd_label_p^.first_parameter;                                                        
      dump_label.shadow_control_store := shadow_bit.shadow_control_store;                                     
      dump_label.number_of_128_bit_regs := edd_label_p^.second_parameter;                                     
                                                                                                              
    ELSE                                                                                                      
      IF (edd_label_p^.code.first_character = c$i_display_code) OR                                            
            (edd_label_p^.code.first_character = c$s_display_code) THEN                                       
        dump_label.kind := c$dlk_iom_label;                                                                   
        max_pp_memories := duc$de_max_pp_memories;                                                            
      ELSEIF edd_label_p^.code.first_character = c$j_display_code THEN                                        
        dump_label.kind := c$dlk_jom_label;                                                                   
        max_pp_memories := duc$de_max_pp_memories;                                                            
      ELSEIF edd_label_p^.code.first_character = c$d_display_code THEN                                        
        dump_label.kind := c$dlk_dom_label;                                                                   
        max_pp_memories := duc$de_max_cio_pp_memories;                                                        
      ELSEIF edd_label_p^.code.first_character = c$e_display_code THEN                                        
        dump_label.kind := c$dlk_eom_label;                                                                   
        max_pp_memories := duc$de_max_cio_pp_memories;                                                        
      ELSE                                                                                                    
        dump_label.kind := c$dlk_other_label;                                                                 
      IFEND;                                                                                                  
                                                                                                              
      IF dump_label.kind <> c$dlk_other_label THEN                                                            
        IF (edd_label_p^.code.second_character <= c$nine_display_code) AND                                    
              (edd_label_p^.code.second_character >= c$zero_display_code) AND                                 
              (edd_label_p^.code.third_character <= c$nine_display_code) AND                                  
              (edd_label_p^.code.third_character >= c$zero_display_code) THEN                                 
          pp_number := ((edd_label_p^.code.second_character - c$zero_display_code) * 8) +                     
                edd_label_p^.code.third_character - c$zero_display_code;                                      
          IF pp_number > max_pp_memories THEN                                                                 
            osp$set_status_abnormal (duc$dump_analyzer_id, due$dump_file_format_error, v$file_name_p^,        
                  local_status);                                                                              
            osp$append_status_parameter (osc$status_parameter_delimiter, 'PP number is out of range.',        
                  local_status);                                                                              
            dup$display_message (local_status, v$display_control);                                            
            dump_label.kind := c$dlk_ill_formatted_label;                                                     
          ELSE                                                                                                
            IF (dump_label.kind = c$dlk_iom_label) OR (dump_label.kind = c$dlk_jom_label) THEN                
              dump_label.pp_number := pp_number;                                                              
            ELSE  {(dump_label.kind = c$dlk_dom_label) OR (dump_label.kind = c$dlk_eom_label)                 
              dump_label.cio_pp_number := pp_number;                                                          
            IFEND;                                                                                            
          IFEND;                                                                                              
        ELSE                                                                                                  
          dump_label.kind := c$dlk_other_label;                                                               
        IFEND;                                                                                                
      IFEND;                                                                                                  
                                                                                                              
      IF dump_label.kind = c$dlk_other_label THEN                                                             
        IF edd_label_p^.zero_parameter = 20(8) THEN                                                           
          dump_label.record_type := duc$de_ort_report;                                                        
          dump_label.header_line_count := edd_label_p^.first_parameter;                                       
          dump_label.report_record_length := edd_label_p^.second_parameter;                                   
        ELSE                                                                                                  
          dump_label.record_type := duc$de_ort_dump;                                                          
          dump_label.header_line_count := 0;                                                                  
          dump_label.report_record_length := 0;                                                               
        IFEND;                                                                                                
      IFEND;                                                                                                  
                                                                                                              
    CASEND;                                                                                                   
                                                                                                              
    first_ascii_char := convert_display_to_ascii (edd_label_p^.code.first_character);                         
    second_ascii_char := convert_display_to_ascii (edd_label_p^.code.second_character);                       
    third_ascii_char := convert_display_to_ascii (edd_label_p^.code.third_character);                         
    STRINGREP (dump_label.record_name, length, first_ascii_char, second_ascii_char, third_ascii_char);        
                                                                                                              
  PROCEND process_label_record;                                                                               
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'read_buffer_controlware', EJECT ??                                                            
                                                                                                              
{ PURPOSE:                                                                                                    
{   This procedure reads the buffer controlware from the dump file and places it on the restart file.  The    
{   controlware data on the dump file is contained in groups of 8-bits of valid data in every 12-bit group.   
{   Only the 8-bits are moved to the restart file.                                                            
                                                                                                              
  PROCEDURE read_buffer_controlware                                                                           
    (VAR dump_label: t$dump_label;                                                                            
     VAR status: ost$status);                                                                                 
                                                                                                              
    CONST                                                                                                     
      c$7154_controlware_size = 8192,                                                                         
      c$7154_buffer_size = 12300,                                                                             
      c$7154_number_of_blocks = 4,                                                                            
                                                                                                              
      c$isd_controlware_size = 16384,                                                                         
      c$isd_buffer_size = 24600,                                                                              
      c$isd_number_of_blocks = 7,                                                                             
                                                                                                              
      c$7155_controlware_size = 16384,                                                                        
      c$7155_buffer_size = 24600,                                                                             
      c$7155_number_of_blocks = 7,                                                                            
                                                                                                              
      c$ismt_controlware_size = 71680,                                                                        
      c$ismt_buffer_size = 107520,                                                                            
      c$ismt_number_of_blocks = 28,                                                                           
                                                                                                              
      c$895_controlware_size = 32768,                                                                         
      c$895_buffer_size = 49200,                                                                              
      c$895_number_of_blocks = 13,                                                                            
                                                                                                              
      c$largest_number_of_blocks = 28;                                                                        
                                                                                                              
    TYPE                                                                                                      
      t$controlware_definition = PACKED RECORD                                                                
        fill1: 0 .. 0f(16),                                                                                   
        channel_type: 0 .. 0ff(16),                                                                           
        fill2: 0 .. 0ffff(16),                                                                                
        channel_number_upper: 0 .. 3(16),                                                                     
        channel_number_lower: 0 .. 3f(16),                                                                    
      RECEND,                                                                                                 
                                                                                                              
      t$eight_in_twelve = PACKED RECORD                                                                       
        fill: 0 .. 0f(16),                                                                                    
        data: 0 .. 0ff(16),                                                                                   
      RECEND;                                                                                                 
                                                                                                              
    VAR                                                                                                       
      buffer_controlware_entry_p: ^dut$de_buffer_controlware_entry,                                           
      bytes_read: amt$transfer_count,                                                                         
      channel: 0 .. duc$de_maximum_channels,                                                                  
      channel_type: dut$de_channel_type,                                                                      
      controlware_definition_p: ^t$controlware_definition,                                                    
      controlware_size: 0 .. (2 * duc$de_maximum_bc_size),                                                    
      data_buffer_array_p: ^PACKED ARRAY [ * ] OF t$eight_in_twelve,                                          
      data_buffer_p: ^SEQ ( * ),                                                                              
      data_buffer_seq_p: ^SEQ ( * ),                                                                          
      first_pass: boolean,                                                                                    
      index: 0 .. (2 * duc$de_maximum_bc_size),                                                               
      number_of_blocks: 1 .. 28,                                                                              
      restart_file_array_p: ^ARRAY [ * ] OF 0 .. 0ff(16),                                                     
      total_bytes_read: amt$transfer_count;                                                                   
                                                                                                              
    status.normal := TRUE;                                                                                    
                                                                                                              
    ofp$display_status_message ('reading channel buffer controlware', status);                                
                                                                                                              
    first_pass := TRUE;                                                                                       
                                                                                                              
    PUSH data_buffer_seq_p: [[REP (c$largest_number_of_blocks * c$edd_tape_block_size) OF cell]];             
    IF data_buffer_seq_p = NIL THEN                                                                           
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                            
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
    total_bytes_read := 0;                                                                                    
                                                                                                              
    WHILE TRUE DO                                                                                             
                                                                                                              
      RESET data_buffer_seq_p;                                                                                
                                                                                                              
      { Read the first block of the controlware.                                                              
                                                                                                              
      NEXT data_buffer_p: [[REP c$edd_tape_block_size OF cell]] IN data_buffer_seq_p;                         
      IF data_buffer_p = NIL THEN                                                                             
        osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                          
        RETURN;  {---->                                                                                       
      IFEND;                                                                                                  
      RESET data_buffer_p;                                                                                    
                                                                                                              
      get_next_data (c$edd_tape_block_size, data_buffer_p, bytes_read, status);                               
      IF NOT status.normal THEN                                                                               
        RETURN;  {---->                                                                                       
      IFEND;                                                                                                  
                                                                                                              
      IF (bytes_read = 0) OR (v$file_position = amc$eoi) THEN                                                 
        IF first_pass THEN                                                                                    
          osp$set_status_abnormal (duc$dump_analyzer_id, due$unexpected_eoi, v$file_name_p^, status);         
          osp$append_status_parameter (osc$status_parameter_delimiter, 'the buffer controlware', status);     
        IFEND;                                                                                                
        RETURN;  {---->                                                                                       
      IFEND;                                                                                                  
                                                                                                              
      { If the next EDD label has been read, process the label and return.                                    
                                                                                                              
      IF bytes_read = #SIZE (t$edd_label) THEN                                                                
        process_label_record (data_buffer_p, dump_label);                                                     
        RETURN;  {---->                                                                                       
      IFEND;                                                                                                  
      total_bytes_read := total_bytes_read + bytes_read;                                                      
                                                                                                              
      { Get the controlware size from the first couple of bytes of the first block.                           
                                                                                                              
      RESET data_buffer_p;                                                                                    
      NEXT controlware_definition_p IN data_buffer_p;                                                         
      IF controlware_definition_p = NIL THEN                                                                  
        osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                          
        RETURN;  {---->                                                                                       
      IFEND;                                                                                                  
                                                                                                              
      IF controlware_definition_p^.channel_type = duc$de_isd_adapter THEN                                     
        controlware_size := c$isd_controlware_size;                                                           
        number_of_blocks := c$isd_number_of_blocks;                                                           
      ELSEIF controlware_definition_p^.channel_type = duc$de_7155_adapter THEN                                
        controlware_size := c$7155_controlware_size;                                                          
        number_of_blocks := c$7155_number_of_blocks;                                                          
      ELSEIF controlware_definition_p^.channel_type = duc$de_ismt_adapter THEN                                
        controlware_size := c$ismt_controlware_size;                                                          
        number_of_blocks := c$ismt_number_of_blocks;                                                          
      ELSEIF controlware_definition_p^.channel_type = duc$de_895_adapter THEN                                 
        controlware_size := c$895_controlware_size;                                                           
        number_of_blocks := c$895_number_of_blocks;                                                           
      ELSEIF controlware_definition_p^.channel_type = duc$de_7154_adapter THEN                                
        controlware_size := c$7154_controlware_size;                                                          
        number_of_blocks := c$7154_number_of_blocks;                                                          
      ELSE                                                                                                    
        osp$set_status_abnormal (duc$dump_analyzer_id, due$bad_buffer_controlware, '', status);               
        dup$display_message (status, v$display_control);                                                      
        status.normal := TRUE;                                                                                
        RETURN;  {---->                                                                                       
      IFEND;                                                                                                  
                                                                                                              
      { Convert the channel number from display code.                                                         
                                                                                                              
      CASE controlware_definition_p^.channel_number_upper OF                                                  
      = 0 =                                                                                                   
        channel := 1;                                                                                         
      = 1 =                                                                                                   
        channel := 2;                                                                                         
      = 2 =                                                                                                   
        channel := 3;                                                                                         
      = 3 =                                                                                                   
        channel := 0;                                                                                         
      ELSE                                                                                                    
        channel := 0;                                                                                         
      CASEND;                                                                                                 
      channel := channel * 8 + controlware_definition_p^.channel_number_lower - 33(8);                        
      channel_type := controlware_definition_p^.channel_type;                                                 
                                                                                                              
      { Read the rest of the full blocks of controlware.                                                      
                                                                                                              
      FOR index := 2 TO number_of_blocks DO                                                                   
        NEXT data_buffer_p: [[REP c$edd_tape_block_size OF cell]] IN data_buffer_seq_p;                       
        IF data_buffer_p = NIL THEN                                                                           
          osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                        
          RETURN;  {---->                                                                                     
        IFEND;                                                                                                
                                                                                                              
        get_next_data (c$edd_tape_block_size, data_buffer_p, bytes_read, status);                             
        IF NOT status.normal THEN                                                                             
          RETURN;  {---->                                                                                     
        IFEND;                                                                                                
                                                                                                              
        IF (bytes_read = 0) OR ((v$file_position = amc$eoi) AND (index <> number_of_blocks)) THEN             
          osp$set_status_abnormal (duc$dump_analyzer_id, due$unexpected_eoi, v$file_name_p^, status);         
          osp$append_status_parameter (osc$status_parameter_delimiter, 'the buffer controlware', status);     
          RETURN;  {---->                                                                                     
        IFEND;                                                                                                
        total_bytes_read := total_bytes_read + bytes_read;                                                    
      FOREND;                                                                                                 
      v$last_other_record_p^.size := total_bytes_read;                                                        
                                                                                                              
      { Move the controlware to the restart file.  Each 8-bit piece is embedded, right justified, into a      
      { 12-bit PP byte.  Move just the 8-bit piece of each 12-bit PP byte.                                    
                                                                                                              
      RESET data_buffer_seq_p;                                                                                
      NEXT data_buffer_array_p: [1 .. controlware_size] IN data_buffer_seq_p;                                 
      IF data_buffer_array_p = NIL THEN                                                                       
        osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                          
        RETURN;  {---->                                                                                       
      IFEND;                                                                                                  
      NEXT restart_file_array_p: [1 .. controlware_size] IN                                                   
            duv$execution_environment.data_file_p^.segment_pointer.sequence_pointer;                          
      IF restart_file_array_p = NIL THEN                                                                      
        osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                          
        RETURN;  {---->                                                                                       
      IFEND;                                                                                                  
      FOR index := 1 TO controlware_size DO                                                                   
        restart_file_array_p^ [index] := data_buffer_array_p^ [index].data;                                   
      FOREND;                                                                                                 
                                                                                                              
      NEXT buffer_controlware_entry_p IN duv$execution_environment.data_file_p^.segment_pointer.              
            sequence_pointer;                                                                                 
      IF buffer_controlware_entry_p = NIL THEN                                                                
        osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                          
        RETURN;  {---->                                                                                       
      IFEND;                                                                                                  
      IF NOT duv$dump_environment_p^.buffer_controlware.available THEN                                        
        duv$dump_environment_p^.buffer_controlware.available := TRUE;                                         
        duv$dump_environment_p^.buffer_controlware.first_bc_entry := #OFFSET (buffer_controlware_entry_p);    
      ELSE                                                                                                    
        v$last_bc_entry_p^.next_bc_entry := #OFFSET (buffer_controlware_entry_p);                             
      IFEND;                                                                                                  
      v$last_bc_entry_p := buffer_controlware_entry_p;                                                        
      duv$dump_environment_p^.buffer_controlware.number_of_entries :=                                         
            duv$dump_environment_p^.buffer_controlware.number_of_entries + 1;                                 
      buffer_controlware_entry_p^.channel_number := channel;                                                  
      buffer_controlware_entry_p^.channel_type := channel_type;                                               
      buffer_controlware_entry_p^.words := controlware_size DIV 2;                                            
      buffer_controlware_entry_p^.first_byte := #OFFSET (restart_file_array_p);                               
      buffer_controlware_entry_p^.next_bc_entry := 0;                                                         
                                                                                                              
      { Return if finished reading the controlware.                                                           
                                                                                                              
      IF v$file_position = amc$eoi THEN                                                                       
        RETURN;  {---->                                                                                       
      IFEND;                                                                                                  
      first_pass := FALSE;                                                                                    
    WHILEND;                                                                                                  
                                                                                                              
  PROCEND read_buffer_controlware;                                                                            
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'read_central_memory', EJECT ??                                                                
                                                                                                              
{ PURPOSE:                                                                                                    
{   This procedure reads the central memory from the dump file and places it on the memory file.              
                                                                                                              
  PROCEDURE read_central_memory                                                                               
    (VAR dump_label: t$dump_label;                                                                            
     VAR status: ost$status);                                                                                 
                                                                                                              
    CONST                                                                                                     
      c$max_byte_length = 0ffffffff(16);                                                                      
                                                                                                              
    VAR                                                                                                       
      adjust_dump_label: boolean,                                                                             
      bytes_read: amt$transfer_count,                                                                         
      current_block_index: integer,                                                                           
      data_buffer_p: ^SEQ ( * ),                                                                              
      data_buffer_seq: SEQ (REP c$edd_tape_block_size OF cell),                                               
      data_buffer_seq_p: ^SEQ ( * ),                                                                          
      display_message: string (ofc$max_display_message),                                                      
      first_word_address: 0 .. 0fffffff(16),                                                                  
      local_status: ost$status,                                                                               
      memory_file_p: ^SEQ ( * ),                                                                              
      message_length: integer,                                                                                
      total_block_length: integer,                                                                            
      total_bytes_read: integer;                                                                              
                                                                                                              
    status.normal := TRUE;                                                                                    
    adjust_dump_label := FALSE;                                                                               
    ofp$display_status_message ('reading central memory', status);                                            
                                                                                                              
 { Determine the total number of tape blocks that need to be read.                                            
    IF dump_label.length = 0 THEN                                                                             
      total_block_length := c$max_byte_length DIV c$edd_tape_block_size;                                      
    ELSEIF (dump_label.length >= 07fe0000(16)) AND (dump_label.first_word_address > 0) THEN                   
      adjust_dump_label := true;                                                                              
      total_block_length := 2147483648 DIV c$edd_tape_block_size;                                             
      clp$put_display (duv$execution_environment.output_file.display_control, 'MEM Dump Label adjusted.',     
            clc$no_trim, local_status);                                                                       
    ELSE                                                                                                      
      total_block_length := (dump_label.length * 8) DIV c$edd_tape_block_size;                                
      IF ((dump_label.length * 8) MOD c$edd_tape_block_size) <> 0 THEN                                        
        total_block_length := total_block_length + 1;                                                         
      IFEND;                                                                                                  
    IFEND;                                                                                                    
                                                                                                              
    IF adjust_dump_label THEN                                                                                 
      first_word_address := 0;                                                                                
    ELSE                                                                                                      
      first_word_address := dump_label.first_word_address;                                                    
    IFEND;                                                                                                    
                                                                                                              
 { Retrieve the offset into the memory file of where the memory data will be placed.                          
    NEXT memory_file_p: [[REP 1 OF cell]] IN duv$execution_environment.memory_file_p^.segment_pointer.        
          sequence_pointer;                                                                                   
    IF memory_file_p = NIL THEN                                                                               
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                            
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
    RESET memory_file_p;                                                                                      
    duv$dump_environment_p^.central_memory.bias := #OFFSET (memory_file_p);                                   
    RESET duv$execution_environment.memory_file_p^.segment_pointer.sequence_pointer TO memory_file_p;         
                                                                                                              
    mmp$set_access_selections (duv$execution_environment.memory_file_p^.segment_pointer.sequence_pointer,     
          mmc$as_sequential, local_status);                                                                   
    IF NOT local_status.normal THEN                                                                           
      dup$display_message (local_status, v$display_control);                                                  
    IFEND;                                                                                                    
                                                                                                              
    data_buffer_seq_p := ^data_buffer_seq;                                                                    
    IF data_buffer_seq_p = NIL THEN                                                                           
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                            
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
                                                                                                              
{ Move the data from the dump file to the memory file.                                                        
    total_bytes_read := 0;                                                                                    
                                                                                                              
   /read_memory/                                                                                              
    FOR current_block_index := 1 TO total_block_length DO                                                     
      IF (current_block_index MOD 10) = 0 THEN                                                                
        STRINGREP (display_message, message_length, 'reading central memory block', current_block_index,      
              ' of', total_block_length);                                                                     
        ofp$display_status_message (display_message (1, message_length), local_status);                       
      IFEND;                                                                                                  
                                                                                                              
      RESET data_buffer_seq_p;                                                                                
      get_next_data (c$edd_tape_block_size, data_buffer_seq_p, bytes_read, status);                           
      IF NOT status.normal THEN                                                                               
        EXIT /read_memory/;  {---->                                                                           
      IFEND;                                                                                                  
      IF bytes_read = 0 THEN                                                                                  
        IF NOT adjust_dump_label THEN                                                                         
          osp$set_status_abnormal (duc$dump_analyzer_id, due$unexpected_eoi, v$file_name_p^, status);         
          osp$append_status_parameter (osc$status_parameter_delimiter, 'the central memory', status);         
          osp$append_status_parameter (osc$status_parameter_delimiter,                                        
                'The central memory image is incomplete.', status);                                           
        IFEND;                                                                                                
        EXIT /read_memory/;  {---->                                                                           
      IFEND;                                                                                                  
                                                                                                              
      IF (dump_label.length = 0) AND (bytes_read = #SIZE (t$edd_label)) THEN                                  
        process_label_record (data_buffer_seq_p, dump_label);                                                 
        EXIT /read_memory/; {---->                                                                            
      IFEND;                                                                                                  
                                                                                                              
      NEXT memory_file_p: [[REP bytes_read OF cell]] IN duv$execution_environment.memory_file_p^.             
            segment_pointer.sequence_pointer;                                                                 
      IF memory_file_p = NIL THEN                                                                             
        osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                          
        EXIT /read_memory/;  {---->                                                                           
      IFEND;                                                                                                  
      RESET data_buffer_seq_p;                                                                                
      NEXT data_buffer_p: [[REP bytes_read OF cell]] IN data_buffer_seq_p;                                    
      IF data_buffer_p = NIL THEN                                                                             
        osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                          
        EXIT /read_memory/;  {---->                                                                           
      IFEND;                                                                                                  
      memory_file_p^ := data_buffer_p^;                                                                       
                                                                                                              
      total_bytes_read := total_bytes_read + bytes_read;                                                      
      IF v$file_position = amc$eoi THEN                                                                       
        EXIT /read_memory/;  {---->                                                                           
      IFEND;                                                                                                  
    FOREND /read_memory/;                                                                                     
                                                                                                              
    v$last_other_record_p^.size := total_bytes_read;                                                          
    IF total_bytes_read > 0 THEN                                                                              
      duv$dump_environment_p^.central_memory.available := TRUE;                                               
      duv$dump_environment_p^.central_memory.first_byte := first_word_address * 8;                            
      duv$dump_environment_p^.central_memory.last_byte := duv$dump_environment_p^.central_memory.first_byte + 
            total_bytes_read - 1;                                                                             
    IFEND;                                                                                                    
    mmp$set_access_selections (duv$execution_environment.memory_file_p^.segment_pointer.sequence_pointer,     
          mmc$as_random, local_status);                                                                       
                                                                                                              
  PROCEND read_central_memory;                                                                                
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'read_control_store', EJECT ??                                                                 
                                                                                                              
{ PURPOSE:                                                                                                    
{   This procedure reads the control store from the dump file and places it on the restart file.              
                                                                                                              
  PROCEDURE read_control_store                                                                                
    (VAR dump_label: t$dump_label;                                                                            
     VAR status: ost$status);                                                                                 
                                                                                                              
    VAR                                                                                                       
      bytes_read: amt$transfer_count,                                                                         
      control_store_buffer_p: ^SEQ ( * ),                                                                     
      control_store_size: 0 .. duc$de_control_store_size,                                                     
      control_store_p: ^SEQ ( * ),                                                                            
      current_block_index: 0 .. duc$de_control_store_size,                                                    
      data_buffer_p: ^SEQ ( * ),                                                                              
      data_buffer_seq: SEQ (REP c$edd_tape_block_size OF cell),                                               
      data_buffer_seq_p: ^SEQ ( * ),                                                                          
      processor: 0 .. duc$de_maximum_processors,                                                              
      shadow_control_store: boolean,                                                                          
      total_block_length: 0 .. duc$de_control_store_size,                                                     
      total_bytes_read: amt$transfer_count;                                                                   
                                                                                                              
    status.normal := TRUE;                                                                                    
                                                                                                              
    ofp$display_status_message ('reading processor control store (microcode)', status);                       
    shadow_control_store := dump_label.shadow_control_store;                                                  
                                                                                                              
    { Determine which processor to use.                                                                       
                                                                                                              
   /find_processor/                                                                                           
    FOR processor := 0 TO duc$de_maximum_processors DO                                                        
      IF shadow_control_store THEN                                                                            
        IF NOT duv$dump_environment_p^.control_store.shadow [processor].available THEN                        
          EXIT /find_processor/;  {---->                                                                      
        IFEND;                                                                                                
      ELSE                                                                                                    
        IF NOT duv$dump_environment_p^.control_store.main [processor].available THEN                          
          EXIT /find_processor/;  {---->                                                                      
        IFEND;                                                                                                
      IFEND;                                                                                                  
    FOREND /find_processor/;                                                                                  
                                                                                                              
    { Determine the total number of tape blocks that need to be read.                                         
                                                                                                              
    total_block_length := duc$de_control_store_size * 16 DIV c$edd_tape_block_size;                           
    IF (duc$de_control_store_size *16) MOD c$edd_tape_block_size <> 0 THEN                                    
      total_block_length := total_block_length + 1;                                                           
    IFEND;                                                                                                    
                                                                                                              
    NEXT control_store_p: [[REP 1 OF cell]] IN duv$execution_environment.data_file_p^.segment_pointer.        
          sequence_pointer;                                                                                   
    IF control_store_p = NIL THEN                                                                             
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                            
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
    RESET control_store_p;                                                                                    
    RESET duv$execution_environment.data_file_p^.segment_pointer.sequence_pointer TO control_store_p;         
                                                                                                              
    { Move the control store from the dump file to the restart file.                                          
                                                                                                              
    control_store_size := 0;                                                                                  
    data_buffer_seq_p := ^data_buffer_seq;                                                                    
    IF data_buffer_seq_p = NIL THEN                                                                           
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                            
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
    RESET data_buffer_seq_p;                                                                                  
    total_bytes_read := 0;                                                                                    
                                                                                                              
   /read_cs_blocks/                                                                                           
    FOR current_block_index := 1 TO total_block_length DO                                                     
      RESET data_buffer_seq_p;                                                                                
      get_next_data (c$edd_tape_block_size, data_buffer_seq_p, bytes_read, status);                           
      IF NOT status.normal THEN                                                                               
        EXIT /read_cs_blocks/;  {---->                                                                        
      IFEND;                                                                                                  
                                                                                                              
      IF (bytes_read = 0) OR (v$file_position = amc$eoi) THEN                                                 
        EXIT /read_cs_blocks/;  {---->                                                                        
      IFEND;                                                                                                  
                                                                                                              
      IF bytes_read = #SIZE (t$edd_label) THEN                                                                
        process_label_record (data_buffer_seq_p, dump_label);                                                 
        EXIT /read_cs_blocks/;  {---->                                                                        
      IFEND;                                                                                                  
      total_bytes_read := total_bytes_read + bytes_read;                                                      
                                                                                                              
      NEXT control_store_buffer_p: [[REP bytes_read OF cell]] IN                                              
            duv$execution_environment.data_file_p^.segment_pointer.sequence_pointer;                          
      IF control_store_buffer_p = NIL THEN                                                                    
        osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                          
        EXIT /read_cs_blocks/;  {---->                                                                        
      IFEND;                                                                                                  
      RESET data_buffer_seq_p;                                                                                
      NEXT data_buffer_p: [[REP bytes_read OF cell]] IN data_buffer_seq_p;                                    
      IF data_buffer_p = NIL THEN                                                                             
        osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                          
        EXIT /read_cs_blocks/;  {---->                                                                        
      IFEND;                                                                                                  
      control_store_buffer_p^ := data_buffer_p^;                                                              
                                                                                                              
      control_store_size := control_store_size + bytes_read DIV 16;                                           
    FOREND /read_cs_blocks/;                                                                                  
                                                                                                              
    v$last_other_record_p^.size := total_bytes_read;                                                          
    IF control_store_size > 0 THEN                                                                            
      IF shadow_control_store THEN                                                                            
        duv$dump_environment_p^.control_store.shadow [processor].available := TRUE;                           
        duv$dump_environment_p^.control_store.shadow [processor].size := control_store_size;                  
        duv$dump_environment_p^.control_store.shadow [processor].first_byte := #OFFSET (control_store_p);     
      ELSE                                                                                                    
        duv$dump_environment_p^.control_store.main [processor].available := TRUE;                             
        duv$dump_environment_p^.control_store.main [processor].size := control_store_size;                    
        duv$dump_environment_p^.control_store.main [processor].first_byte := #OFFSET (control_store_p);       
      IFEND;                                                                                                  
    IFEND;                                                                                                    
                                                                                                              
  PROCEND read_control_store;                                                                                 
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'read_critical_memory', EJECT ??                                                               
                                                                                                              
{ PURPOSE:                                                                                                    
{   This procedure reads the critical memory information.                                                     
                                                                                                              
  PROCEDURE read_critical_memory                                                                              
    (VAR dump_label: t$dump_label;                                                                            
     VAR critical_page_table_p: ^array [0 .. * ] of dut$de_critical_page_entry;                               
     VAR status: ost$status);                                                                                 
                                                                                                              
    VAR                                                                                                       
      bytes_read: amt$transfer_count,                                                                         
      ccm_record_p: ^SEQ ( * ),                                                                               
      cxm_record_p: ^SEQ ( * ),                                                                               
      page_number: 0 .. 0ffffffff(16),                                                                        
      save_ccm_record_p: ^SEQ ( * ),                                                                          
      total_bytes_read: amt$transfer_count;                                                                   
                                                                                                              
    status.normal := TRUE;                                                                                    
                                                                                                              
    ofp$display_status_message ('reading critical memory', status);                                           
                                                                                                              
    { Enter the page in the critical page table.                                                              
                                                                                                              
    NEXT ccm_record_p: [[REP 1 OF cell]] IN duv$execution_environment.memory_file_p^.segment_pointer.         
          sequence_pointer;                                                                                   
    IF ccm_record_p = NIL THEN                                                                                
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                            
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
    save_ccm_record_p := ccm_record_p;                                                                        
    page_number := dump_label.page_number;                                                                    
    RESET duv$execution_environment.memory_file_p^.segment_pointer.sequence_pointer TO ccm_record_p;          
    total_bytes_read := 0;                                                                                    
    cxm_record_p := ccm_record_p;                                                                             
                                                                                                              
   /read_ccm_record/                                                                                          
    REPEAT                                                                                                    
      NEXT ccm_record_p: [[REP c$edd_tape_block_size OF cell]] IN                                             
            duv$execution_environment.memory_file_p^.segment_pointer.sequence_pointer;                        
      IF ccm_record_p = NIL THEN                                                                              
        osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                          
        EXIT /read_ccm_record/;  {---->                                                                       
      IFEND;                                                                                                  
                                                                                                              
      get_next_data (c$edd_tape_block_size, ccm_record_p, bytes_read, status);                                
      IF NOT status.normal THEN                                                                               
        EXIT /read_ccm_record/;  {---->                                                                       
      IFEND;                                                                                                  
      IF bytes_read = 0 THEN                                                                                  
        osp$set_status_abnormal (duc$dump_analyzer_id, due$unexpected_eoi, v$file_name_p^, status);           
        osp$append_status_parameter (osc$status_parameter_delimiter, 'the critical memory', status);          
        EXIT /read_ccm_record/;  {---->                                                                       
      IFEND;                                                                                                  
                                                                                                              
      IF bytes_read = #SIZE (t$edd_label) THEN                                                                
        RESET duv$execution_environment.memory_file_p^.segment_pointer.sequence_pointer TO ccm_record_p;      
        process_label_record (ccm_record_p, dump_label);                                                      
        EXIT /read_ccm_record/;  {---->                                                                       
      IFEND;                                                                                                  
                                                                                                              
      total_bytes_read := total_bytes_read + bytes_read;                                                      
      IF v$file_position = amc$eoi THEN                                                                       
        EXIT /read_ccm_record/;  {---->                                                                       
      IFEND;                                                                                                  
    UNTIL (bytes_read < c$edd_tape_block_size);  {/read_ccm_record/}                                          
                                                                                                              
    v$last_other_record_p^.size := total_bytes_read;                                                          
    IF total_bytes_read > 0 THEN                                                                              
      RESET duv$execution_environment.memory_file_p^.segment_pointer.sequence_pointer TO cxm_record_p;        
      NEXT cxm_record_p: [[REP duv$dump_environment_p^.critical_memory.page_size OF cell]] IN                 
            duv$execution_environment.memory_file_p^.segment_pointer.sequence_pointer;                        
      IF cxm_record_p = NIL THEN                                                                              
        osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                          
        RETURN;  {---->                                                                                       
      IFEND;                                                                                                  
      duv$dump_environment_p^.critical_memory.current_page_offset := #OFFSET (save_ccm_record_p);             
      critical_page_table_p^ [page_number].available := TRUE;                                                 
      critical_page_table_p^ [page_number].page_offset := #OFFSET (save_ccm_record_p);                        
      IF NOT duv$dump_environment_p^.critical_memory.available THEN                                           
        duv$dump_environment_p^.critical_memory.available := TRUE;                                            
        duv$dump_environment_p^.critical_memory.first_page := #OFFSET (save_ccm_record_p);                    
        duv$dump_environment_p^.critical_memory.first_rma_available :=                                        
              page_number * duv$dump_environment_p^.critical_memory.page_size;                                
        duv$dump_environment_p^.critical_memory.total_ccm_size := 0;                                          
        duv$dump_environment_p^.critical_memory.multiple_ccm_exists := FALSE;                                 
      ELSE                                                                                                    
        duv$dump_environment_p^.critical_memory.multiple_ccm_exists := TRUE;                                  
      IFEND;                                                                                                  
      duv$dump_environment_p^.critical_memory.last_rma_available :=                                           
            ((page_number + 1) * duv$dump_environment_p^.critical_memory.page_size) - 1;                      
      duv$dump_environment_p^.critical_memory.current_page_offset :=                                          
            duv$dump_environment_p^.critical_memory.current_page_offset +                                     
            duv$dump_environment_p^.critical_memory.page_size;                                                
      duv$dump_environment_p^.critical_memory.last_ccm_other_record := #OFFSET (v$last_other_record_p);       
      duv$dump_environment_p^.critical_memory.total_ccm_size :=                                               
            duv$dump_environment_p^.critical_memory.total_ccm_size + total_bytes_read;                        
    IFEND;                                                                                                    
                                                                                                              
  PROCEND read_critical_memory;                                                                               
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'read_critical_page_table', EJECT ??                                                           
                                                                                                              
{ PURPOSE:                                                                                                    
{   This procedure reads the critical page table.                                                             
                                                                                                              
  PROCEDURE read_critical_page_table                                                                          
    (VAR dump_label: t$dump_label;                                                                            
     VAR critical_page_table_p: ^array [0 .. * ] of dut$de_critical_page_entry;                               
     VAR status: ost$status);                                                                                 
                                                                                                              
    VAR                                                                                                       
      bytes_read: amt$transfer_count,                                                                         
      cpt_record_p: ^SEQ ( * ),                                                                               
      index: 0 .. 0ffffffff(16),                                                                              
      number_page_entries: 0 .. 0ffffffff(16),                                                                
      page_mask: 0 .. 7f(16),                                                                                 
      page_table_length: 0 .. 3ffff(16),                                                                      
      total_bytes_read: amt$transfer_count;                                                                   
                                                                                                              
    status.normal := TRUE;                                                                                    
                                                                                                              
    ofp$display_status_message ('reading critical page table', status);                                       
                                                                                                              
    { Calculate the page size based on the page size mask in the CPT record label.                            
                                                                                                              
    duv$dump_environment_p^.critical_memory.page_size := 2048;                                                
    page_mask := dump_label.page_size_mask DIV 4;                                                             
    page_table_length := dump_label.page_table_length;                                                        
                                                                                                              
   /mask_loop/                                                                                                
    FOR index := 1 to 5 DO                                                                                    
      IF page_mask MOD 2 = 1 THEN                                                                             
        EXIT /mask_loop/;  {---->                                                                             
      IFEND;                                                                                                  
      duv$dump_environment_p^.critical_memory.page_size :=                                                    
            duv$dump_environment_p^.critical_memory.page_size * 2;                                            
      page_mask := page_mask DIV 2;                                                                           
    FOREND /mask_loop/;                                                                                       
                                                                                                              
    NEXT cpt_record_p: [[REP 1 OF cell]] IN duv$execution_environment.data_file_p^.segment_pointer.           
          sequence_pointer;                                                                                   
    IF cpt_record_p = NIL THEN                                                                                
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                            
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
    duv$dump_environment_p^.critical_memory.cpt_start := #OFFSET (cpt_record_p);                              
    RESET duv$execution_environment.data_file_p^.segment_pointer.sequence_pointer TO cpt_record_p;            
    total_bytes_read := 0;                                                                                    
                                                                                                              
   /read_cpt_record/                                                                                          
    WHILE TRUE DO                                                                                             
      NEXT cpt_record_p: [[REP c$edd_tape_block_size OF cell]] IN                                             
            duv$execution_environment.data_file_p^.segment_pointer.sequence_pointer;                          
      IF cpt_record_p = NIL THEN                                                                              
        osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                          
        EXIT /read_cpt_record/;  {---->                                                                       
      IFEND;                                                                                                  
                                                                                                              
      get_next_data (c$edd_tape_block_size, cpt_record_p, bytes_read, status);                                
      IF NOT status.normal THEN                                                                               
        EXIT /read_cpt_record/;  {---->                                                                       
      IFEND;                                                                                                  
                                                                                                              
      IF (bytes_read = 0) OR (v$file_position = amc$eoi) THEN                                                 
        EXIT /read_cpt_record/;  {---->                                                                       
      IFEND;                                                                                                  
                                                                                                              
      IF bytes_read = #SIZE (t$edd_label) THEN                                                                
        RESET duv$execution_environment.data_file_p^.segment_pointer.sequence_pointer TO cpt_record_p;        
        process_label_record (cpt_record_p, dump_label);                                                      
        RESET duv$execution_environment.data_file_p^.segment_pointer.sequence_pointer TO cpt_record_p;        
        EXIT /read_cpt_record/;  {---->                                                                       
      IFEND;                                                                                                  
      total_bytes_read := total_bytes_read + bytes_read;                                                      
                                                                                                              
      IF v$file_position = amc$eoi THEN                                                                       
        EXIT /read_cpt_record/;  {---->                                                                       
      IFEND;                                                                                                  
    WHILEND /read_cpt_record/;                                                                                
                                                                                                              
    v$last_other_record_p^.size := total_bytes_read;                                                          
    duv$dump_environment_p^.critical_memory.page_table_size := page_table_length;                             
    number_page_entries := page_table_length * 64;                                                            
    duv$dump_environment_p^.critical_memory.cpt_end := duv$dump_environment_p^.critical_memory.cpt_start +    
          page_table_length * 8;                                                                              
                                                                                                              
    { Allocate and initialize all critical page entries.                                                      
                                                                                                              
    NEXT critical_page_table_p: [0 .. (number_page_entries - 1)] IN                                           
          duv$execution_environment.data_file_p^.segment_pointer.sequence_pointer;                            
    IF critical_page_table_p = NIL THEN                                                                       
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                            
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
    duv$dump_environment_p^.critical_memory.critical_page_table_offset := #OFFSET (critical_page_table_p);    
    FOR index := 0 TO (number_page_entries - 1) DO                                                            
      critical_page_table_p^ [index].available := FALSE;                                                      
    FOREND;                                                                                                   
                                                                                                              
  PROCEND read_critical_page_table;                                                                           
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'read_dump_identifier', EJECT ??                                                               
                                                                                                              
{ PURPOSE:                                                                                                    
{   This procedure reads the dump identifier from the dump file and places it on the restart file.            
                                                                                                              
  PROCEDURE read_dump_identifier                                                                              
    (VAR dump_label: t$dump_label;                                                                            
     VAR status: ost$status);                                                                                 
                                                                                                              
    VAR                                                                                                       
      bytes_read: amt$transfer_count,                                                                         
      data_buffer_p: ^SEQ ( * ),                                                                              
      data_buffer_seq: SEQ (REP c$edd_tape_block_size OF cell),                                               
      data_buffer_seq_p: ^SEQ ( * ),                                                                          
      did_record_p: ^SEQ ( * ),                                                                               
      local_status: ost$status;                                                                               
                                                                                                              
    status.normal := TRUE;                                                                                    
                                                                                                              
    ofp$display_status_message ('reading the dump identifier', status);                                       
                                                                                                              
    mmp$set_access_selections (duv$execution_environment.data_file_p^.segment_pointer.sequence_pointer,       
          mmc$as_sequential, local_status);                                                                   
    IF NOT local_status.normal THEN                                                                           
      dup$display_message (local_status, v$display_control);                                                  
    IFEND;                                                                                                    
                                                                                                              
    data_buffer_seq_p := ^data_buffer_seq;                                                                    
    IF data_buffer_seq_p = NIL THEN                                                                           
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                            
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
                                                                                                              
    { By agreement between EDD and *RUN, this record will not exceed a tape block in size - but its size is   
    { not identical between the two dump types.                                                               
                                                                                                              
    RESET data_buffer_seq_p;                                                                                  
    get_next_data (c$edd_tape_block_size, data_buffer_seq_p, bytes_read, status);                             
    IF NOT status.normal THEN                                                                                 
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
    IF bytes_read = 0 THEN                                                                                    
      osp$set_status_abnormal (duc$dump_analyzer_id, due$unexpected_eoi, v$file_name_p^, status);             
      osp$append_status_parameter (osc$status_parameter_delimiter, 'the dump identifier', status);            
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
    v$last_other_record_p^.size := bytes_read;                                                                
                                                                                                              
    NEXT did_record_p: [[REP bytes_read OF cell]] IN duv$execution_environment.data_file_p^.segment_pointer.  
          sequence_pointer;                                                                                   
    IF did_record_p = NIL THEN                                                                                
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                            
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
    RESET data_buffer_seq_p;                                                                                  
    NEXT data_buffer_p: [[REP bytes_read OF cell]] IN data_buffer_seq_p;                                      
    IF data_buffer_p = NIL THEN                                                                               
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                            
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
    did_record_p^ := data_buffer_p^;                                                                          
                                                                                                              
    duv$dump_environment_p^.dump_identifier.available := TRUE;                                                
    duv$dump_environment_p^.dump_identifier.first_byte := #OFFSET (did_record_p);                             
    duv$dump_environment_p^.dump_identifier.size := bytes_read;                                               
    duv$dump_environment_p^.dump_identifier.edd_revision_level := dump_label.edd_revision_level;              
                                                                                                              
    mmp$set_access_selections (duv$execution_environment.data_file_p^.segment_pointer.sequence_pointer,       
          mmc$as_random, local_status);                                                                       
                                                                                                              
  PROCEND read_dump_identifier;                                                                               
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'read_exchange_package', EJECT ??                                                              
                                                                                                              
{ PURPOSE:                                                                                                    
{   This procedure reads the exchange package from the dump file and places it on the restart file.           
                                                                                                              
  PROCEDURE read_exchange_package                                                                             
    (VAR dump_label: t$dump_label;                                                                            
     VAR status: ost$status);                                                                                 
                                                                                                              
    VAR                                                                                                       
      bytes_read: amt$transfer_count,                                                                         
      data_buffer_seq: SEQ (REP c$edd_tape_block_size OF cell),                                               
      data_buffer_seq_p: ^SEQ ( * ),                                                                          
      exchange_package_p: ^dut$exchange_package,                                                              
      processor: 0 .. duc$de_maximum_processors;                                                              
                                                                                                              
    status.normal := TRUE;                                                                                    
                                                                                                              
    CASE dump_label.kind OF                                                                                   
    = c$dlk_pxp_label, c$dlk_px0_label, c$dlk_px1_label =                                                     
      ofp$display_status_message ('reading processor exchange package', status);                              
    = c$dlk_jps_label, c$dlk_jp0_label, c$dlk_jp1_label =                                                     
      ofp$display_status_message ('reading job exchange package', status);                                    
    ELSE  { = c$dlk_mps_label, c$dlk_mp0_label, c$dlk_mp1_label = }                                           
      ofp$display_status_message ('reading monitor exchange package', status);                                
    CASEND;                                                                                                   
                                                                                                              
    data_buffer_seq_p := ^data_buffer_seq;                                                                    
    RESET data_buffer_seq_p;                                                                                  
                                                                                                              
    get_next_data (c$edd_tape_block_size, data_buffer_seq_p, bytes_read, status);                             
    IF NOT status.normal THEN                                                                                 
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
    IF bytes_read = 0 THEN                                                                                    
      osp$set_status_abnormal (duc$dump_analyzer_id, due$unexpected_eoi, v$file_name_p^, status);             
      osp$append_status_parameter (osc$status_parameter_delimiter, 'the exchange package', status);           
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
    IF bytes_read = #SIZE (t$edd_label) THEN                                                                  
      process_label_record (data_buffer_seq_p, dump_label);                                                   
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
    v$last_other_record_p^.size := bytes_read;                                                                
                                                                                                              
    IF bytes_read < #SIZE (dut$exchange_package) THEN                                                         
      osp$set_status_abnormal (duc$dump_analyzer_id, due$dump_file_format_error, v$file_name_p^, status);     
      osp$append_status_parameter (osc$status_parameter_delimiter,                                            
            'The processor exchange package record is shorter than expected.', status);                       
      dup$display_message (status, v$display_control);                                                        
      status.normal := TRUE;                                                                                  
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
                                                                                                              
    NEXT exchange_package_p IN data_buffer_seq_p;                                                             
    IF exchange_package_p = NIL THEN                                                                          
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                            
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
                                                                                                              
    CASE dump_label.kind OF                                                                                   
    = c$dlk_pxp_label =                                                                                       
                                                                                                              
     /find_active_slot/                                                                                       
      FOR processor := 0 TO duc$de_maximum_processors DO                                                      
        IF NOT duv$dump_environment_p^.active_exchange [processor].available THEN                             
          EXIT /find_active_slot/;  {---->                                                                    
        IFEND;                                                                                                
      FOREND /find_active_slot/;                                                                              
      duv$dump_environment_p^.active_exchange [processor].available := TRUE;                                  
      duv$dump_environment_p^.active_exchange [processor].value := exchange_package_p^;                       
      duv$dump_environment_p^.active_exchange [processor].radial_mci := dump_label.radial_mci;                
                                                                                                              
    = c$dlk_px0_label =                                                                                       
                                                                                                              
      duv$dump_environment_p^.active_exchange [0].available := TRUE;                                          
      duv$dump_environment_p^.active_exchange [0].value := exchange_package_p^;                               
      duv$dump_environment_p^.active_exchange [0].radial_mci := dump_label.radial_mci;                        
                                                                                                              
    = c$dlk_px1_label =                                                                                       
                                                                                                              
      duv$dump_environment_p^.active_exchange [1].available := TRUE;                                          
      duv$dump_environment_p^.active_exchange [1].value := exchange_package_p^;                               
      duv$dump_environment_p^.active_exchange [1].radial_mci := dump_label.radial_mci;                        
                                                                                                              
    = c$dlk_jps_label =                                                                                       
                                                                                                              
     /find_jps_slot/                                                                                          
      FOR processor := 0 TO duc$de_maximum_processors DO                                                      
        IF NOT duv$dump_environment_p^.jps_exchange [processor].available THEN                                
          EXIT /find_jps_slot/;  {---->                                                                       
        IFEND;                                                                                                
      FOREND /find_jps_slot/;                                                                                 
      duv$dump_environment_p^.jps_exchange [processor].available := TRUE;                                     
      duv$dump_environment_p^.jps_exchange [processor].value := exchange_package_p^;                          
      duv$dump_environment_p^.jps_exchange [processor].radial_mci := dump_label.radial_mci;                   
                                                                                                              
    = c$dlk_jp0_label =                                                                                       
                                                                                                              
      duv$dump_environment_p^.jps_exchange [0].available := TRUE;                                             
      duv$dump_environment_p^.jps_exchange [0].value := exchange_package_p^;                                  
      duv$dump_environment_p^.jps_exchange [0].radial_mci := dump_label.radial_mci;                           
                                                                                                              
    = c$dlk_jp1_label =                                                                                       
                                                                                                              
      duv$dump_environment_p^.jps_exchange [1].available := TRUE;                                             
      duv$dump_environment_p^.jps_exchange [1].value := exchange_package_p^;                                  
      duv$dump_environment_p^.jps_exchange [1].radial_mci := dump_label.radial_mci;                           
                                                                                                              
    = c$dlk_mps_label =                                                                                       
                                                                                                              
     /find_mps_slot/                                                                                          
      FOR processor := 0 TO duc$de_maximum_processors DO                                                      
        IF NOT duv$dump_environment_p^.mps_exchange [processor].available THEN                                
          EXIT /find_mps_slot/;  {---->                                                                       
        IFEND;                                                                                                
      FOREND /find_mps_slot/;                                                                                 
      duv$dump_environment_p^.mps_exchange [processor].available := TRUE;                                     
      duv$dump_environment_p^.mps_exchange [processor].value := exchange_package_p^;                          
      duv$dump_environment_p^.mps_exchange [processor].radial_mci := dump_label.radial_mci;                   
                                                                                                              
    = c$dlk_mp0_label =                                                                                       
                                                                                                              
      duv$dump_environment_p^.mps_exchange [0].available := TRUE;                                             
      duv$dump_environment_p^.mps_exchange [0].value := exchange_package_p^;                                  
      duv$dump_environment_p^.mps_exchange [0].radial_mci := dump_label.radial_mci;                           
                                                                                                              
    ELSE  { = c$dlk_mp1_label = }                                                                             
                                                                                                              
      duv$dump_environment_p^.mps_exchange [1].available := TRUE;                                             
      duv$dump_environment_p^.mps_exchange [1].value := exchange_package_p^;                                  
      duv$dump_environment_p^.mps_exchange [1].radial_mci := dump_label.radial_mci;                           
    CASEND;                                                                                                   
                                                                                                              
  PROCEND read_exchange_package;                                                                              
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'read_label_record', EJECT ??                                                                  
                                                                                                              
{ PURPOSE:                                                                                                    
{   This procedure reads the EDD label from the dump file and produces a dump label.                          
                                                                                                              
  PROCEDURE read_label_record                                                                                 
    (VAR dump_label: t$dump_label;                                                                            
     VAR status: ost$status);                                                                                 
                                                                                                              
    VAR                                                                                                       
      bytes_read: amt$transfer_count,                                                                         
      display_message: boolean,                                                                               
      label_buffer_seq: SEQ (REP c$edd_tape_block_size OF cell),                                              
      label_buffer_seq_p: ^SEQ ( * );                                                                         
                                                                                                              
    status.normal := TRUE;                                                                                    
    label_buffer_seq_p := ^label_buffer_seq;                                                                  
    display_message := TRUE;                                                                                  
                                                                                                              
    WHILE TRUE DO                                                                                             
      RESET label_buffer_seq_p;                                                                               
      get_next_data (c$edd_tape_block_size, label_buffer_seq_p, bytes_read, status);                          
      IF NOT status.normal THEN                                                                               
        RETURN;  {---->                                                                                       
      IFEND;                                                                                                  
                                                                                                              
      IF (bytes_read = 0) OR (v$file_position = amc$eoi) THEN                                                 
        RETURN;  {---->                                                                                       
      IFEND;                                                                                                  
                                                                                                              
      IF bytes_read = #SIZE (t$edd_label) THEN                                                                
        process_label_record (label_buffer_seq_p, dump_label);                                                
        RETURN;  {---->                                                                                       
      IFEND;                                                                                                  
                                                                                                              
      IF display_message THEN                                                                                 
        osp$set_status_abnormal (duc$dump_analyzer_id, due$dump_file_format_error, v$file_name_p^, status);   
        osp$append_status_parameter (osc$status_parameter_delimiter,                                          
              'A header record is not an expected size.', status);                                            
        dup$display_message (status, v$display_control);                                                      
        status.normal := TRUE;                                                                                
        display_message := FALSE;                                                                             
      IFEND;                                                                                                  
    WHILEND;                                                                                                  
                                                                                                              
  PROCEND read_label_record;                                                                                  
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'read_maintenance_registers', EJECT ??                                                         
                                                                                                              
{ PURPOSE:                                                                                                    
{   This procedure reads the maintenance registers from the dump file and places them on the restart file.    
                                                                                                              
  PROCEDURE read_maintenance_registers                                                                        
    (VAR dump_label: t$dump_label;                                                                            
     VAR status: ost$status);                                                                                 
                                                                                                              
    TYPE                                                                                                      
      t$register_id = PACKED RECORD                                                                           
        length: 0 .. 0fff(16),                                                                                
        number: 0 .. 0fff(16)                                                                                 
      RECEND;                                                                                                 
                                                                                                              
    VAR                                                                                                       
      byte_count: integer,                                                                                    
      bytes_read: amt$transfer_count,                                                                         
      current_byte: 1 .. duc$de_max_register_length,                                                          
      current_part: 1 .. duc$de_max_register_parts,                                                           
      current_register_length: 0 .. duc$de_max_register_length,                                               
      current_register_offset: 0 .. duc$de_max_register_length,                                               
      data_buffer_seq: SEQ (REP c$edd_tape_block_size OF cell),                                               
      data_buffer_seq_p: ^SEQ ( * ),                                                                          
      maintenance_registers_p: ^ARRAY [ * ] OF dut$de_maintenance_register,                                   
      number_of_register_parts: 0 .. 0fff(16),                                                                
      offset: 0 .. (duc$de_max_register_length * duc$de_max_register_parts),                                  
      processor: 0 .. duc$de_maximum_processors,                                                              
      register_contents_p: ^PACKED ARRAY [ * ] OF 0 .. 0fff(16),                                              
      register_id_p: ^t$register_id,                                                                          
      register_index: 1 .. duc$de_max_register_number,                                                        
      remaining_register: 1 .. (duc$de_max_register_number + 1),                                              
      zero_register: [STATIC, READ] ARRAY [1 .. duc$de_max_register_length] OF 0 .. 0ff(16) :=                
            [REP duc$de_max_register_length OF 0];                                                            
                                                                                                              
    status.normal := TRUE;                                                                                    
                                                                                                              
    CASE dump_label.kind OF                                                                                   
    = c$dlk_pmr_label, c$dlk_pr0_label, c$dlk_pr1_label =                                                     
      ofp$display_status_message ('reading processor maintenance registers', status);                         
    = c$dlk_imr_label =                                                                                       
      ofp$display_status_message ('reading IOU maintenance registers', status);                               
    = c$dlk_im1_label =                                                                                       
      ofp$display_status_message ('reading secondary IOU maintenance registers', status);                     
    ELSE  { = c$dlk_mmr_label = }                                                                             
      ofp$display_status_message ('reading memory maintenance registers', status);                            
    CASEND;                                                                                                   
                                                                                                              
    data_buffer_seq_p := ^data_buffer_seq;                                                                    
    RESET data_buffer_seq_p;                                                                                  
                                                                                                              
    get_next_data (c$edd_tape_block_size, data_buffer_seq_p, bytes_read, status);                             
    IF NOT status.normal THEN                                                                                 
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
    IF bytes_read = 0 THEN                                                                                    
      osp$set_status_abnormal (duc$dump_analyzer_id, due$unexpected_eoi, v$file_name_p^, status);             
      osp$append_status_parameter (osc$status_parameter_delimiter, 'the maintenance registers', status);      
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
    IF bytes_read = #SIZE (t$edd_label) THEN                                                                  
      process_label_record (data_buffer_seq_p, dump_label);                                                   
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
    v$last_other_record_p^.size := bytes_read;                                                                
                                                                                                              
    byte_count := 0;                                                                                          
    current_part := 1;                                                                                        
                                                                                                              
    CASE dump_label.kind OF                                                                                   
    = c$dlk_pmr_label, c$dlk_pr0_label, c$dlk_pr1_label =                                                     
      PUSH maintenance_registers_p: [1 .. duc$de_number_of_pro_mrs_dumped];                                   
    = c$dlk_imr_label, c$dlk_im1_label =                                                                      
      PUSH maintenance_registers_p: [1 .. duc$de_number_of_iou_mrs_dumped];                                   
    ELSE  { = c$dlk_mmr_label = }                                                                             
      PUSH maintenance_registers_p: [1 .. duc$de_number_of_mem_mrs_dumped];                                   
    CASEND;                                                                                                   
    IF maintenance_registers_p = NIL THEN                                                                     
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                            
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
    RESET data_buffer_seq_p;                                                                                  
                                                                                                              
   /read_registers/                                                                                           
    FOR register_index := 1 TO UPPERBOUND (maintenance_registers_p^) DO                                       
                                                                                                              
      maintenance_registers_p^ [register_index].available := FALSE;                                           
      maintenance_registers_p^ [register_index].value := zero_register;                                       
                                                                                                              
      IF current_part = 1 THEN                                                                                
        NEXT register_id_p IN data_buffer_seq_p;                                                              
        IF (register_id_p = NIL) OR (register_id_p^.length = 0) OR                                            
              (register_id_p^.number > duc$de_max_register_number) THEN                                       
          EXIT /read_registers/;  {---->                                                                      
        IFEND;                                                                                                
        NEXT register_contents_p: [1 .. register_id_p^.length] IN data_buffer_seq_p;                          
        IF register_contents_p = NIL THEN                                                                     
          EXIT /read_registers/;  {---->                                                                      
        IFEND;                                                                                                
        number_of_register_parts := register_id_p^.length DIV duc$de_max_register_length;                     
        IF (register_id_p^.length MOD duc$de_max_register_length) <> 0 THEN                                   
          number_of_register_parts := number_of_register_parts + 1;                                           
        IFEND;                                                                                                
      IFEND;                                                                                                  
                                                                                                              
      IF current_part = number_of_register_parts THEN                                                         
        current_register_length := register_id_p^.length MOD duc$de_max_register_length;                      
        IF current_register_length = 0 THEN                                                                   
          current_register_length := duc$de_max_register_length;                                              
        IFEND;                                                                                                
      ELSE                                                                                                    
        current_register_length := duc$de_max_register_length;                                                
      IFEND;                                                                                                  
                                                                                                              
      maintenance_registers_p^ [register_index].available := TRUE;                                            
      maintenance_registers_p^ [register_index].number := register_id_p^.number;                              
      maintenance_registers_p^ [register_index].length := current_register_length;                            
                                                                                                              
      current_register_offset := duc$de_max_register_length - current_register_length;                        
      offset := current_register_offset + ((current_part - 1) * duc$de_max_register_length);                  
      FOR current_byte := 1 TO current_register_length DO                                                     
        maintenance_registers_p^ [register_index].value [current_byte + current_register_offset] :=           
              register_contents_p^ [current_byte + offset];                                                   
      FOREND;                                                                                                 
                                                                                                              
      IF current_part = number_of_register_parts THEN                                                         
        current_part := 1;                                                                                    
        byte_count := byte_count + (((register_id_p^.length + 2) * 3) DIV 2);                                 
        IF byte_count >= bytes_read THEN                                                                      
          EXIT /read_registers/;  {---->                                                                      
        IFEND;                                                                                                
      ELSE                                                                                                    
        current_part := current_part + 1;                                                                     
      IFEND;                                                                                                  
                                                                                                              
    FOREND /read_registers/;                                                                                  
                                                                                                              
    FOR remaining_register := (register_index) + 1 TO UPPERBOUND (maintenance_registers_p^) DO                
      maintenance_registers_p^ [remaining_register].available := FALSE;                                       
    FOREND;                                                                                                   
                                                                                                              
    CASE dump_label.kind OF                                                                                   
    = c$dlk_pmr_label =                                                                                       
                                                                                                              
     /find_processor/                                                                                         
      FOR processor := 0 TO duc$de_maximum_processors DO                                                      
        IF NOT duv$dump_environment_p^.pro_maintenance_registers [processor].available THEN                   
          EXIT /find_processor/;  {---->                                                                      
        IFEND;                                                                                                
      FOREND /find_processor/;                                                                                
      duv$dump_environment_p^.pro_maintenance_registers [processor].available := TRUE;                        
      duv$dump_environment_p^.pro_maintenance_registers [processor].registers := maintenance_registers_p^;    
      duv$dump_environment_p^.pro_maintenance_registers [processor].radial_mci := dump_label.radial_mci;      
                                                                                                              
    = c$dlk_pr0_label =                                                                                       
                                                                                                              
      duv$dump_environment_p^.pro_maintenance_registers [0].available := TRUE;                                
      duv$dump_environment_p^.pro_maintenance_registers [0].registers := maintenance_registers_p^;            
      duv$dump_environment_p^.pro_maintenance_registers [0].radial_mci := dump_label.radial_mci;              
                                                                                                              
    = c$dlk_pr1_label =                                                                                       
                                                                                                              
      duv$dump_environment_p^.pro_maintenance_registers [1].available := TRUE;                                
      duv$dump_environment_p^.pro_maintenance_registers [1].registers := maintenance_registers_p^;            
      duv$dump_environment_p^.pro_maintenance_registers [1].radial_mci := dump_label.radial_mci;              
                                                                                                              
    = c$dlk_imr_label =                                                                                       
      duv$dump_environment_p^.iou_maintenance_registers [0].available := TRUE;                                
      duv$dump_environment_p^.iou_maintenance_registers [0].registers := maintenance_registers_p^;            
                                                                                                              
    = c$dlk_im1_label =                                                                                       
      duv$dump_environment_p^.iou_maintenance_registers [1].available := TRUE;                                
      duv$dump_environment_p^.iou_maintenance_registers [1].registers := maintenance_registers_p^;            
                                                                                                              
    ELSE  { = c$dlk_mmr_label = }                                                                             
      duv$dump_environment_p^.mem_maintenance_registers.available := TRUE;                                    
      duv$dump_environment_p^.mem_maintenance_registers.registers := maintenance_registers_p^;                
    CASEND;                                                                                                   
                                                                                                              
  PROCEND read_maintenance_registers;                                                                         
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'read_only_critical_memory', EJECT ??                                                          
                                                                                                              
{ PURPOSE:                                                                                                    
{   This procedure reads only the critical memory from the dump file and places it on the memory file.        
                                                                                                              
  PROCEDURE read_only_critical_memory                                                                         
    (    critical_page_table_p: ^ARRAY [0 .. *] OF dut$de_critical_page_entry;                                
     VAR dump_label: t$dump_label;                                                                            
     VAR status: ost$status);                                                                                 
                                                                                                              
    VAR                                                                                                       
      bytes_read: amt$transfer_count,                                                                         
      cpt_image_p: ^PACKED ARRAY [0 .. *] OF boolean,                                                         
      cpt_p: ^cell,                                                                                           
      current_block_index: integer,                                                                           
      data_buffer: SEQ (REP c$edd_tape_block_size OF cell),                                                   
      data_buffer_p: ^SEQ ( * ),                                                                              
      data_p: ^SEQ ( * ),                                                                                     
      data_transfer_amount: amt$transfer_count,                                                               
      display_message: string (ofc$max_display_message),                                                      
      memory_data_p: ^SEQ ( * ),                                                                              
      memory_file_p: ^SEQ ( * ),                                                                              
      message_length: integer,                                                                                
      number_page_entries: 0 .. 0ffffffff(16),                                                                
      remainder_to_transfer: 0 .. duc$de_max_page_size,                                                       
      total_bytes_read: amt$transfer_count;                                                                   
                                                                                                              
    status.normal := TRUE;                                                                                    
                                                                                                              
    ofp$display_status_message ('reading critical memory', status);                                           
                                                                                                              
    { Use the critical page table record to determine what pages of central memory to retain on the           
    { memory file.                                                                                            
                                                                                                              
    NEXT memory_file_p: [[REP 1 OF cell]] IN duv$execution_environment.memory_file_p^.segment_pointer.        
          sequence_pointer;                                                                                   
    IF memory_file_p = NIL THEN                                                                               
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                            
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
    cpt_p := #ADDRESS (#RING (duv$execution_environment.data_file_p^.segment_pointer.sequence_pointer),       
          #SEGMENT (duv$execution_environment.data_file_p^.segment_pointer.sequence_pointer),                 
          duv$dump_environment_p^.critical_memory.cpt_start);                                                 
    RESET duv$execution_environment.data_file_p^.segment_pointer.sequence_pointer TO cpt_p;                   
    number_page_entries := duv$dump_environment_p^.critical_memory.page_table_size * 64;                      
    NEXT cpt_image_p: [0 .. number_page_entries - 1] IN duv$execution_environment.data_file_p^.               
          segment_pointer.sequence_pointer;                                                                   
    IF cpt_image_p = NIL THEN                                                                                 
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                            
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
    RESET duv$execution_environment.memory_file_p^.segment_pointer.sequence_pointer TO memory_file_p;         
                                                                                                              
    bytes_read := 0;                                                                                          
    total_bytes_read := 0;                                                                                    
                                                                                                              
    data_buffer_p := ^data_buffer;                                                                            
    IF data_buffer_p = NIL THEN                                                                               
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                            
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
                                                                                                              
   /read_critical_pages/                                                                                      
    FOR current_block_index := 0 TO (number_page_entries - 1) DO                                              
      IF (current_block_index MOD 10) = 0 THEN                                                                
        STRINGREP (display_message, message_length, 'reading critical central memory page',                   
              current_block_index, ' of', (number_page_entries - 1));                                         
        ofp$display_status_message (display_message (1, message_length), status);                             
      IFEND;                                                                                                  
                                                                                                              
      NEXT memory_file_p: [[REP 1 OF cell]] IN duv$execution_environment.memory_file_p^.segment_pointer.      
            sequence_pointer;                                                                                 
      IF memory_file_p = NIL THEN                                                                             
        osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                          
        EXIT /read_critical_pages/;  {---->                                                                   
      IFEND;                                                                                                  
      RESET duv$execution_environment.memory_file_p^.segment_pointer.sequence_pointer TO memory_file_p;       
                                                                                                              
      remainder_to_transfer := duv$dump_environment_p^.critical_memory.page_size;                             
      WHILE remainder_to_transfer > 0 DO                                                                      
        IF bytes_read = 0 THEN                                                                                
          IF v$file_position = amc$eoi THEN                                                                   
            EXIT /read_critical_pages/;  {---->                                                               
          IFEND;                                                                                              
          get_next_data (c$edd_tape_block_size, data_buffer_p, bytes_read, status);                           
          IF NOT status.normal THEN                                                                           
            EXIT /read_critical_pages/;  {---->                                                               
          IFEND;                                                                                              
          IF bytes_read = 0 THEN                                                                              
            osp$set_status_abnormal (duc$dump_analyzer_id, due$unexpected_eoi, v$file_name_p^, status);       
            osp$append_status_parameter (osc$status_parameter_delimiter, 'the critical memory', status);      
            EXIT /read_critical_pages/;  {---->                                                               
          IFEND;                                                                                              
          total_bytes_read := total_bytes_read + bytes_read;                                                  
          RESET data_buffer_p;                                                                                
        IFEND;                                                                                                
                                                                                                              
        { Transfer the data in the buffer to the memory file.                                                 
                                                                                                              
        IF remainder_to_transfer >= bytes_read THEN                                                           
          data_transfer_amount := bytes_read;                                                                 
          bytes_read := 0;                                                                                    
        ELSE                                                                                                  
          data_transfer_amount := remainder_to_transfer;                                                      
          bytes_read := bytes_read - data_transfer_amount;                                                    
        IFEND;                                                                                                
        NEXT memory_data_p: [[REP data_transfer_amount OF cell]] IN                                           
              duv$execution_environment.memory_file_p^.segment_pointer.sequence_pointer;                      
        IF memory_data_p = NIL THEN                                                                           
          osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                        
          EXIT /read_critical_pages/;  {---->                                                                 
        IFEND;                                                                                                
        RESET memory_data_p;                                                                                  
        NEXT data_p: [[REP data_transfer_amount OF cell]] IN data_buffer_p;                                   
        IF data_p = NIL THEN                                                                                  
          osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                        
          EXIT /read_critical_pages/;  {---->                                                                 
        IFEND;                                                                                                
        memory_data_p^ := data_p^;                                                                            
                                                                                                              
        remainder_to_transfer := remainder_to_transfer - data_transfer_amount;                                
      WHILEND;                                                                                                
                                                                                                              
      IF cpt_image_p^ [current_block_index] THEN                                                              
        critical_page_table_p^ [current_block_index].available := TRUE;                                       
        critical_page_table_p^ [current_block_index].page_offset := #OFFSET (memory_file_p);                  
        IF NOT duv$dump_environment_p^.critical_memory.available THEN                                         
          duv$dump_environment_p^.critical_memory.available := TRUE;                                          
          duv$dump_environment_p^.critical_memory.first_page := #OFFSET (memory_file_p);                      
          duv$dump_environment_p^.critical_memory.first_rma_available :=                                      
                (current_block_index - 1) * duv$dump_environment_p^.critical_memory.page_size;                
        IFEND;                                                                                                
      ELSE                                                                                                    
        RESET duv$execution_environment.memory_file_p^.segment_pointer.sequence_pointer TO memory_file_p;     
      IFEND;                                                                                                  
                                                                                                              
    FOREND /read_critical_pages/;                                                                             
                                                                                                              
    v$last_other_record_p^.size := total_bytes_read;                                                          
    duv$dump_environment_p^.critical_memory.last_rma_available :=  (number_page_entries *                     
          duv$dump_environment_p^.critical_memory.page_size) - 1;                                             
                                                                                                              
  PROCEND read_only_critical_memory;                                                                          
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'read_other_record', EJECT ??                                                                  
                                                                                                              
{ PURPOSE:                                                                                                    
{   This procedure reads other records from the dump file and moves them to the restart file.                 
                                                                                                              
  PROCEDURE read_other_record                                                                                 
    (VAR dump_label: t$dump_label;                                                                            
     VAR status: ost$status);                                                                                 
                                                                                                              
    VAR                                                                                                       
      block_count: integer,                                                                                   
      bytes_read: amt$transfer_count,                                                                         
      data_buffer_p: ^SEQ ( * ),                                                                              
      data_buffer_seq: SEQ (REP c$edd_tape_block_size OF cell),                                               
      data_buffer_seq_p: ^SEQ ( * ),                                                                          
      display_message: string (ofc$max_display_message),                                                      
      local_status: ost$status,                                                                               
      message_length: integer,                                                                                
      other_record_entry_p: ^dut$de_other_record_entry,                                                       
      other_record_p: ^SEQ ( * ),                                                                             
      save_dump_label: t$dump_label,                                                                          
      save_first_byte: amt$file_byte_address,                                                                 
      total_bytes_read: integer;                                                                              
                                                                                                              
    status.normal := TRUE;                                                                                    
                                                                                                              
    ofp$display_status_message ('reading other record', status);                                              
                                                                                                              
    other_record_entry_p := v$last_other_record_p;                                                            
                                                                                                              
    NEXT other_record_p: [[REP 1 OF cell]] IN duv$execution_environment.data_file_p^.segment_pointer.         
          sequence_pointer;                                                                                   
    IF other_record_p = NIL THEN                                                                              
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                            
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
    RESET duv$execution_environment.data_file_p^.segment_pointer.sequence_pointer TO other_record_p;          
    save_first_byte := #OFFSET (other_record_p);                                                              
    save_dump_label := dump_label;                                                                            
                                                                                                              
    mmp$set_access_selections (duv$execution_environment.data_file_p^.segment_pointer.sequence_pointer,       
          mmc$as_sequential, local_status);                                                                   
    IF NOT local_status.normal THEN                                                                           
      dup$display_message (local_status, v$display_control);                                                  
    IFEND;                                                                                                    
                                                                                                              
    data_buffer_seq_p := ^data_buffer_seq;                                                                    
    IF data_buffer_seq_p = NIL THEN                                                                           
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                            
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
                                                                                                              
    block_count := 0;                                                                                         
    total_bytes_read := 0;                                                                                    
                                                                                                              
  /move_other_record/                                                                                         
    WHILE TRUE DO                                                                                             
      block_count := block_count + 1;                                                                         
      STRINGREP (display_message, message_length, 'reading  ', other_record_entry_p^.name, '  block ',        
            block_count);                                                                                     
      ofp$display_status_message (display_message (1, message_length), local_status);                         
                                                                                                              
      RESET data_buffer_seq_p;                                                                                
      get_next_data (c$edd_tape_block_size, data_buffer_seq_p, bytes_read, status);                           
      IF NOT status.normal THEN                                                                               
        EXIT /move_other_record/;  {---->                                                                     
      IFEND;                                                                                                  
      IF (bytes_read = 0) AND (v$file_position = amc$eoi) THEN                                                
        EXIT /move_other_record/;  {---->                                                                     
      IFEND;                                                                                                  
                                                                                                              
      IF bytes_read = #SIZE (t$edd_label) THEN                                                                
        process_label_record (data_buffer_seq_p, dump_label);                                                 
        EXIT /move_other_record/; {---->                                                                      
      IFEND;                                                                                                  
                                                                                                              
      NEXT other_record_p: [[REP bytes_read OF cell]] IN duv$execution_environment.data_file_p^.              
            segment_pointer.sequence_pointer;                                                                 
      IF other_record_p = NIL THEN                                                                            
        osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                          
        EXIT /move_other_record/;  {---->                                                                     
      IFEND;                                                                                                  
      RESET data_buffer_seq_p;                                                                                
      NEXT data_buffer_p: [[REP bytes_read OF cell]] IN data_buffer_seq_p;                                    
      IF data_buffer_p = NIL THEN                                                                             
        osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                          
        EXIT /move_other_record/;  {---->                                                                     
      IFEND;                                                                                                  
      other_record_p^ := data_buffer_p^;                                                                      
                                                                                                              
      total_bytes_read := total_bytes_read + bytes_read;                                                      
      IF v$file_position = amc$eoi THEN                                                                       
        EXIT /move_other_record/;  {---->                                                                     
      IFEND;                                                                                                  
    WHILEND /move_other_record/;                                                                              
                                                                                                              
    other_record_entry_p^.record_type := save_dump_label.record_type;                                         
    IF total_bytes_read > 0 THEN                                                                              
      other_record_entry_p^.first_byte := save_first_byte;                                                    
      other_record_entry_p^.header_line_count := save_dump_label.header_line_count;                           
      other_record_entry_p^.report_record_length := save_dump_label.report_record_length;                     
      other_record_entry_p^.size := total_bytes_read;                                                         
    IFEND;                                                                                                    
                                                                                                              
    mmp$set_access_selections (duv$execution_environment.data_file_p^.segment_pointer.sequence_pointer,       
          mmc$as_random, local_status);                                                                       
                                                                                                              
  PROCEND read_other_record;                                                                                  
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'read_pp_memory', EJECT ??                                                                     
                                                                                                              
{ PURPOSE:                                                                                                    
{   This procedure reads the PP memory from the dump file and places it on the restart file.                  
                                                                                                              
  PROCEDURE read_pp_memory                                                                                    
    (VAR dump_label: t$dump_label;                                                                            
     VAR status: ost$status);                                                                                 
                                                                                                              
    TYPE                                                                                                      
      t$r_register = PACKED RECORD                                                                            
        CASE boolean OF                                                                                       
        = TRUE =                                                                                              
          upper_10: 0 .. 3ff(16),                                                                             
          lower_12: 0 .. 0fff(16),                                                                            
        = FALSE =                                                                                             
          value: 0 .. 3fffff(16),                                                                             
        CASEND,                                                                                               
      RECEND,                                                                                                 
                                                                                                              
      t$r_register_container = PACKED RECORD                                                                  
        fill_22: 0 .. 3fffff(16),                                                                             
        upper_10: 0 .. 3ff(16),                                                                               
        fill_4: 0 .. 0f(16),                                                                                  
        lower_12: 0 .. 0fff(16),                                                                              
      RECEND;                                                                                                 
                                                                                                              
    VAR                                                                                                       
      bytes_read: amt$transfer_count,                                                                         
      data_buffer_p: ^SEQ ( * ),                                                                              
      first_time: boolean,                                                                                    
      index: 1 .. 9,                                                                                          
      iou: 0 .. duc$de_maximum_ious,                                                                          
      iou_class: dut$di_iou_class,                                                                            
      pp_buffer_array_p: ^ARRAY [1 .. *] OF cell,                                                             
      pp_memory_buffer_seq_p: ^SEQ ( * ),                                                                     
      pp_number: 0 .. duc$de_max_pp_memories,                                                                 
      pp_type: dst$channel_protocol_type,                                                                     
      pp_word_size: dut$di_pp_word_size,                                                                      
      r_register: t$r_register,                                                                               
      r_register_container_p: ^t$r_register_container,                                                        
      register: dut$de_maintenance_register,                                                                  
      restart_file_array_p: ^array [1 .. * ] of cell,                                                         
      restart_file_seq_p: ^SEQ ( * ),                                                                         
      tape_blocks: 3 .. 9,                                                                                    
      total_bytes_read: amt$transfer_count;                                                                   
                                                                                                              
    status.normal := TRUE;                                                                                    
                                                                                                              
    CASE dump_label.kind OF                                                                                   
    = c$dlk_iom_label =                                                                                       
      ofp$display_status_message ('reading pp memory from iou 0', status);                                    
      pp_number := dump_label.pp_number;                                                                      
      pp_type := dsc$cpt_nio;                                                                                 
      iou := 0;                                                                                               
    = c$dlk_jom_label =                                                                                       
      ofp$display_status_message ('reading pp memory from iou 1', status);                                    
      pp_number := dump_label.pp_number;                                                                      
      pp_type := dsc$cpt_nio;                                                                                 
      iou := 1;                                                                                               
    = c$dlk_dom_label =                                                                                       
      ofp$display_status_message ('reading cio pp memory from iou 0', status);                                
      pp_number := dump_label.cio_pp_number;                                                                  
      pp_type := dsc$cpt_cio;                                                                                 
      iou := 0;                                                                                               
    ELSE  { = c$dlk_eom_label = }                                                                             
      ofp$display_status_message ('reading cio pp memory from iou 1', status);                                
      pp_number := dump_label.cio_pp_number;                                                                  
      pp_type := dsc$cpt_cio;                                                                                 
      iou := 1;                                                                                               
    CASEND;                                                                                                   
                                                                                                              
    iou_class := duc$di_ic_iou_4k;                                                                            
    pp_word_size := 4096;                                                                                     
    dup$retrieve_register (duc$de_iou, iou, 10(16), register);                                                
    IF register.available THEN                                                                                
      IF (register.value [duc$de_model_byte_number] >= 50(16)) AND                                            
            (register.value [duc$de_model_byte_number] <= 5F(16)) THEN                                        
        iou_class := duc$di_ic_iou_16k;                                                                       
        pp_word_size := 16384;                                                                                
      ELSEIF (register.value [duc$de_model_byte_number] >= 40(16)) AND                                        
            (register.value [duc$de_model_byte_number] <= 46(16)) THEN                                        
        iou_class := duc$di_ic_iou_8k;                                                                        
        pp_word_size := 8192;                                                                                 
        IF (register.value [duc$de_model_byte_number] = 44(16)) OR                                            
              (register.value [duc$de_model_byte_number] = 46(16)) THEN                                       
          pp_type := dsc$cpt_nio;                                                                             
        IFEND;                                                                                                
      IFEND;                                                                                                  
    IFEND;                                                                                                    
                                                                                                              
    CASE iou_class OF                                                                                         
    = duc$di_ic_iou_4k =                                                                                      
      tape_blocks := 3;                                                                                       
    = duc$di_ic_iou_8k =                                                                                      
      tape_blocks := 5;                                                                                       
    = duc$di_ic_iou_16k =                                                                                     
      tape_blocks := 9;                                                                                       
    ELSE                                                                                                      
      osp$set_status_abnormal (duc$dump_analyzer_id, due$unknown_iou_model, ' ', status);                     
      dup$display_message (status, v$display_control);                                                        
      status.normal := TRUE;                                                                                  
      RETURN;  {---->                                                                                         
    CASEND;                                                                                                   
                                                                                                              
    PUSH pp_memory_buffer_seq_p: [[REP (tape_blocks * c$edd_tape_block_size) OF cell]];                       
    IF pp_memory_buffer_seq_p = NIL THEN                                                                      
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                            
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
    RESET pp_memory_buffer_seq_p;                                                                             
                                                                                                              
    total_bytes_read := 0;                                                                                    
    first_time := TRUE;                                                                                       
    FOR index := 1 TO tape_blocks DO                                                                          
      NEXT data_buffer_p: [[REP c$edd_tape_block_size OF cell]] IN pp_memory_buffer_seq_p;                    
      IF data_buffer_p = NIL THEN                                                                             
        osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                          
        RETURN;  {---->                                                                                       
      IFEND;                                                                                                  
                                                                                                              
      get_next_data (c$edd_tape_block_size, data_buffer_p, bytes_read, status);                               
      IF NOT status.normal THEN                                                                               
        RETURN;  {---->                                                                                       
      IFEND;                                                                                                  
                                                                                                              
      IF (bytes_read = 0) OR (v$file_position = amc$eoi) THEN                                                 
        osp$set_status_abnormal (duc$dump_analyzer_id, due$unexpected_eoi, v$file_name_p^, status);           
        osp$append_status_parameter (osc$status_parameter_delimiter, 'the pp memory', status);                
        RETURN;  {---->                                                                                       
      IFEND;                                                                                                  
      IF first_time THEN                                                                                      
        IF bytes_read = #SIZE (t$edd_label) THEN                                                              
          process_label_record (data_buffer_p, dump_label);                                                   
          RETURN;  {---->                                                                                     
        IFEND;                                                                                                
        first_time := FALSE;                                                                                  
      IFEND;                                                                                                  
      total_bytes_read := total_bytes_read + bytes_read;                                                      
    FOREND;                                                                                                   
                                                                                                              
    v$last_other_record_p^.size := total_bytes_read;                                                          
    NEXT restart_file_seq_p: [[REP (pp_word_size * 2) OF cell]] IN                                            
          duv$execution_environment.data_file_p^.segment_pointer.sequence_pointer;                            
    IF restart_file_seq_p = NIL THEN                                                                          
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                            
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
    RESET restart_file_seq_p;                                                                                 
    RESET pp_memory_buffer_seq_p;                                                                             
                                                                                                              
    NEXT pp_buffer_array_p: [1 .. (pp_word_size * 2)] IN pp_memory_buffer_seq_p;                              
    IF pp_buffer_array_p = NIL THEN                                                                           
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                            
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
    NEXT restart_file_array_p: [1 .. (pp_word_size * 2)] IN restart_file_seq_p;                               
    IF restart_file_array_p = NIL THEN                                                                        
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                            
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
    restart_file_array_p^ := pp_buffer_array_p^;                                                              
                                                                                                              
    IF pp_type = dsc$cpt_nio THEN                                                                             
      duv$dump_environment_p^.iou_memory [iou].nio_pp [pp_number].available := TRUE;                          
      duv$dump_environment_p^.iou_memory [iou].nio_pp [pp_number].first_byte :=                               
            #OFFSET (restart_file_array_p);                                                                   
    ELSE                                                                                                      
      duv$dump_environment_p^.iou_memory [iou].cio_pp [pp_number].available := TRUE;                          
      duv$dump_environment_p^.iou_memory [iou].cio_pp [pp_number].first_byte :=                               
            #OFFSET (restart_file_array_p);                                                                   
    IFEND;                                                                                                    
                                                                                                              
    NEXT r_register_container_p IN pp_memory_buffer_seq_p;                                                    
    IF r_register_container_p = NIL THEN                                                                      
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                            
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
    r_register.upper_10 := r_register_container_p^.upper_10;                                                  
    r_register.lower_12 := r_register_container_p^.lower_12;                                                  
                                                                                                              
    IF pp_type = dsc$cpt_nio THEN                                                                             
      duv$dump_environment_p^.iou_memory [iou].nio_pp [pp_number].r_register := r_register.value;             
    ELSE                                                                                                      
      duv$dump_environment_p^.iou_memory [iou].cio_pp [pp_number].r_register := r_register.value;             
    IFEND;                                                                                                    
                                                                                                              
  PROCEND read_pp_memory;                                                                                     
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'read_register_file', EJECT ??                                                                 
                                                                                                              
{ PURPOSE:                                                                                                    
{   This procedure reads the register file from the dump file and places it on the restart file.              
                                                                                                              
                                                                                                              
  PROCEDURE read_register_file                                                                                
    (VAR dump_label: t$dump_label;                                                                            
     VAR status: ost$status);                                                                                 
                                                                                                              
    VAR                                                                                                       
      bytes_read: amt$transfer_count,                                                                         
      data_buffer_seq_p: ^SEQ ( * ),                                                                          
      processor: 0 .. duc$de_maximum_processors,                                                              
      register_contents_p: ^integer,                                                                          
      register_index: 0 .. duc$de_max_register_number,                                                        
      remaining_register: 1 .. (duc$de_max_register_number + 1);                                              
                                                                                                              
    status.normal := TRUE;                                                                                    
                                                                                                              
    ofp$display_status_message ('reading processor register file', status);                                   
                                                                                                              
   /find_processor/                                                                                           
    FOR processor := 0 TO duc$de_maximum_processors DO                                                        
      IF NOT duv$dump_environment_p^.register_file [processor].available THEN                                 
        EXIT /find_processor/;  {---->                                                                        
      IFEND;                                                                                                  
    FOREND /find_processor/;                                                                                  
                                                                                                              
    PUSH data_buffer_seq_p: [[REP dump_label.register_file_size OF integer]];                                 
    IF data_buffer_seq_p = NIL THEN                                                                           
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                            
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
    RESET data_buffer_seq_p;                                                                                  
                                                                                                              
    get_next_data (#SIZE (data_buffer_seq_p^), data_buffer_seq_p, bytes_read, status);                        
    IF NOT status.normal THEN                                                                                 
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
    IF bytes_read = 0 THEN                                                                                    
      osp$set_status_abnormal (duc$dump_analyzer_id, due$unexpected_eoi, v$file_name_p^, status);             
      osp$append_status_parameter (osc$status_parameter_delimiter, 'the register file', status);              
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
    IF bytes_read = #SIZE (t$edd_label) THEN                                                                  
      process_label_record (data_buffer_seq_p, dump_label);                                                   
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
    v$last_other_record_p^.size := bytes_read;                                                                
                                                                                                              
   /read_registers/                                                                                           
    FOR register_index := 0 TO duc$de_max_register_number DO                                                  
      duv$dump_environment_p^.register_file [processor].register [register_index].available := FALSE;         
      duv$dump_environment_p^.register_file [processor].register [register_index].value := 0;                 
                                                                                                              
      NEXT register_contents_p IN data_buffer_seq_p;                                                          
      IF register_contents_p = NIL THEN                                                                       
        EXIT /read_registers/;  {---->                                                                        
      IFEND;                                                                                                  
                                                                                                              
      duv$dump_environment_p^.register_file [processor].register [register_index].available := TRUE;          
      duv$dump_environment_p^.register_file [processor].register [register_index].value :=                    
            register_contents_p^;                                                                             
                                                                                                              
    FOREND /read_registers/;                                                                                  
                                                                                                              
    FOR remaining_register := (register_index + 1) TO UPPERBOUND (duv$dump_environment_p^.register_file) DO   
      duv$dump_environment_p^.register_file [processor].register [remaining_register].available := FALSE;     
    FOREND;                                                                                                   
                                                                                                              
    duv$dump_environment_p^.register_file [processor].available := TRUE;                                      
    duv$dump_environment_p^.register_file [processor].number_of_registers := dump_label.register_file_size;   
                                                                                                              
  PROCEND read_register_file;                                                                                 
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'save_record_name', EJECT ??                                                                   
                                                                                                              
{ PURPOSE:                                                                                                    
{   This procedure saves the record name on the other record linked list.                                     
                                                                                                              
  PROCEDURE save_record_name                                                                                  
    (VAR dump_label: t$dump_label;                                                                            
     VAR status: ost$status);                                                                                 
                                                                                                              
    VAR                                                                                                       
      other_record_entry_p: ^dut$de_other_record_entry;                                                       
                                                                                                              
    status.normal := TRUE;                                                                                    
                                                                                                              
    IF NOT duv$dump_environment_p^.other_records.available THEN                                               
      duv$dump_environment_p^.other_records.available := TRUE;                                                
      duv$dump_environment_p^.other_records.number_of_records := 0;                                           
    IFEND;                                                                                                    
                                                                                                              
    NEXT other_record_entry_p IN duv$execution_environment.data_file_p^.segment_pointer.sequence_pointer;     
    IF other_record_entry_p = NIL THEN                                                                        
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                            
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
                                                                                                              
    duv$dump_environment_p^.other_records.number_of_records :=                                                
          duv$dump_environment_p^.other_records.number_of_records + 1;                                        
    IF v$last_other_record_p = NIL THEN                                                                       
      duv$dump_environment_p^.other_records.first_record := #OFFSET (other_record_entry_p);                   
    ELSE                                                                                                      
      v$last_other_record_p^.next_record := #OFFSET (other_record_entry_p);                                   
    IFEND;                                                                                                    
    v$last_other_record_p := other_record_entry_p;                                                            
                                                                                                              
    other_record_entry_p^.index := duv$dump_environment_p^.other_records.number_of_records;                   
    other_record_entry_p^.name := dump_label.record_name;                                                     
    other_record_entry_p^.record_type := duc$de_ort_detail;                                                   
    other_record_entry_p^.first_byte := 0;                                                                    
    other_record_entry_p^.size := 0;                                                                          
    other_record_entry_p^.header_line_count := 0;                                                             
    other_record_entry_p^.report_record_length := 0;                                                          
    other_record_entry_p^.next_record := 0;                                                                   
                                                                                                              
  PROCEND save_record_name;                                                                                   
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'dup$read_dump_file', EJECT ??                                                                 
                                                                                                              
{ PURPOSE:                                                                                                    
{   This procedure reads the dump file and builds the dump environment.                                       
                                                                                                              
  PROCEDURE [XDCL] dup$read_dump_file                                                                         
    (    file_name_p: ^fst$file_reference;                                                                    
         restart_file_count: integer;                                                                         
     VAR status: ost$status);                                                                                 
                                                                                                              
    VAR                                                                                                       
      critical_page_table_p: ^array [0 .. * ] of dut$de_critical_page_entry,                                  
      device_assigned: boolean,                                                                               
      device_class: rmt$device_class,                                                                         
      dump_environment_40702_p: ^dut$dump_environment_40702,                                                  
      dump_label: t$dump_label,                                                                               
      fa_p: ^fst$attachment_options,                                                                          
      i: integer,                                                                                             
      iou: 0 .. duc$de_maximum_ious,                                                                          
      local_status: ost$status,                                                                               
      mca_p: ^fst$file_cycle_attributes,                                                                      
      pp_number: 0 .. duc$de_max_pp_memories,                                                                 
      processor: 0 .. duc$de_maximum_processors,                                                              
      severity: ost$status_severity;                                                                          
                                                                                                              
    status.normal := TRUE;                                                                                    
    v$file_name_p := file_name_p;                                                                             
                                                                                                              
{ Retrieve the display control for the display file.                                                          
    v$display_control := duv$execution_environment.output_file.display_control;                               
    v$display_control.line_number := v$display_control.page_length + 1;                                       
                                                                                                              
{ Initialize the dump environment.                                                                            
    FOR i := 1 TO restart_file_count DO                                                                       
      IF i = 1 THEN                                                                                           
        duv$execution_environment.data_file_p := ^duv$execution_environment.restart_files [i];                
        duv$execution_environment.memory_file_p := ^duv$execution_environment.restart_files [i];              
                                                                                                              
        RESET duv$execution_environment.data_file_p^.segment_pointer.sequence_pointer;                        
        NEXT duv$dump_environment_p IN duv$execution_environment.data_file_p^.segment_pointer.                
              sequence_pointer;                                                                               
        IF duv$dump_environment_p = NIL THEN                                                                  
          osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                        
          RETURN; {---->                                                                                      
        IFEND;                                                                                                
                                                                                                              
        pmp$zero_out_table (#LOC (duv$dump_environment_p^), #SIZE (duv$dump_environment_p^));                 
        duv$dump_environment_p^.revision_level := (duc$revision_level * 100(16)) + i;                         
        duv$dump_environment_p^.restart_identifier.file_number := i;                                          
        duv$dump_environment_p^.restart_identifier.file_count := restart_file_count;                          
        duv$dump_environment_p^.restart_identifier.identifier := #FREE_RUNNING_CLOCK (0);                     
                                                                                                              
      ELSE                                                                                                    
        duv$execution_environment.memory_file_p := ^duv$execution_environment.restart_files [i];              
        RESET duv$execution_environment.memory_file_p^.segment_pointer.sequence_pointer;                      
        NEXT dump_environment_40702_p IN duv$execution_environment.memory_file_p^.segment_pointer.            
              sequence_pointer;                                                                               
        IF dump_environment_40702_p = NIL THEN                                                                
          osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                        
          RETURN; {---->                                                                                      
        IFEND;                                                                                                
                                                                                                              
        dump_environment_40702_p^.revision_level := (duc$revision_level * 100(16)) + i;                       
        dump_environment_40702_p^.restart_identifier.file_number := i;                                        
        dump_environment_40702_p^.restart_identifier.file_count := restart_file_count;                        
        dump_environment_40702_p^.restart_identifier.identifier :=                                            
              duv$dump_environment_p^.restart_identifier.identifier;                                          
      IFEND;                                                                                                  
    FOREND;                                                                                                   
                                                                                                              
{ Open the Dump File.                                                                                         
    rmp$get_device_class (v$file_name_p^, device_assigned, device_class, status);                             
    IF NOT status.normal THEN                                                                                 
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
    IF NOT device_assigned THEN                                                                               
      osp$set_status_abnormal (duc$dump_analyzer_id, due$file_empty, v$file_name_p^, status);                 
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
    IF device_class = rmc$magnetic_tape_device THEN                                                           
      PUSH fa_p: [1 .. 3];                                                                                    
      fa_p^ [1].selector := fsc$access_and_share_modes;                                                       
      fa_p^ [1].access_modes.selector := fsc$specific_access_modes;                                           
      fa_p^ [1].access_modes.value := $fst$file_access_options [fsc$read];                                    
      fa_p^ [1].share_modes.selector := fsc$specific_share_modes;                                             
      fa_p^ [1].share_modes.value := $fst$file_access_options [fsc$read];                                     
      fa_p^ [2].selector := fsc$open_position;                                                                
      fa_p^ [2].open_position := amc$open_at_boi;                                                             
      fa_p^ [3].selector := fsc$tape_attachment;                                                              
      fa_p^ [3].tape_attachment.selector := fsc$tape_file_set_position;                                       
      fa_p^ [3].tape_attachment.tape_file_set_position.position := fsc$tape_beginning_of_set;                 
      PUSH mca_p: [1 .. 6];                                                                                   
      mca_p^ [1].selector := fsc$block_type;                                                                  
      mca_p^ [1].block_type := amc$user_specified;                                                            
      mca_p^ [2].selector := fsc$max_block_length;                                                            
      mca_p^ [2].max_block_length := c$edd_tape_block_size;                                                   
      mca_p^ [3].selector := fsc$max_record_length;                                                           
      mca_p^ [3].max_record_length := c$edd_tape_block_size;                                                  
      mca_p^ [4].selector := fsc$record_type;                                                                 
      mca_p^ [4].record_type := amc$undefined;                                                                
      mca_p^ [5].selector := fsc$file_organization;                                                           
      mca_p^ [5].file_organization := amc$sequential;                                                         
      mca_p^ [6].selector := fsc$file_label_type;                                                             
      mca_p^ [6].file_label_type := amc$labelled;                                                             
    ELSEIF device_class = rmc$mass_storage_device THEN                                                        
      PUSH fa_p: [1 .. 2];                                                                                    
      fa_p^ [1].selector := fsc$access_and_share_modes;                                                       
      fa_p^ [1].access_modes.selector := fsc$specific_access_modes;                                           
      fa_p^ [1].access_modes.value := $fst$file_access_options [fsc$read];                                    
      fa_p^ [1].share_modes.selector := fsc$specific_share_modes;                                             
      fa_p^ [1].share_modes.value := $fst$file_access_options [fsc$read];                                     
      fa_p^ [2].selector := fsc$open_position;                                                                
      fa_p^ [2].open_position := amc$open_at_boi;                                                             
      PUSH mca_p: [1 .. 2];                                                                                   
      mca_p^ [1].selector := fsc$record_type;                                                                 
      mca_p^ [1].record_type := amc$variable;                                                                 
      mca_p^ [2].selector := fsc$file_organization;                                                           
      mca_p^ [2].file_organization := amc$sequential;                                                         
    ELSE                                                                                                      
      osp$set_status_abnormal (duc$dump_analyzer_id, due$file_empty, v$file_name_p^, status);                 
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
                                                                                                              
    fsp$open_file (v$file_name_p^, amc$record, fa_p, NIL, mca_p, NIL, NIL, v$dump_file_identifier, status);   
    IF NOT status.normal THEN                                                                                 
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
                                                                                                              
    dump_label.read_label := TRUE;                                                                            
    v$file_position := amc$boi;                                                                               
                                                                                                              
  /read_dump/                                                                                                 
    WHILE TRUE DO                                                                                             
      IF v$file_position = amc$eoi THEN                                                                       
        EXIT /read_dump/;  {---->                                                                             
      IFEND;                                                                                                  
                                                                                                              
      IF dump_label.read_label THEN                                                                           
        read_label_record (dump_label, status);                                                               
        IF NOT status.normal OR (v$file_position = amc$eoi) THEN                                              
          EXIT /read_dump/;  {---->                                                                           
        IFEND;                                                                                                
      IFEND;                                                                                                  
                                                                                                              
      dump_label.read_label := TRUE;                                                                          
      save_record_name (dump_label, status);                                                                  
      IF NOT status.normal THEN                                                                               
        EXIT /read_dump/;  {---->                                                                             
      IFEND;                                                                                                  
                                                                                                              
      CASE dump_label.kind OF                                                                                 
      = c$dlk_pmr_label, c$dlk_pr0_label, c$dlk_pr1_label,                                                    
            c$dlk_imr_label, c$dlk_im1_label, c$dlk_mmr_label =                                               
        read_maintenance_registers (dump_label, status);                                                      
        IF NOT status.normal THEN                                                                             
          EXIT /read_dump/;  {---->                                                                           
        IFEND;                                                                                                
                                                                                                              
      = c$dlk_mem_label =                                                                                     
        IF duv$execution_environment.processing_options = duc$ee_po_no_memory THEN                            
          EXIT /read_dump/;  {---->                                                                           
        ELSEIF (duv$execution_environment.processing_options = duc$ee_po_critical_memory) AND                 
              NOT duv$dump_environment_p^.critical_memory.available THEN                                      
          read_only_critical_memory (critical_page_table_p, dump_label, status);                              
        ELSE                                                                                                  
          read_central_memory (dump_label, status);                                                           
        IFEND;                                                                                                
        IF NOT status.normal THEN                                                                             
          EXIT /read_dump/;  {---->                                                                           
        IFEND;                                                                                                
                                                                                                              
      = c$dlk_did_label =                                                                                     
        read_dump_identifier (dump_label, status);                                                            
        IF NOT status.normal THEN                                                                             
          EXIT /read_dump/;  {---->                                                                           
        IFEND;                                                                                                
                                                                                                              
      = c$dlk_ccm_label =                                                                                     
        read_critical_memory (dump_label, critical_page_table_p, status);                                     
        IF NOT status.normal THEN                                                                             
          EXIT /read_dump/;  {---->                                                                           
        IFEND;                                                                                                
                                                                                                              
      = c$dlk_cpt_label =                                                                                     
        read_critical_page_table (dump_label, critical_page_table_p, status);                                 
        IF NOT status.normal THEN                                                                             
          EXIT /read_dump/;  {---->                                                                           
        IFEND;                                                                                                
                                                                                                              
      = c$dlk_iom_label, c$dlk_jom_label, c$dlk_dom_label, c$dlk_eom_label =                                  
        read_pp_memory (dump_label, status);                                                                  
        IF NOT status.normal THEN                                                                             
          EXIT /read_dump/;  {---->                                                                           
        IFEND;                                                                                                
                                                                                                              
      = c$dlk_pxp_label, c$dlk_px0_label, c$dlk_px1_label,                                                    
            c$dlk_jps_label, c$dlk_jp0_label, c$dlk_jp1_label,                                                
            c$dlk_mps_label, c$dlk_mp0_label, c$dlk_mp1_label =                                               
        read_exchange_package (dump_label, status);                                                           
        IF NOT status.normal THEN                                                                             
          EXIT /read_dump/;  {---->                                                                           
        IFEND;                                                                                                
                                                                                                              
      = c$dlk_prf_label =                                                                                     
        read_register_file (dump_label, status);                                                              
        IF NOT status.normal THEN                                                                             
          EXIT /read_dump/;  {---->                                                                           
        IFEND;                                                                                                
                                                                                                              
      = c$dlk_pcs_label =                                                                                     
        read_control_store (dump_label, status);                                                              
        IF NOT status.normal THEN                                                                             
          EXIT /read_dump/;  {---->                                                                           
        IFEND;                                                                                                
                                                                                                              
      = c$dlk_bc_label =                                                                                      
        read_buffer_controlware (dump_label, status);                                                         
        IF NOT status.normal THEN                                                                             
          EXIT /read_dump/;  {---->                                                                           
        IFEND;                                                                                                
                                                                                                              
      = c$dlk_other_label =                                                                                   
        read_other_record (dump_label, status);                                                               
        IF NOT status.normal THEN                                                                             
          EXIT /read_dump/;  {---->                                                                           
        IFEND;                                                                                                
                                                                                                              
      = c$dlk_ill_formatted_label =                                                                           
        CYCLE /read_dump/;  {---->                                                                            
                                                                                                              
      = c$dlk_not_a_label =                                                                                   
        CYCLE /read_dump/;  {---->                                                                            
                                                                                                              
      ELSE                                                                                                    
        CYCLE /read_dump/;  {---->                                                                            
      CASEND;                                                                                                 
                                                                                                              
    WHILEND /read_dump/;                                                                                      
                                                                                                              
    IF NOT status.normal THEN                                                                                 
      dup$display_message (status, v$display_control);                                                        
      osp$get_status_severity (status.condition, severity, local_status);                                     
      IF local_status.normal AND (severity <= osc$warning_status) THEN                                        
        status.normal := TRUE;                                                                                
      IFEND;                                                                                                  
    IFEND;                                                                                                    
                                                                                                              
    FOR i := 1 TO restart_file_count DO                                                                       
      amp$set_segment_eoi (duv$execution_environment.restart_files [i].file_identifier,                       
            duv$execution_environment.restart_files [i].segment_pointer, local_status);                       
      IF NOT local_status.normal THEN                                                                         
        dup$display_message (local_status, v$display_control);                                                
      IFEND;                                                                                                  
    FOREND;                                                                                                   
                                                                                                              
    fsp$close_file (v$dump_file_identifier, local_status);                                                    
    amp$return (v$file_name_p^, local_status);                                                                
                                                                                                              
  PROCEND dup$read_dump_file;                                                                                 
MODEND dum$read_dump_file;                                                                                    
