?? RIGHT := 110 ??                                                                                            
?? NEWTITLE := 'NOS/VE Dump Analyzer : Dump Analyzer Functions' ??                                            
MODULE dum$dump_analyzer_functions;                                                                           
?? RIGHT := 110 ??                                                                                            
                                                                                                              
{ PURPOSE:                                                                                                    
{   This module contains the code for the dump analyzer functions.                                            
                                                                                                              
?? NEWTITLE := 'Global Declarations Referenced by This Module', EJECT ??                                      
?? PUSH (LISTEXT := ON) ??                                                                                    
*copyc clc$standard_file_names                                                                                
*copyc osc$processor_defined_registers                                                                        
*copyc cle$ecc_parsing                                                                                        
*copyc due$exception_condition_codes                                                                          
?? POP ??                                                                                                     
*copyc clf#make_clt$integer_value                                                                             
*copyc clf#make_integer_value                                                                                 
*copyc clf#make_keyword_value                                                                                 
*copyc clf#make_boolean_value                                                                                 
*copyc clf#make_string_value                                                                                  
*copyc clf#make_list_value                                                                                    
*copyc clf#make_record_header_value                                                                           
*copyc clf#make_unspecified_value                                                                             
*copyc clp#add_record_field                                                                                   
                                                                                                              
*copyc i#move                                                                                                 
*copyc clp$convert_string_to_integer                                                                          
*copyc clp$evaluate_parameters                                                                                
*copyc clp$make_boolean_value                                                                                 
*copyc clp$make_file_value                                                                                    
*copyc clp$make_integer_value                                                                                 
*copyc clp$make_name_value                                                                                    
*copyc clp$make_string_value                                                                                  
*copyc dup$access_real_memory                                                                                 
*copyc dup$copy_virtual_memory_pva                                                                            
*copyc dup$copy_virtual_memory_sva                                                                            
*copyc dup$determine_dump_information                                                                         
*copyc dup$evaluate_parameters                                                                                
*copyc dup$find_record_list_entry                                                                             
*copyc dup$retrieve_bc_entry                                                                                  
*copyc dup$retrieve_exchange_package                                                                          
*copyc dup$retrieve_register                                                                                  
*copyc dup$translate_pva                                                                                      
*copyc dup$translate_sva                                                                                      
*copyc fsp$get_open_information                                                                               
*copyc osp$append_status_integer                                                                              
*copyc osp$append_status_parameter                                                                            
*copyc osp$set_status_abnormal                                                                                
?? EJECT ??                                                                                                   
*copyc duv$default_parameters                                                                                 
*copyc duv$dump_environment_p                                                                                 
*copyc duv$execution_environment                                                                              
*copyc duv$title_data                                                                                         
?? OLDTITLE ??                                                                                                
?? NEWTITLE := '[unsafe] F$MAKE_DEBUG_MASK_REG_VALUE', EJECT ??                                               
                                                                                                              
  FUNCTION [UNSAFE] f$make_debug_mask_reg_value                                                               
    (    debug_mask_register: ost$debug_mask;                                                                 
     VAR work_area: ^clt$work_area): ^clt$data_value;                                                         
                                                                                                              
    TYPE                                                                                                      
      t$debug_codes = packed array [osc$data_read .. osc$call_instruction] of boolean;                        
                                                                                                              
    VAR                                                                                                       
      attribute_record_index: 0 .. clc$max_fields,                                                            
      attribute_record_p: ^clt$data_value;                                                                    
                                                                                                              
?? NEWTITLE := '[unsafe] F$MAKE_DEBUG_CODES', EJECT ??                                                        
                                                                                                              
    FUNCTION [UNSAFE] f$make_debug_codes                                                                      
      (    codes: t$debug_codes;                                                                              
       VAR work_area_p: ^clt$work_area): ^clt$data_value;                                                     
                                                                                                              
      VAR                                                                                                     
        v$code_names: [READ] array [osc$data_read .. osc$call_instruction] of string (19) := [                
{ OSC$DATA_READ             } 'DATA_READ            ',                                                        
{ OSC$DATA_WRITE            } 'DATA_WRITE           ',                                                        
{ OSC$INSTRUCTION_FETCH     } 'INSTRUCTION_FETCH    ',                                                        
{ OSC$BRANCHING_INSTRUCTION } 'BRANCHING_INSTRUCTION',                                                        
{ OSC$CALL_INSTRUCTION      } 'CALL_INSTRUCTION     '];                                                       
                                                                                                              
      VAR                                                                                                     
        result_p: ^clt$data_value,                                                                            
        code: ost$debug_code,                                                                                 
        value_p: ^clt$data_value,                                                                             
        value_pp: ^^clt$data_value;                                                                           
                                                                                                              
      value_pp := ^value_p;                                                                                   
                                                                                                              
      FOR code := LOWERBOUND (codes) TO UPPERBOUND (codes) DO                                                 
        IF codes [code] THEN                                                                                  
          clp$make_name_value (v$code_names [code], work_area_p, result_p);                                   
          value_pp^ := clf#make_list_value (result_p, work_area_p);                                           
          value_pp := ^value_pp^^.link;                                                                       
        IFEND;                                                                                                
      FOREND;                                                                                                 
                                                                                                              
      IF value_pp = ^value_p THEN                                                                             
        f$make_debug_codes := clf#make_list_value (NIL, work_area_p);                                         
      ELSE                                                                                                    
        f$make_debug_codes := value_p;                                                                        
      IFEND;                                                                                                  
                                                                                                              
    FUNCEND f$make_debug_codes;                                                                               
?? OLDTITLE ??                                                                                                
?? EJECT ??                                                                                                   
                                                                                                              
    attribute_record_index := 0;                                                                              
    attribute_record_p := clf#make_record_header_value (3, work_area);                                        
                                                                                                              
    clp#add_record_field ('End_of_list_seen_flag', clf#make_boolean_value                                     
          (debug_mask_register.end_of_list_seen_flag, work_area), attribute_record_index, attribute_record_p);
                                                                                                              
    clp#add_record_field ('Scan_In_Progress', clf#make_boolean_value                                          
          (debug_mask_register.scan_in_progress, work_area), attribute_record_index, attribute_record_p);     
                                                                                                              
    clp#add_record_field ('Codes', f$make_debug_codes (debug_mask_register.codes, work_area),                 
          attribute_record_index, attribute_record_p);                                                        
                                                                                                              
  FUNCEND f$make_debug_mask_reg_value;                                                                        
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'P$MAKE_EXCHANGE_PACKAGE', EJECT ??                                                            
                                                                                                              
  PROCEDURE p$make_exchange_package                                                                           
    (    exchange_package: dut$exchange_package;                                                              
         display_option_full: boolean;                                                                        
     VAR result_p: ^clt$data_value;                                                                           
     VAR work_area: ^clt$work_area);                                                                          
                                                                                                              
    VAR                                                                                                       
      attribute_record_index: 0 .. clc$max_fields,                                                            
      attribute_record_p: ^clt$data_value,                                                                    
      pva: ost$pva;                                                                                           
                                                                                                              
?? NEWTITLE := 'P$ADD_RECORD_FIELD', EJECT ??                                                                 
                                                                                                              
{ Note: local not inline version of CLP#ADD_RECORD_FIELD. Otherwise we get an access violation                
{       probably because we do too many inlines.                                                              
                                                                                                              
    PROCEDURE p$add_record_field                                                                              
      (    field_name: string ( * <= 31);                                                                     
           value: ^clt$data_value;                                                                            
       VAR record_field_index: 0 .. clc$max_fields;                                                           
       VAR record_fwa: ^clt$data_value);                                                                      
                                                                                                              
      record_field_index := record_field_index + 1;                                                           
      #TRANSLATE (osv$lower_to_upper, field_name, record_fwa^.field_values^ [record_field_index].name);       
      record_fwa^.field_values^ [record_field_index].value := value;                                          
                                                                                                              
    PROCEND p$add_record_field;                                                                               
?? OLDTITLE ??                                                                                                
?? EJECT ??                                                                                                   
    attribute_record_index := 0;                                                                              
    IF display_option_full THEN                                                                               
      attribute_record_p := clf#make_record_header_value (52, work_area);                                     
    ELSE                                                                                                      
      attribute_record_p := clf#make_record_header_value (46, work_area);                                     
    IFEND;                                                                                                    
                                                                                                              
{  1 - P_REGISTER                                                                                             
    p$add_record_field ('P_REGISTER', f$make_p_register_value                                                 
          (exchange_package.p_register, display_option_full, work_area), attribute_record_index,              
          attribute_record_p);                                                                                
                                                                                                              
{  2 - A0_Dynamic_Space_Pointer                                                                               
    p$add_record_field ('a0_dynamic_space_pointer', f$make_pva_value                                          
          (exchange_package.a0_dynamic_space_pointer, display_option_full, work_area), attribute_record_index,
          attribute_record_p);                                                                                
                                                                                                              
{  3 - A1_Current_Stack_Frame                                                                                 
    p$add_record_field ('a1_current_stack_frame', f$make_pva_value                                            
          (exchange_package.a1_current_stack_frame, display_option_full, work_area), attribute_record_index,  
          attribute_record_p);                                                                                
                                                                                                              
{  4 - A2_Previous_Save_Area                                                                                  
    p$add_record_field ('a2_previous_save_area', f$make_pva_value                                             
          (exchange_package.a2_previous_save_area, display_option_full, work_area), attribute_record_index,   
          attribute_record_p);                                                                                
                                                                                                              
{  5 - A3                                                                                                     
    p$add_record_field ('a3', f$make_pva_value (exchange_package.a3, display_option_full, work_area),         
          attribute_record_index, attribute_record_p);                                                        
                                                                                                              
{  6 - A4                                                                                                     
    p$add_record_field ('a4', f$make_pva_value (exchange_package.a4, display_option_full, work_area),         
          attribute_record_index, attribute_record_p);                                                        
                                                                                                              
{  7 - A5                                                                                                     
    p$add_record_field ('a5', f$make_pva_value (exchange_package.a5, display_option_full, work_area),         
          attribute_record_index, attribute_record_p);                                                        
                                                                                                              
{  8 - A6                                                                                                     
    p$add_record_field ('a6', f$make_pva_value (exchange_package.a6, display_option_full, work_area),         
          attribute_record_index, attribute_record_p);                                                        
                                                                                                              
{  9 - A7                                                                                                     
    p$add_record_field ('a7', f$make_pva_value (exchange_package.a7, display_option_full, work_area),         
          attribute_record_index, attribute_record_p);                                                        
                                                                                                              
{ 10 - A8                                                                                                     
    p$add_record_field ('a8', f$make_pva_value (exchange_package.a8, display_option_full, work_area),         
          attribute_record_index, attribute_record_p);                                                        
                                                                                                              
{ 11 - A9                                                                                                     
    p$add_record_field ('a9', f$make_pva_value (exchange_package.a9, display_option_full, work_area),         
          attribute_record_index, attribute_record_p);                                                        
                                                                                                              
{ 12 - AA                                                                                                     
    p$add_record_field ('aa', f$make_pva_value (exchange_package.aa, display_option_full, work_area),         
          attribute_record_index, attribute_record_p);                                                        
                                                                                                              
{ 13 - AB                                                                                                     
    p$add_record_field ('ab', f$make_pva_value (exchange_package.ab, display_option_full, work_area),         
          attribute_record_index, attribute_record_p);                                                        
                                                                                                              
{ 14 - AC                                                                                                     
    p$add_record_field ('ac', f$make_pva_value (exchange_package.ac, display_option_full, work_area),         
          attribute_record_index, attribute_record_p);                                                        
                                                                                                              
{ 15 - AD                                                                                                     
    p$add_record_field ('ad', f$make_pva_value (exchange_package.ad, display_option_full, work_area),         
          attribute_record_index, attribute_record_p);                                                        
                                                                                                              
{ 16 - AE                                                                                                     
    p$add_record_field ('ae', f$make_pva_value (exchange_package.ae, display_option_full, work_area),         
          attribute_record_index, attribute_record_p);                                                        
                                                                                                              
{ 17 - AF                                                                                                     
    p$add_record_field ('af', f$make_pva_value (exchange_package.af, display_option_full, work_area),         
          attribute_record_index, attribute_record_p);                                                        
                                                                                                              
    p$add_record_field ('vmid', f$make_virtual_machine_ident (exchange_package.vmid, work_area),              
          attribute_record_index, attribute_record_p);                                                        
                                                                                                              
    p$add_record_field ('uvmid', f$make_virtual_machine_ident (exchange_package.uvmid, work_area),            
          attribute_record_index, attribute_record_p);                                                        
                                                                                                              
    p$add_record_field ('flags', f$make_ost$flags_value (exchange_package.flags, work_area),                  
          attribute_record_index, attribute_record_p);                                                        
                                                                                                              
    p$add_record_field ('Trap_enable', f$make_ost$trap_enable (exchange_package.trap_enable, work_area),      
          attribute_record_index, attribute_record_p);                                                        
                                                                                                              
    p$add_record_field ('user_condition_register', f$make_user_conditions_value                               
          (exchange_package.user_condition_register, work_area), attribute_record_index, attribute_record_p); 
                                                                                                              
    p$add_record_field ('monitor_condition_register', f$make_monitor_conditions_value                         
          (exchange_package.monitor_condition_register, work_area), attribute_record_index,                   
          attribute_record_p);                                                                                
                                                                                                              
    p$add_record_field ('user_mask', f$make_user_conditions_value (exchange_package.user_mask, work_area),    
          attribute_record_index, attribute_record_p);                                                        
                                                                                                              
    p$add_record_field ('monitor_mask', f$make_monitor_conditions_value                                       
          (exchange_package.monitor_mask, work_area), attribute_record_index, attribute_record_p);            
                                                                                                              
    p$add_record_field ('keypoint_class_number', clf#make_clt$integer_value                                   
          (exchange_package.keypoint_class_number, 16, TRUE, work_area), attribute_record_index,              
          attribute_record_p);                                                                                
                                                                                                              
    p$add_record_field ('keypoint_code_1', clf#make_clt$integer_value                                         
          (exchange_package.keypoint_code_1, 16, TRUE, work_area), attribute_record_index,                    
          attribute_record_p);                                                                                
                                                                                                              
    p$add_record_field ('keypoint_code_2', clf#make_clt$integer_value                                         
          (exchange_package.keypoint_code_2, 16, TRUE, work_area), attribute_record_index,                    
          attribute_record_p);                                                                                
                                                                                                              
    p$add_record_field ('keypoint_mask', f$make_keypoint_mask_value                                           
          (exchange_package.keypoint_mask, work_area), attribute_record_index, attribute_record_p);           
                                                                                                              
    p$add_record_field ('process_interval_timer_1', clf#make_clt$integer_value                                
          (exchange_package.process_interval_timer_1, 16, TRUE, work_area), attribute_record_index,           
          attribute_record_p);                                                                                
                                                                                                              
    p$add_record_field ('process_interval_timer_2', clf#make_clt$integer_value                                
          (exchange_package.process_interval_timer_2, 16, TRUE, work_area), attribute_record_index,           
          attribute_record_p);                                                                                
                                                                                                              
    p$add_record_field ('base_constant_1', clf#make_clt$integer_value                                         
          (exchange_package.base_constant_1, 16, TRUE, work_area), attribute_record_index,                    
          attribute_record_p);                                                                                
                                                                                                              
    p$add_record_field ('base_constant_2', clf#make_clt$integer_value                                         
          (exchange_package.base_constant_2, 16, TRUE, work_area), attribute_record_index,                    
          attribute_record_p);                                                                                
                                                                                                              
    p$add_record_field ('segment_table_length', clf#make_clt$integer_value                                    
          (exchange_package.segment_table_length, 16, TRUE, work_area), attribute_record_index,               
          attribute_record_p);                                                                                
                                                                                                              
    p$add_record_field ('segment_table_address_1', clf#make_clt$integer_value                                 
          (exchange_package.segment_table_address_1, 16, TRUE, work_area), attribute_record_index,            
          attribute_record_p);                                                                                
                                                                                                              
    p$add_record_field ('segment_table_address_2', clf#make_clt$integer_value                                 
          (exchange_package.segment_table_address_2, 16, TRUE, work_area), attribute_record_index,            
          attribute_record_p);                                                                                
                                                                                                              
    p$add_record_field ('model_dependent_flags', clf#make_clt$integer_value                                   
          (exchange_package.model_dependent_flags, 16, TRUE, work_area), attribute_record_index,              
          attribute_record_p);                                                                                
                                                                                                              
    p$add_record_field ('model_dependent_word', clf#make_clt$integer_value                                    
          (exchange_package.model_dependent_word, 16, TRUE, work_area), attribute_record_index,               
          attribute_record_p);                                                                                
                                                                                                              
    p$add_record_field ('last_processor_id', clf#make_clt$integer_value                                       
          (exchange_package.last_processor_id, 16, TRUE, work_area), attribute_record_index,                  
          attribute_record_p);                                                                                
                                                                                                              
    p$add_record_field ('untranslatable_pointer', f$make_pva_value                                            
          (exchange_package.untranslatable_pointer, display_option_full, work_area), attribute_record_index,  
          attribute_record_p);                                                                                
                                                                                                              
    p$add_record_field ('trap_pointer', f$make_pva_value (exchange_package.trap_pointer, display_option_full, 
          work_area), attribute_record_index, attribute_record_p);                                            
                                                                                                              
    p$add_record_field ('debug_index', clf#make_clt$integer_value                                             
          (exchange_package.debug_index, 16, TRUE, work_area), attribute_record_index, attribute_record_p);   
                                                                                                              
    p$add_record_field ('debug_list_pointer', f$make_pva_value                                                
          (exchange_package.debug_list_pointer.pva, display_option_full, work_area), attribute_record_index,  
          attribute_record_p);                                                                                
                                                                                                              
    p$add_record_field ('debug_mask_register', f$make_debug_mask_reg_value                                    
          (exchange_package.debug_mask_register, work_area), attribute_record_index, attribute_record_p);     
                                                                                                              
    p$add_record_field ('x_registers', f$make_x_registers_value (exchange_package.x_registers, work_area),    
          attribute_record_index, attribute_record_p);                                                        
                                                                                                              
    p$add_record_field ('tos_registers', f$make_tos_registers_value                                           
          (exchange_package.tos_registers, display_option_full, work_area), attribute_record_index,           
          attribute_record_p);                                                                                
                                                                                                              
    IF display_option_full THEN                                                                               
      p$add_record_field ('undefined1', clf#make_clt$integer_value                                            
            (exchange_package.undefined1, 16, TRUE, work_area), attribute_record_index, attribute_record_p);  
      p$add_record_field ('undefined2', clf#make_clt$integer_value                                            
            (exchange_package.undefined2, 16, TRUE, work_area), attribute_record_index, attribute_record_p);  
      p$add_record_field ('undefined3', clf#make_clt$integer_value                                            
            (exchange_package.undefined3, 16, TRUE, work_area), attribute_record_index, attribute_record_p);  
      p$add_record_field ('undefined4', clf#make_clt$integer_value                                            
            (exchange_package.undefined4, 16, TRUE, work_area), attribute_record_index, attribute_record_p);  
      p$add_record_field ('undefined5', clf#make_clt$integer_value                                            
            (exchange_package.undefined5, 16, TRUE, work_area), attribute_record_index, attribute_record_p);  
      p$add_record_field ('undefined6', clf#make_clt$integer_value                                            
            (exchange_package.undefined6, 16, TRUE, work_area), attribute_record_index, attribute_record_p);  
    IFEND;                                                                                                    
                                                                                                              
    result_p := attribute_record_p;                                                                           
                                                                                                              
  PROCEND p$make_exchange_package;                                                                            
?? OLDTITLE ??                                                                                                
?? NEWTITLE := '[unsafe] F$MAKE_KEYPOINT_MASK_VALUE', EJECT ??                                                
                                                                                                              
  FUNCTION [UNSAFE] f$make_keypoint_mask_value                                                                
    (    keypoint_mask: ost$keypoint_mask;                                                                    
     VAR work_area_p: ^clt$work_area): ^clt$data_value;                                                       
                                                                                                              
    VAR                                                                                                       
      class: ost$keypoint_class,                                                                              
      value_p: ^clt$data_value,                                                                               
      value_pp: ^^clt$data_value;                                                                             
                                                                                                              
    value_pp := ^value_p;                                                                                     
                                                                                                              
    FOR class := LOWERVALUE (ost$keypoint_class) TO UPPERVALUE (ost$keypoint_class) DO                        
      IF class IN keypoint_mask THEN                                                                          
        value_pp^ := clf#make_list_value (clf#make_clt$integer_value (class, 16, TRUE, work_area_p),          
              work_area_p);                                                                                   
        value_pp := ^value_pp^^.link;                                                                         
      IFEND;                                                                                                  
    FOREND;                                                                                                   
                                                                                                              
    IF value_pp = ^value_p THEN                                                                               
      f$make_keypoint_mask_value := clf#make_list_value (NIL, work_area_p);                                   
    ELSE                                                                                                      
      f$make_keypoint_mask_value := value_p;                                                                  
    IFEND;                                                                                                    
                                                                                                              
  FUNCEND f$make_keypoint_mask_value;                                                                         
?? OLDTITLE ??                                                                                                
?? NEWTITLE := '[unsafe] F$MAKE_OST$FLAGS_VALUE', EJECT ??                                                    
                                                                                                              
  FUNCTION [UNSAFE] f$make_ost$flags_value                                                                    
    (    flags: ost$flags;                                                                                    
     VAR work_area_p: ^clt$work_area): ^clt$data_value;                                                       
                                                                                                              
    VAR                                                                                                       
      v$flag_names: [READ] array [ost$flag] of string (19) := [                                               
{ OSC$CRITICAL_FRAME       } 'CRITICAL_FRAME     ',                                                           
{ OSC$ON_CONDITION         } 'ON_CONDITION       ',                                                           
{ OSC$KEYPOINT_ENABLE      } 'KEYPOINT_ENABLE    ',                                                           
{ OSC$PROCESS_NOT_DAMAGED  } 'PROCESS_NOT_DAMAGED'];                                                          
                                                                                                              
    VAR                                                                                                       
      result_p: ^clt$data_value,                                                                              
      flag: ost$flag,                                                                                         
      value_p: ^clt$data_value,                                                                               
      value_pp: ^^clt$data_value;                                                                             
                                                                                                              
    value_pp := ^value_p;                                                                                     
                                                                                                              
    FOR flag := LOWERVALUE (ost$flag) TO UPPERVALUE (ost$flag) DO                                             
      IF flag IN flags THEN                                                                                   
        clp$make_name_value (v$flag_names [flag], work_area_p, result_p);                                     
        value_pp^ := clf#make_list_value (result_p, work_area_p);                                             
        value_pp := ^value_pp^^.link;                                                                         
      IFEND;                                                                                                  
    FOREND;                                                                                                   
                                                                                                              
    IF value_pp = ^value_p THEN                                                                               
      f$make_ost$flags_value := clf#make_list_value (NIL, work_area_p);                                       
    ELSE                                                                                                      
      f$make_ost$flags_value := value_p;                                                                      
    IFEND;                                                                                                    
                                                                                                              
  FUNCEND f$make_ost$flags_value;                                                                             
?? OLDTITLE ??                                                                                                
?? NEWTITLE := '[unsafe] F$MAKE_OUTPUT_FILE_VALUE', EJECT ??                                                  
                                                                                                              
  FUNCTION [UNSAFE] f$make_output_file_value                                                                  
    (VAR work_area_p: ^clt$work_area): ^clt$data_value;                                                       
                                                                                                              
    VAR                                                                                                       
      ignore_user_def_attribute_size: fst$user_defined_attribute_size,                                        
      resolved_file_reference: fst$resolved_file_reference,                                                   
      result_p: ^clt$data_value,                                                                              
      status: ost$status;                                                                                     
                                                                                                              
    IF (duv$execution_environment.output_file_opened = FALSE) THEN                                            
      clp$make_file_value (clc$null_file, work_area_p, result_p);                                             
                                                                                                              
    ELSE                                                                                                      
      fsp$get_open_information (duv$execution_environment.output_file.display_control.file_id, NIL, NIL, NIL, 
            NIL, NIL, ^resolved_file_reference, NIL, ignore_user_def_attribute_size, status);                 
      IF status.normal THEN                                                                                   
        clp$make_file_value (resolved_file_reference.path (1, resolved_file_reference.cycle_path_size),       
              work_area_p, result_p);                                                                         
      ELSE                                                                                                    
        result_p := clf#make_unspecified_value (work_area_p);                                                 
      IFEND;                                                                                                  
    IFEND;                                                                                                    
                                                                                                              
    f$make_output_file_value := result_p;                                                                     
                                                                                                              
  FUNCEND f$make_output_file_value;                                                                           
?? OLDTITLE ??                                                                                                
?? NEWTITLE := '[unsafe] F$MAKE_PROCESSOR_REGISTER_VALUE', EJECT ??                                           
                                                                                                              
  FUNCTION [UNSAFE] f$make_processor_register_value                                                           
    (    processor_registers: dut$ee_processor_registers;                                                     
         include_status_summary: boolean;                                                                     
     VAR work_area: ^clt$work_area): ^clt$data_value;                                                         
                                                                                                              
    VAR                                                                                                       
      attribute_record_index: 0 .. clc$max_fields,                                                            
      attribute_record_p: ^clt$data_value,                                                                    
      psm: dut$ee_psm_value,                                                                                  
      pta: dut$ee_pta_value,                                                                                  
      ptl: dut$ee_ptl_value;                                                                                  
                                                                                                              
    IF NOT processor_registers.available THEN                                                                 
      f$make_processor_register_value := clf#make_unspecified_value (work_area);                              
      RETURN; {----->                                                                                         
    IFEND;                                                                                                    
                                                                                                              
    attribute_record_index := 0;                                                                              
    IF include_status_summary THEN                                                                            
      attribute_record_p := clf#make_record_header_value (6, work_area);                                      
                                                                                                              
      #SPOIL (work_area);                                                                                     
      clp#add_record_field ('STATUS_SUMMARY', f$make_status_summary_value                                     
            (processor_registers.status_summary, work_area), attribute_record_index, attribute_record_p);     
    ELSE                                                                                                      
      attribute_record_p := clf#make_record_header_value (5, work_area);                                      
    IFEND;                                                                                                    
                                                                                                              
    #SPOIL (work_area);                                                                                       
    clp#add_record_field ('JOB_PROCESS_STATE', clf#make_clt$integer_value                                     
          (processor_registers.job_process_state, 16 {radix} , TRUE {include radix} , work_area),             
          attribute_record_index, attribute_record_p);                                                        
                                                                                                              
    #SPOIL (work_area);                                                                                       
    clp#add_record_field ('MONITOR_PROCESS_STATE', clf#make_clt$integer_value                                 
          (processor_registers.monitor_process_state, 16 {radix} , TRUE {include radix} , work_area),         
          attribute_record_index, attribute_record_p);                                                        
                                                                                                              
    psm.psm := processor_registers.page_size_mask;                                                            
    #SPOIL (work_area);                                                                                       
    clp#add_record_field ('PAGE_SIZE_MASK', clf#make_clt$integer_value (psm.value, 16 {radix} , TRUE          
          {include radix} , work_area), attribute_record_index, attribute_record_p);                          
                                                                                                              
    pta.pta := processor_registers.page_table_address;                                                        
    #SPOIL (work_area);                                                                                       
    clp#add_record_field ('PAGE_TABLE_ADDRESS', clf#make_clt$integer_value (pta.value, 16 {radix} , TRUE      
          {include radix} , work_area), attribute_record_index, attribute_record_p);                          
                                                                                                              
    ptl.ptl := processor_registers.page_table_length;                                                         
    #SPOIL (work_area);                                                                                       
    clp#add_record_field ('PAGE_TABLE_LENGTH', clf#make_clt$integer_value (ptl.value, 16 {radix} , TRUE       
          {include radix} , work_area), attribute_record_index, attribute_record_p);                          
                                                                                                              
    f$make_processor_register_value := attribute_record_p;                                                    
                                                                                                              
  FUNCEND f$make_processor_register_value;                                                                    
?? OLDTITLE ??                                                                                                
?? NEWTITLE := '[unsafe] F$MAKE_PROC_REGISTER_VALUES', EJECT ??                                               
                                                                                                              
  FUNCTION [UNSAFE] f$make_proc_register_values                                                               
    (    processor_registers: array [0 .. duc$de_maximum_processors] of dut$ee_processor_registers;           
         include_status_summary: boolean;                                                                     
     VAR work_area: ^clt$work_area): ^clt$data_value;                                                         
                                                                                                              
    CONST                                                                                                     
      c$processor_index_name_size = 11;                                                                       
                                                                                                              
    VAR                                                                                                       
      attribute_record_index: 0 .. clc$max_fields,                                                            
      attribute_record_p: ^clt$data_value,                                                                    
      processor_index: 0 .. duc$de_maximum_processors,                                                        
      processor_index_name: string (c$processor_index_name_size);                                             
                                                                                                              
    processor_index_name := 'PROCESSOR_x';                                                                    
    attribute_record_p := clf#make_record_header_value (duc$de_maximum_processors + 1, work_area);            
    attribute_record_index := 0;                                                                              
                                                                                                              
    FOR processor_index := 0 TO duc$de_maximum_processors DO                                                  
      processor_index_name (c$processor_index_name_size) := $CHAR ($INTEGER ('0') + processor_index);         
      #SPOIL (work_area);                                                                                     
      clp#add_record_field (processor_index_name, f$make_processor_register_value                             
            (processor_registers [processor_index], include_status_summary, work_area),                       
            attribute_record_index, attribute_record_p);                                                      
    FOREND;                                                                                                   
                                                                                                              
    f$make_proc_register_values := attribute_record_p;                                                        
                                                                                                              
  FUNCEND f$make_proc_register_values;                                                                        
?? OLDTITLE ??                                                                                                
?? NEWTITLE := '[unsafe] F$MAKE_P_REGISTER_VALUE', EJECT ??                                                   
                                                                                                              
  FUNCTION [UNSAFE] f$make_p_register_value                                                                   
    (    p_register: ost$p_register;                                                                          
         display_option_full: boolean;                                                                        
     VAR work_area: ^clt$work_area): ^clt$data_value;                                                         
                                                                                                              
    VAR                                                                                                       
      attribute_record_index: 0 .. clc$max_fields,                                                            
      attribute_record_p: ^clt$data_value;                                                                    
                                                                                                              
    IF display_option_full THEN                                                                               
      attribute_record_index := 0;                                                                            
      attribute_record_p := clf#make_record_header_value (5, work_area);                                      
                                                                                                              
      clp#add_record_field ('undefined1', clf#make_integer_value (p_register.undefined1, work_area),          
            attribute_record_index, attribute_record_p);                                                      
                                                                                                              
      clp#add_record_field ('global_key', clf#make_integer_value (p_register.global_key, work_area),          
            attribute_record_index, attribute_record_p);                                                      
                                                                                                              
      clp#add_record_field ('undefined2', clf#make_integer_value (p_register.undefined2, work_area),          
            attribute_record_index, attribute_record_p);                                                      
                                                                                                              
      clp#add_record_field ('local_key', clf#make_integer_value (p_register.local_key, work_area),            
            attribute_record_index, attribute_record_p);                                                      
                                                                                                              
      clp#add_record_field ('pva', f$make_pva_value (p_register.pva, display_option_full, work_area),         
            attribute_record_index, attribute_record_p);                                                      
    ELSE                                                                                                      
      attribute_record_p := f$make_pva_value (p_register.pva, display_option_full, work_area);                
    IFEND;                                                                                                    
                                                                                                              
    f$make_p_register_value := attribute_record_p;                                                            
                                                                                                              
  FUNCEND f$make_p_register_value;                                                                            
?? OLDTITLE ??                                                                                                
?? NEWTITLE := '[unsafe] F$MAKE_PVA_VALUE', EJECT ??                                                          
                                                                                                              
  FUNCTION [UNSAFE] f$make_pva_value                                                                          
    (    pva: ost$pva;                                                                                        
         display_option_full: boolean;                                                                        
     VAR work_area: ^clt$work_area): ^clt$data_value;                                                         
                                                                                                              
    VAR                                                                                                       
      attribute_record_index: 0 .. clc$max_fields,                                                            
      attribute_record_p: ^clt$data_value;                                                                    
                                                                                                              
    IF display_option_full THEN                                                                               
      attribute_record_index := 0;                                                                            
      attribute_record_p := clf#make_record_header_value (3, work_area);                                      
                                                                                                              
      clp#add_record_field ('ring', clf#make_clt$integer_value (pva.ring, 16, TRUE, work_area),               
            attribute_record_index, attribute_record_p);                                                      
      clp#add_record_field ('segment', clf#make_clt$integer_value (pva.seg, 16, TRUE, work_area),             
            attribute_record_index, attribute_record_p);                                                      
      clp#add_record_field ('offset', clf#make_clt$integer_value (pva.offset, 16, TRUE, work_area),           
            attribute_record_index, attribute_record_p);                                                      
    ELSE                                                                                                      
      attribute_record_p := clf#make_clt$integer_value ((pva.ring * 100000000000(16)) +                       
            (pva.seg * 100000000(16)) + (pva.offset), 16, TRUE, work_area);                                   
    IFEND;                                                                                                    
                                                                                                              
    f$make_pva_value := attribute_record_p;                                                                   
                                                                                                              
  FUNCEND f$make_pva_value;                                                                                   
?? OLDTITLE ??                                                                                                
?? NEWTITLE := '[unsafe] F$MAKE_RESTART_FILE_VALUE', EJECT ??                                                 
                                                                                                              
  FUNCTION [UNSAFE] f$make_restart_file_value                                                                 
    (VAR work_area_p: ^clt$work_area): ^clt$data_value;                                                       
                                                                                                              
    VAR                                                                                                       
      i: integer,                                                                                             
      ignore_user_def_attribute_size: fst$user_defined_attribute_size,                                        
      resolved_file_reference: fst$resolved_file_reference,                                                   
      result_p: ^clt$data_value,                                                                              
      status: ost$status,                                                                                     
      value_p: ^clt$data_value,                                                                               
      value_pp: ^^clt$data_value;                                                                             
                                                                                                              
    value_pp := ^value_p;                                                                                     
    IF duv$dump_environment_p <> NIL THEN                                                                     
      FOR i := 1 TO UPPERBOUND (duv$execution_environment.restart_files) DO                                   
        IF duv$execution_environment.restart_files [i].opened THEN                                            
          fsp$get_open_information (duv$execution_environment.restart_files [i].file_identifier, NIL, NIL,    
                NIL, NIL, NIL, ^resolved_file_reference, NIL, ignore_user_def_attribute_size, status);        
          IF status.normal THEN                                                                               
            clp$make_file_value (resolved_file_reference.path (1, resolved_file_reference.cycle_path_size),   
                  work_area_p, result_p);                                                                     
            value_pp^ := clf#make_list_value (result_p, work_area_p);                                         
          ELSE                                                                                                
            value_pp^ := clf#make_list_value (clf#make_unspecified_value (work_area_p), work_area_p);         
          IFEND;                                                                                              
          value_pp := ^value_pp^^.link;                                                                       
        IFEND;                                                                                                
      FOREND;                                                                                                 
    IFEND;                                                                                                    
                                                                                                              
    IF value_pp = ^value_p THEN                                                                               
      f$make_restart_file_value := clf#make_list_value (NIL, work_area_p);                                    
    ELSE                                                                                                      
      f$make_restart_file_value := value_p;                                                                   
    IFEND;                                                                                                    
                                                                                                              
  FUNCEND f$make_restart_file_value;                                                                          
?? OLDTITLE ??                                                                                                
?? NEWTITLE := '[unsafe] F$MAKE_STATUS_SUMMARY_VALUE', EJECT ??                                               
                                                                                                              
  FUNCTION [UNSAFE] f$make_status_summary_value                                                               
    (    status_summary: dut$ee_processor_status_summary;                                                     
     VAR work_area: ^clt$work_area): ^clt$data_value;                                                         
                                                                                                              
    VAR                                                                                                       
      v$pro_cy2000_ss_reg_bit_names: [READ] array [dut$ee_pro_cy2000_ss_reg_bits] of string (21) := [         
{ DUC$EE_CY_NOT_USED_48                } 'NOT_USED_48          ',                                             
{ DUC$EE_CY_NOT_USED_49                } 'NOT_USED_49          ',                                             
{ DUC$EE_CY_NOT_USED_50                } 'NOT_USED_50          ',                                             
{ DUC$EE_CY_NOT_USED_51                } 'NOT_USED_51          ',                                             
{ DUC$EE_CY_NOT_USED_52                } 'NOT_USED_52          ',                                             
{ DUC$EE_CY_MONITOR_MODE               } 'MONITOR_MODE         ',                                             
{ DUC$EE_CY_CLOCK_HALTED_1             } 'CLOCK_HALTED_1       ',                                             
{ DUC$EE_CY_CLOCK_HALTED_2             } 'CLOCK_HALTED_2       ',                                             
{ DUC$EE_CY_PMF_HALTED                 } 'PMF_HALTED           ',                                             
{ DUC$EE_CY_CAPTURE_BUFFER_HALTED      } 'CAPTURE_BUFFER_HALTED',                                             
{ DUC$EE_CY_MICROCODE_HALTED           } 'MICROCODE_HALTED     ',                                             
{ DUC$EE_CY_NOT_USED_59                } 'NOT_USED_59          ',                                             
{ DUC$EE_CY_MAC_HALT                   } 'MAC_HALT             ',                                             
{ DUC$EE_CY_DUE                        } 'DUE                  ',                                             
{ DUC$EE_CY_SUBSYSTEM_FAULT_BIT        } 'SUBSYSTEM_FAULT_BIT  ',                                             
{ DUC$EE_CY_RETRYABLE_ERROR            } 'RETRYABLE_ERROR      '];                                            
                                                                                                              
    VAR                                                                                                       
      v$pro_general_ss_reg_bit_names: [READ] array [dut$ee_pro_general_ss_reg_bits] of string (19) := [       
{ DUC$EE_GEN_NOT_USED_48               } 'NOT_USED_48        ',                                               
{ DUC$EE_GEN_NOT_USED_49               } 'NOT_USED_49        ',                                               
{ DUC$EE_GEN_NOT_USED_50               } 'NOT_USED_50        ',                                               
{ DUC$EE_GEN_NOT_USED_51               } 'NOT_USED_51        ',                                               
{ DUC$EE_GEN_NOT_USED_52               } 'NOT_USED_52        ',                                               
{ DUC$EE_GEN_NOT_USED_53               } 'NOT_USED_53        ',                                               
{ DUC$EE_GEN_NOT_USED_54               } 'NOT_USED_54        ',                                               
{ DUC$EE_GEN_NOT_USED_55               } 'NOT_USED_55        ',                                               
{ DUC$EE_GEN_NOT_USED_56               } 'NOT_USED_56        ',                                               
{ DUC$EE_GEN_NOT_USED_57               } 'NOT_USED_57        ',                                               
{ DUC$EE_GEN_180_MONITOR_MODE          } '180_MONITOR_MODE   ',                                               
{ DUC$EE_GEN_SHORT_WARNING             } 'SHORT_WARNING      ',                                               
{ DUC$EE_GEN_PROCESSOR_HALT            } 'PROCESSOR_HALT     ',                                               
{ DUC$EE_GEN_UNCORRECTABLE_ERROR       } 'UNCORRECTABLE_ERROR',                                               
{ DUC$EE_GEN_CORRECTED_ERROR           } 'CORRECTED_ERROR    ',                                               
{ DUC$EE_GEN_LONG_WARNING              } 'LONG_WARNING       '];                                              
                                                                                                              
    VAR                                                                                                       
      dump_information: dut$dump_information;                                                                 
                                                                                                              
?? NEWTITLE := '[unsafe] F$MAKE_CY2000_SS_VALUE', EJECT ??                                                    
                                                                                                              
    FUNCTION [UNSAFE] f$make_cy2000_ss_value                                                                  
      (    status_summary: dut$ee_pro_cy2000_ss_set;                                                          
       VAR work_area: ^clt$work_area): ^clt$data_value;                                                       
                                                                                                              
      VAR                                                                                                     
        ss_bit: dut$ee_pro_cy2000_ss_reg_bits,                                                                
        value_p: ^clt$data_value,                                                                             
        value_pp: ^^clt$data_value;                                                                           
                                                                                                              
      value_pp := ^value_p;                                                                                   
                                                                                                              
      FOR ss_bit := LOWERVALUE (dut$ee_pro_cy2000_ss_reg_bits)                                                
            TO UPPERVALUE (dut$ee_pro_cy2000_ss_reg_bits) DO                                                  
        IF ss_bit IN status_summary THEN                                                                      
          value_pp^ := clf#make_list_value (clf#make_keyword_value                                            
                (v$pro_cy2000_ss_reg_bit_names [ss_bit], work_area), work_area);                              
          value_pp := ^value_pp^^.link;                                                                       
        IFEND;                                                                                                
      FOREND;                                                                                                 
                                                                                                              
      IF value_pp = ^value_p THEN                                                                             
        f$make_cy2000_ss_value := clf#make_list_value (NIL, work_area);                                       
      ELSE                                                                                                    
        f$make_cy2000_ss_value := value_p;                                                                    
      IFEND;                                                                                                  
                                                                                                              
    FUNCEND f$make_cy2000_ss_value;                                                                           
?? OLDTITLE ??                                                                                                
?? NEWTITLE := '[unsafe] F$MAKE_GENERAL_SS_VALUE', EJECT ??                                                   
                                                                                                              
    FUNCTION [UNSAFE] f$make_general_ss_value                                                                 
      (    status_summary: dut$ee_pro_general_ss_set;                                                         
       VAR work_area: ^clt$work_area): ^clt$data_value;                                                       
                                                                                                              
      VAR                                                                                                     
        ss_bit: dut$ee_pro_general_ss_reg_bits,                                                               
        value_p: ^clt$data_value,                                                                             
        value_pp: ^^clt$data_value;                                                                           
                                                                                                              
      FOR ss_bit := LOWERVALUE (dut$ee_pro_general_ss_reg_bits)                                               
            TO UPPERVALUE (dut$ee_pro_general_ss_reg_bits) DO                                                 
        IF ss_bit IN status_summary THEN                                                                      
          value_pp^ := clf#make_list_value (clf#make_keyword_value                                            
                (v$pro_general_ss_reg_bit_names [ss_bit], work_area), work_area);                             
          value_pp := ^value_pp^^.link;                                                                       
        IFEND;                                                                                                
      FOREND;                                                                                                 
                                                                                                              
      IF value_pp = ^value_p THEN                                                                             
        f$make_general_ss_value := clf#make_list_value (NIL, work_area);                                      
      ELSE                                                                                                    
        f$make_general_ss_value := value_p;                                                                   
      IFEND;                                                                                                  
                                                                                                              
    FUNCEND f$make_general_ss_value;                                                                          
?? OLDTITLE ??                                                                                                
?? EJECT ??                                                                                                   
                                                                                                              
    dup$determine_dump_information (dump_information);                                                        
                                                                                                              
    IF dump_information.dump_type = duc$di_dt_cy2000 THEN                                                     
      f$make_status_summary_value := f$make_cy2000_ss_value (status_summary.cy2000, work_area);               
    ELSE                                                                                                      
      f$make_status_summary_value := f$make_general_ss_value (status_summary.general, work_area);             
    IFEND;                                                                                                    
                                                                                                              
  FUNCEND f$make_status_summary_value;                                                                        
?? OLDTITLE ??                                                                                                
?? NEWTITLE := '[unsafe] F$MAKE_OST$TRAP_ENABLE', EJECT ??                                                    
                                                                                                              
  FUNCTION [UNSAFE] f$make_ost$trap_enable                                                                    
    (    trap_enable: ost$trap_enable;                                                                        
     VAR work_area_p: ^clt$work_area): ^clt$data_value;                                                       
                                                                                                              
    VAR                                                                                                       
      v$trap_enable_names: [READ] array [ost$trap_enable] of string (19) := [                                 
{ OSC$TRAPS_DISABLED       } 'TRAPS_DISABLED     ',                                                           
{ OSC$TRAPS_UNDEFINED      } 'TRAPS_UNDEFINED    ',                                                           
{ OSC$TRAPS_ENABLED        } 'TRAPS_ENABLED      ',                                                           
{ OSC$TRAPS_ENABLED_DELAY  } 'TRAPS_ENABLED_DELAY'];                                                          
                                                                                                              
    VAR                                                                                                       
      result_p: ^clt$data_value;                                                                              
                                                                                                              
    IF (trap_enable >= LOWERBOUND (v$trap_enable_names))                                                      
{ } AND (trap_enable <= UPPERBOUND (v$trap_enable_names)) THEN                                                
                                                                                                              
      clp$make_name_value (v$trap_enable_names [trap_enable], work_area_p, result_p);                         
    ELSE                                                                                                      
      clp$make_name_value ('unknown', work_area_p, result_p);                                                 
    IFEND;                                                                                                    
                                                                                                              
    f$make_ost$trap_enable := result_p;                                                                       
                                                                                                              
  FUNCEND f$make_ost$trap_enable;                                                                             
?? OLDTITLE ??                                                                                                
?? NEWTITLE := '[unsafe] F$MAKE_MONITOR_CONDITIONS_VALUE', EJECT ??                                           
                                                                                                              
  FUNCTION [UNSAFE] f$make_monitor_conditions_value                                                           
    (    monitor_conditions: ost$monitor_conditions;                                                          
     VAR work_area_p: ^clt$work_area): ^clt$data_value;                                                       
                                                                                                              
    VAR                                                                                                       
      v$monitor_conditions_names: [READ] array [ost$monitor_condition] of string (26) := [                    
{ OSC$DETECTED_UNCORRECTED_ERR         } 'DETECTED_UNCORRECTED_ERROR',                                        
{ OSC$NOT_ASSIGNED                     } 'NOT_ASSIGNED              ',                                        
{ OSC$SHORT_WARNING                    } 'SHORT_WARNING             ',                                        
{ OSC$INSTRUCTION_SPEC                 } 'INSTRUCTION_SPEC          ',                                        
{ OSC$ADDRESS_SPECIFICATION            } 'ADDRESS_SPECIFICATION     ',                                        
{ OSC$EXCHANGE_REQUEST                 } 'EXCHANGE_REQUEST          ',                                        
{ OSC$ACCESS_VIOLATION                 } 'ACCESS_VIOLATION          ',                                        
{ OSC$ENVIRONMENT_SPEC                 } 'ENVIRONMENT_SPEC          ',                                        
{ OSC$EXTERNAL_INTERRUPT               } 'EXTERNAL_INTERRUPT        ',                                        
{ OSC$PAGE_FAULT                       } 'PAGE_FAULT                ',                                        
{ OSC$SYSTEM_CALL                      } 'SYSTEM_CALL               ',                                        
{ OSC$SYSTEM_INTERVAL_TIMER            } 'SYSTEM_INTERVAL_TIMER     ',                                        
{ OSC$INVALID_SEGMENT_RING_0           } 'INVALID_SEGMENT_RING_0    ',                                        
{ OSC$OUT_CALL_IN_RETURN               } 'OUT_CALL_IN_RETURN        ',                                        
{ OSC$SOFT_ERROR                       } 'SOFT_ERROR                ',                                        
{ OSC$TRAP_EXCEPTION                   } 'TRAP_EXCEPTION            '];                                       
                                                                                                              
    VAR                                                                                                       
      value_p: ^clt$data_value,                                                                               
      result_p: ^clt$data_value,                                                                              
      monitor_condition: ost$monitor_condition,                                                               
      value_pp: ^^clt$data_value;                                                                             
                                                                                                              
    value_pp := ^value_p;                                                                                     
                                                                                                              
    FOR monitor_condition := LOWERVALUE (ost$monitor_condition) TO UPPERVALUE (ost$monitor_condition) DO      
      IF monitor_condition IN monitor_conditions THEN                                                         
        clp$make_name_value (v$monitor_conditions_names [monitor_condition], work_area_p, result_p);          
        value_pp^ := clf#make_list_value (result_p, work_area_p);                                             
        value_pp := ^value_pp^^.link;                                                                         
      IFEND;                                                                                                  
    FOREND;                                                                                                   
                                                                                                              
    IF value_pp = ^value_p THEN                                                                               
      f$make_monitor_conditions_value := clf#make_list_value (NIL, work_area_p);                              
    ELSE                                                                                                      
      f$make_monitor_conditions_value := value_p;                                                             
    IFEND;                                                                                                    
                                                                                                              
  FUNCEND f$make_monitor_conditions_value;                                                                    
?? OLDTITLE ??                                                                                                
?? NEWTITLE := '[unsafe] f$make_tos_registers_value', EJECT ??                                                
                                                                                                              
  FUNCTION [UNSAFE] f$make_tos_registers_value                                                                
    (    tos_registers: array [ost$valid_ring] of ost$top_of_stack_pointer;                                   
         display_option_full: boolean;                                                                        
     VAR work_area: ^clt$work_area): ^clt$data_value;                                                         
                                                                                                              
    VAR                                                                                                       
      r: ost$register_number,                                                                                 
      value_p: ^clt$data_value,                                                                               
      value_pp: ^^clt$data_value;                                                                             
                                                                                                              
?? NEWTITLE := '[unsafe] f$make_tos_register_value', EJECT ??                                                 
                                                                                                              
    FUNCTION [UNSAFE] f$make_tos_register_value                                                               
      (    tos_register: ost$top_of_stack_pointer;                                                            
           display_option_full: boolean;                                                                      
       VAR work_area: ^clt$work_area): ^clt$data_value;                                                       
                                                                                                              
      VAR                                                                                                     
        attribute_record_index: 0 .. clc$max_fields,                                                          
        attribute_record_p: ^clt$data_value;                                                                  
                                                                                                              
      attribute_record_index := 0;                                                                            
      IF display_option_full THEN                                                                             
        attribute_record_p := clf#make_record_header_value (3, work_area);                                    
        clp#add_record_field ('undefined', clf#make_clt$integer_value                                         
              (tos_register.undefined, 16, TRUE, work_area), attribute_record_index, attribute_record_p);     
      ELSE                                                                                                    
        attribute_record_p := clf#make_record_header_value (2, work_area);                                    
      IFEND;                                                                                                  
                                                                                                              
      clp#add_record_field ('largest_ring_number', clf#make_clt$integer_value                                 
            (tos_register.largest_ring_number, 16, TRUE, work_area), attribute_record_index,                  
            attribute_record_p);                                                                              
                                                                                                              
      clp#add_record_field ('pva', f$make_pva_value (tos_register.pva, display_option_full, work_area),       
            attribute_record_index, attribute_record_p);                                                      
                                                                                                              
      f$make_tos_register_value := attribute_record_p;                                                        
                                                                                                              
    FUNCEND f$make_tos_register_value;                                                                        
?? OLDTITLE ??                                                                                                
?? EJECT ??                                                                                                   
    value_pp := ^value_p;                                                                                     
                                                                                                              
    FOR r := LOWERBOUND (tos_registers) TO UPPERBOUND (tos_registers) DO                                      
      value_pp^ := clf#make_list_value (f$make_tos_register_value                                             
            (tos_registers [r], display_option_full, work_area), work_area);                                  
      value_pp := ^value_pp^^.link;                                                                           
    FOREND;                                                                                                   
                                                                                                              
    IF value_pp = ^value_p THEN                                                                               
      f$make_tos_registers_value := clf#make_list_value (NIL, work_area);                                     
    ELSE                                                                                                      
      f$make_tos_registers_value := value_p;                                                                  
    IFEND;                                                                                                    
                                                                                                              
  FUNCEND f$make_tos_registers_value;                                                                         
?? OLDTITLE ??                                                                                                
?? NEWTITLE := '[unsafe] F$MAKE_USER_CONDITIONS_VALUE', EJECT ??                                              
                                                                                                              
  FUNCTION [UNSAFE] f$make_user_conditions_value                                                              
    (    user_conditions: ost$user_conditions;                                                                
     VAR work_area_p: ^clt$work_area): ^clt$data_value;                                                       
                                                                                                              
    VAR                                                                                                       
      v$user_conditions_names: [READ] array [ost$user_condition] of string (25) := [                          
{ OSC$PRIVILEGED_INSTRUCTION           } 'PRIVILEGED_INSTRUCTION   ',                                         
{ OSC$UNIMPLEMENTED_INSTRUCTION        } 'UNIMPLEMENTED_INSTRUCTION',                                         
{ OSC$FREE_FLAG                        } 'FREE_FLAG                ',                                         
{ OSC$PROCESS_INTERVAL_TIMER           } 'PROCESS_INTERVAL_TIMER   ',                                         
{ OSC$INTER_RING_POP                   } 'INTER_RING_POP           ',                                         
{ OSC$CRITICAL_FRAME_FLAG              } 'CRITICAL_FRAME_FLAG      ',                                         
{ OSC$KEYPOINT                         } 'KEYPOINT                 ',                                         
{ OSC$DIVIDE_FAULT                     } 'DIVIDE_FAULT             ',                                         
{ OSC$DEBUG                            } 'DEBUG                    ',                                         
{ OSC$ARITHMETIC_OVERFLOW              } 'ARITHMETIC_OVERFLOW      ',                                         
{ OSC$EXPONENT_OVERFLOW                } 'EXPONENT_OVERFLOW        ',                                         
{ OSC$EXPONENT_UNDERFLOW               } 'EXPONENT_UNDERFLOW       ',                                         
{ OSC$FP_SIGNIFICANCE_LOSS             } 'FP_SIGNIFICANCE_LOSS     ',                                         
{ OSC$FP_INDEFINITE                    } 'FP_INDEFINITE            ',                                         
{ OSC$ARITHMETIC_SIGNIFICANCE          } 'ARITHMETIC_SIGNIFICANCE  ',                                         
{ OSC$INVALID_BDP_DATA                 } 'INVALID_BDP_DATA         '];                                        
                                                                                                              
    VAR                                                                                                       
      value_p: ^clt$data_value,                                                                               
      result_p: ^clt$data_value,                                                                              
      user_condition: ost$user_condition,                                                                     
      value_pp: ^^clt$data_value;                                                                             
                                                                                                              
    value_pp := ^value_p;                                                                                     
                                                                                                              
    FOR user_condition := LOWERVALUE (ost$user_condition) TO UPPERVALUE (ost$user_condition) DO               
      IF user_condition IN user_conditions THEN                                                               
        clp$make_name_value (v$user_conditions_names [user_condition], work_area_p, result_p);                
        value_pp^ := clf#make_list_value (result_p, work_area_p);                                             
        value_pp := ^value_pp^^.link;                                                                         
      IFEND;                                                                                                  
    FOREND;                                                                                                   
                                                                                                              
    IF value_pp = ^value_p THEN                                                                               
      f$make_user_conditions_value := clf#make_list_value (NIL, work_area_p);                                 
    ELSE                                                                                                      
      f$make_user_conditions_value := value_p;                                                                
    IFEND;                                                                                                    
                                                                                                              
  FUNCEND f$make_user_conditions_value;                                                                       
?? OLDTITLE ??                                                                                                
?? NEWTITLE := '[unsafe] F$MAKE_VIRTUAL_MACHINE_IDENT', EJECT ??                                              
                                                                                                              
  FUNCTION [UNSAFE] f$make_virtual_machine_ident                                                              
    (    virtual_machine_identifier: ost$virtual_machine_identifier;                                          
     VAR work_area: ^clt$work_area): ^clt$data_value;                                                         
                                                                                                              
    VAR                                                                                                       
      v$virtual_machine_ident_names: [READ] array [ost$virtual_machine_identifier] of string (14) := [        
{ OSC$CYBER_180_MODE         } 'CYBER_180_MODE',                                                              
{ OSC$CYBER_170_MODE         } 'CYBER_170_MODE',                                                              
{ OSC$50_RESERVED            } '50_RESERVED   ',                                                              
{ OSC$51_RESERVED            } '51_RESERVED   ',                                                              
{ OSC$52_RESERVED            } '52_RESERVED   ',                                                              
{ OSC$53_RESERVED            } '53_RESERVED   ',                                                              
{ OSC$54_RESERVED            } '54_RESERVED   ',                                                              
{ OSC$55_RESERVED            } '55_RESERVED   ',                                                              
{ OSC$56_RESERVED            } '56_RESERVED   ',                                                              
{ OSC$57_RESERVED            } '57_RESERVED   ',                                                              
{ OSC$58_RESERVED            } '58_RESERVED   ',                                                              
{ OSC$59_RESERVED            } '59_RESERVED   ',                                                              
{ OSC$60_RESERVED            } '60_RESERVED   ',                                                              
{ OSC$61_RESERVED            } '61_RESERVED   ',                                                              
{ OSC$62_RESERVED            } '62_RESERVED   ',                                                              
{ OSC$63_RESERVED            } '63_RESERVED   '];                                                             
                                                                                                              
    VAR                                                                                                       
      result_p: ^clt$data_value;                                                                              
                                                                                                              
    IF (virtual_machine_identifier >= LOWERBOUND (v$virtual_machine_ident_names))                             
{ } AND (virtual_machine_identifier <= UPPERBOUND (v$virtual_machine_ident_names)) THEN                       
                                                                                                              
      clp$make_name_value (v$virtual_machine_ident_names [virtual_machine_identifier], work_area, result_p);  
    ELSE                                                                                                      
      clp$make_name_value ('unknown', work_area, result_p);                                                   
    IFEND;                                                                                                    
                                                                                                              
    f$make_virtual_machine_ident := result_p;                                                                 
                                                                                                              
  FUNCEND f$make_virtual_machine_ident;                                                                       
?? OLDTITLE ??                                                                                                
?? NEWTITLE := '[unsafe] f$make_x_registers_value', EJECT ??                                                  
                                                                                                              
  FUNCTION [UNSAFE] f$make_x_registers_value                                                                  
    (    x_registers: array [ost$register_number] of ost$x_register;                                          
     VAR work_area: ^clt$work_area): ^clt$data_value;                                                         
                                                                                                              
    VAR                                                                                                       
      x: ost$register_number,                                                                                 
      value_p: ^clt$data_value,                                                                               
      value_pp: ^^clt$data_value;                                                                             
                                                                                                              
    value_pp := ^value_p;                                                                                     
                                                                                                              
    FOR x := LOWERBOUND (x_registers) TO UPPERBOUND (x_registers) DO                                          
      value_pp^ := clf#make_list_value (clf#make_clt$integer_value (x_registers [x], 16, TRUE, work_area),    
            work_area);                                                                                       
      value_pp := ^value_pp^^.link;                                                                           
    FOREND;                                                                                                   
                                                                                                              
    IF value_pp = ^value_p THEN                                                                               
      f$make_x_registers_value := clf#make_list_value (NIL, work_area);                                       
    ELSE                                                                                                      
      f$make_x_registers_value := value_p;                                                                    
    IFEND;                                                                                                    
                                                                                                              
  FUNCEND f$make_x_registers_value;                                                                           
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'convert_integer_to_hex_string', EJECT ??                                                      
                                                                                                              
{ PURPOSE:                                                                                                    
{   This procedure converts an integer word into a hex string representation of the word.                     
                                                                                                              
  PROCEDURE convert_integer_to_hex_string                                                                     
    (    value: integer;                                                                                      
         digits_to_convert: 1 .. 16;                                                                          
     VAR hex_string: string ( * <= 16));                                                                      
                                                                                                              
    VAR                                                                                                       
      digit: 0 .. 0f(16),                                                                                     
      digit_index: 1 .. 16,                                                                                   
      hex_array: packed array [1 .. 16] of 0 .. 0f(16),                                                       
      hex_digit: [STATIC] string (16) := '0123456789ABCDEF',                                                  
      temp_string: string (16);                                                                               
                                                                                                              
    #UNCHECKED_CONVERSION (value, hex_array);                                                                 
    temp_string := ' ';                                                                                       
    FOR digit_index := 1 TO digits_to_convert DO                                                              
      digit := hex_array [17 - digit_index];                                                                  
      temp_string (17 - digit_index) := hex_digit (digit + 1);                                                
    FOREND;                                                                                                   
    hex_string := temp_string (17 - STRLENGTH (hex_string), STRLENGTH (hex_string));                          
                                                                                                              
  PROCEND convert_integer_to_hex_string;                                                                      
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'dup$$analyze_dump_output', EJECT ??                                                           
                                                                                                              
{ PURPOSE:                                                                                                    
{   This function returns the name of the output file as a file.                                              
                                                                                                              
  PROCEDURE [XDCL] dup$$analyze_dump_output                                                                   
    (    parameter_list: clt$parameter_list;                                                                  
     VAR work_area_p: ^clt$work_area;                                                                         
     VAR result_p: ^clt$data_value;                                                                           
     VAR status: ost$status);                                                                                 
                                                                                                              
{ FUNCTION $analyze_dump_output, $ado (                                                                       
{   )                                                                                                         
                                                                                                              
?? PUSH (LISTEXT := ON) ??                                                                                    
?? FMT (FORMAT := OFF) ??                                                                                     
  VAR                                                                                                         
    pdt: [STATIC, READ, cls$declaration_section] record                                                       
      header: clt$pdt_header,                                                                                 
    recend := [                                                                                               
    [1,                                                                                                       
    [89, 6, 13, 13, 53, 27, 826],                                                                             
    clc$function, 0, 0, 0, 0, 0, 0, 0, '']];                                                                  
?? FMT (FORMAT := ON) ??                                                                                      
?? POP ??                                                                                                     
                                                                                                              
    VAR                                                                                                       
      value: dut$ee_output_file_record;                                                                       
                                                                                                              
    status.normal := TRUE;                                                                                    
    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, NIL, status);                                   
    IF NOT status.normal THEN                                                                                 
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    value := duv$execution_environment.output_file;                                                           
    clp$make_file_value (value.name (1, value.size), work_area_p, result_p);                                  
                                                                                                              
  PROCEND dup$$analyze_dump_output;                                                                           
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'dup$$analyze_dump_title', EJECT ??                                                            
                                                                                                              
{ PURPOSE:                                                                                                    
{   This function returns the main title of the dump as a string.                                             
                                                                                                              
  PROCEDURE [XDCL] dup$$analyze_dump_title                                                                    
    (    parameter_list: clt$parameter_list;                                                                  
     VAR work_area_p: ^clt$work_area;                                                                         
     VAR result_p: ^clt$data_value;                                                                           
     VAR status: ost$status);                                                                                 
                                                                                                              
{ FUNCTION $analyze_dump_title, $adt (                                                                        
{   )                                                                                                         
                                                                                                              
?? PUSH (LISTEXT := ON) ??                                                                                    
?? FMT (FORMAT := OFF) ??                                                                                     
  VAR                                                                                                         
    pdt: [STATIC, READ, cls$declaration_section] record                                                       
      header: clt$pdt_header,                                                                                 
    recend := [                                                                                               
    [1,                                                                                                       
    [89, 6, 13, 14, 4, 28, 956],                                                                              
    clc$function, 0, 0, 0, 0, 0, 0, 0, '']];                                                                  
?? FMT (FORMAT := ON) ??                                                                                      
?? POP ??                                                                                                     
                                                                                                              
    status.normal := TRUE;                                                                                    
    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, NIL, status);                                   
    IF NOT status.normal THEN                                                                                 
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    clp$make_string_value (duv$title_data.main_title, work_area_p, result_p);                                 
                                                                                                              
  PROCEND dup$$analyze_dump_title;                                                                            
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'dup$$available', EJECT ??                                                                     
                                                                                                              
{ PURPOSE:                                                                                                    
{   This function returns a boolean of TRUE if the specified record is available on the dump.                 
                                                                                                              
  PROCEDURE [XDCL] dup$$available                                                                             
    (    parameter_list: clt$parameter_list;                                                                  
     VAR work_area_p: ^clt$work_area;                                                                         
     VAR result_p: ^clt$data_value;                                                                           
     VAR status: ost$status);                                                                                 
                                                                                                              
{ FUNCTION $available, $avail (                                                                               
{   record_type: key of                                                                                       
{       (control_store cs c) (exchange e) (maintenance_registers mr m) (register_file rf r)                   
{     keyend = $required                                                                                      
{   processor: integer 0..3 = 0                                                                               
{   shadow: boolean = FALSE                                                                                   
{   )                                                                                                         
                                                                                                              
?? PUSH (LISTEXT := ON) ??                                                                                    
?? FMT (FORMAT := OFF) ??                                                                                     
  VAR                                                                                                         
    pdt: [STATIC, READ, cls$declaration_section] record                                                       
      header: clt$pdt_header,                                                                                 
      names: array [1 .. 3] of clt$pdt_parameter_name,                                                        
      parameters: array [1 .. 3] of clt$pdt_parameter,                                                        
      type1: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$keyword_type_qualifier,                                                                
        keyword_specs: array [1 .. 12] of clt$keyword_specification,                                          
      recend,                                                                                                 
      type2: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
        default_value: string (1),                                                                            
      recend,                                                                                                 
      type3: record                                                                                           
        header: clt$type_specification_header,                                                                
        default_value: string (5),                                                                            
      recend,                                                                                                 
    recend := [                                                                                               
    [1,                                                                                                       
    [90, 9, 19, 8, 8, 15, 295],                                                                               
    clc$function, 3, 3, 1, 0, 0, 0, 0, ''], [                                                                 
    ['PROCESSOR                      ',clc$nominal_entry, 2],                                                 
    ['RECORD_TYPE                    ',clc$nominal_entry, 1],                                                 
    ['SHADOW                         ',clc$nominal_entry, 3]],                                                
    [                                                                                                         
{ PARAMETER 1                                                                                                 
    [2, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 451,                        
  clc$required_parameter, 0, 0],                                                                              
{ PARAMETER 2                                                                                                 
    [1, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20,                         
  clc$optional_default_parameter, 0, 1],                                                                      
{ PARAMETER 3                                                                                                 
    [3, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3,                          
  clc$optional_default_parameter, 0, 5]],                                                                     
{ PARAMETER 1                                                                                                 
    [[1, 0, clc$keyword_type], [12], [                                                                        
    ['C                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],                   
    ['CONTROL_STORE                  ', clc$nominal_entry, clc$normal_usage_entry, 2],                        
    ['CS                             ', clc$alias_entry, clc$normal_usage_entry, 2],                          
    ['E                              ', clc$abbreviation_entry, clc$normal_usage_entry, 3],                   
    ['EXCHANGE                       ', clc$nominal_entry, clc$normal_usage_entry, 3],                        
    ['M                              ', clc$abbreviation_entry, clc$normal_usage_entry, 4],                   
    ['MAINTENANCE_REGISTERS          ', clc$nominal_entry, clc$normal_usage_entry, 4],                        
    ['MR                             ', clc$alias_entry, clc$normal_usage_entry, 4],                          
    ['OF                             ', clc$nominal_entry, clc$normal_usage_entry, 1],                        
    ['R                              ', clc$abbreviation_entry, clc$normal_usage_entry, 5],                   
    ['REGISTER_FILE                  ', clc$nominal_entry, clc$normal_usage_entry, 5],                        
    ['RF                             ', clc$alias_entry, clc$normal_usage_entry, 5]]                          
    ],                                                                                                        
{ PARAMETER 2                                                                                                 
    [[1, 0, clc$integer_type], [0, 3, 10],                                                                    
    '0'],                                                                                                     
{ PARAMETER 3                                                                                                 
    [[1, 0, clc$boolean_type],                                                                                
    'FALSE']];                                                                                                
?? FMT (FORMAT := ON) ??                                                                                      
?? POP ??                                                                                                     
                                                                                                              
    CONST                                                                                                     
      p$record_type = 1,                                                                                      
      p$processor = 2,                                                                                        
      p$shadow = 3;                                                                                           
                                                                                                              
    VAR                                                                                                       
      pvt: array [1 .. 3] of clt$parameter_value;                                                             
                                                                                                              
    VAR                                                                                                       
      default_list: array [1 .. 1] of dut$default_change_list_entry,                                          
      processor: 0 .. duc$de_maximum_processors,                                                              
      record_exists: boolean;                                                                                 
                                                                                                              
    status.normal := TRUE;                                                                                    
                                                                                                              
    { Change the default value for the PROCESSOR parameter.                                                   
                                                                                                              
    default_list [1].default_name := duc$dp_processor;                                                        
    default_list [1].number := p$processor;                                                                   
    dup$evaluate_parameters (parameter_list, default_list, #SEQ (pdt), ^pvt, status);                         
    IF NOT status.normal THEN                                                                                 
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    IF duv$dump_environment_p = NIL THEN                                                                      
      osp$set_status_abnormal (duc$dump_analyzer_id, due$no_restart_file, '', status);                        
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    processor := pvt [p$processor].value^.integer_value.value;                                                
                                                                                                              
    IF pvt [p$record_type].value^.keyword_value = 'CONTROL_STORE' THEN                                        
      IF pvt [p$shadow].value^.boolean_value.value THEN                                                       
        record_exists := duv$dump_environment_p^.control_store.shadow [processor].available;                  
      ELSE                                                                                                    
        record_exists := duv$dump_environment_p^.control_store.main [processor].available;                    
      IFEND;                                                                                                  
    ELSEIF pvt [p$record_type].value^.keyword_value = 'EXCHANGE' THEN                                         
      record_exists := duv$dump_environment_p^.active_exchange [processor].available;                         
    ELSEIF pvt [p$record_type].value^.keyword_value = 'MAINTENANCE_REGISTERS' THEN                            
      record_exists := duv$dump_environment_p^.pro_maintenance_registers [processor].available;               
    ELSE { pvt [p$record_type].value^.keyword_value = 'REGISTER_FILE'                                         
      record_exists := duv$dump_environment_p^.register_file [processor].available;                           
    IFEND;                                                                                                    
                                                                                                              
    clp$make_boolean_value (record_exists, clc$true_false_boolean, work_area_p, result_p);                    
                                                                                                              
  PROCEND dup$$available;                                                                                     
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'dup$$buffer_controlware', EJECT ??                                                            
                                                                                                              
{ PURPOSE:                                                                                                    
{   This function returns the value of a specified buffer controlware word as an integer.                     
                                                                                                              
  PROCEDURE [XDCL] dup$$buffer_controlware                                                                    
    (    parameter_list: clt$parameter_list;                                                                  
     VAR work_area_p: ^clt$work_area;                                                                         
     VAR result_p: ^clt$data_value;                                                                           
     VAR status: ost$status);                                                                                 
                                                                                                              
{ FUNCTION $buffer_controlware, $bc (                                                                         
{   word: integer 0..8192 = $required                                                                         
{   channel_number: integer 0..33 = $required                                                                 
{   )                                                                                                         
                                                                                                              
?? PUSH (LISTEXT := ON) ??                                                                                    
?? FMT (FORMAT := OFF) ??                                                                                     
  VAR                                                                                                         
    pdt: [STATIC, READ, cls$declaration_section] record                                                       
      header: clt$pdt_header,                                                                                 
      names: array [1 .. 2] of clt$pdt_parameter_name,                                                        
      parameters: array [1 .. 2] of clt$pdt_parameter,                                                        
      type1: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
      recend,                                                                                                 
      type2: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
      recend,                                                                                                 
    recend := [                                                                                               
    [1,                                                                                                       
    [89, 6, 16, 12, 29, 30, 579],                                                                             
    clc$function, 2, 2, 2, 0, 0, 0, 0, ''], [                                                                 
    ['CHANNEL_NUMBER                 ',clc$nominal_entry, 2],                                                 
    ['WORD                           ',clc$nominal_entry, 1]],                                                
    [                                                                                                         
{ PARAMETER 1                                                                                                 
    [2, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$required_parameter, 
  0, 0],                                                                                                      
{ PARAMETER 2                                                                                                 
    [1, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$required_parameter, 
  0, 0]],                                                                                                     
{ PARAMETER 1                                                                                                 
    [[1, 0, clc$integer_type], [0, 8192, 10]],                                                                
{ PARAMETER 2                                                                                                 
    [[1, 0, clc$integer_type], [0, 33, 10]]];                                                                 
?? FMT (FORMAT := ON) ??                                                                                      
?? POP ??                                                                                                     
                                                                                                              
    CONST                                                                                                     
      p$word = 1,                                                                                             
      p$channel_number = 2;                                                                                   
                                                                                                              
    VAR                                                                                                       
      pvt: array [1 .. 2] of clt$parameter_value;                                                             
                                                                                                              
    VAR                                                                                                       
      buffer_controlware_p: ^array [0 .. * ] of dut$de_buffer_controlware_word,                               
      buffer_controlware_size: 0 .. duc$de_maximum_bc_size,                                                   
      cell_p: ^cell,                                                                                          
      channel_number: 0 .. duc$de_maximum_channels,                                                           
      desired_word: 0 .. duc$de_maximum_bc_size,                                                              
      display_string: string (osc$max_string_size),                                                           
      entry_p: ^dut$de_buffer_controlware_entry,                                                              
      restart_file_seq_p: ^SEQ ( * ),                                                                         
      string_length: integer;                                                                                 
                                                                                                              
    status.normal := TRUE;                                                                                    
    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);                                  
    IF NOT status.normal THEN                                                                                 
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    IF duv$dump_environment_p = NIL THEN                                                                      
      osp$set_status_abnormal (duc$dump_analyzer_id, due$no_restart_file, '', status);                        
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    channel_number := pvt [p$channel_number].value^.integer_value.value;                                      
    dup$retrieve_bc_entry (channel_number, entry_p);                                                          
    IF entry_p = NIL THEN                                                                                     
      osp$set_status_abnormal (duc$dump_analyzer_id, due$data_not_on_dump,                                    
            'The buffer controlware for channel', status);                                                    
      osp$append_status_integer (osc$status_parameter_delimiter, channel_number, 10, FALSE, status);          
      osp$append_status_parameter (osc$status_parameter_delimiter, 'is', status);                             
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    desired_word := pvt [p$word].value^.integer_value.value;                                                  
    buffer_controlware_size := entry_p^.words - 1;                                                            
    IF desired_word > buffer_controlware_size THEN                                                            
      STRINGREP (display_string, string_length, 'Buffer controlware address ', desired_word: #(16),           
            '(16) is');                                                                                       
      osp$set_status_abnormal (duc$dump_analyzer_id, due$data_not_on_dump, display_string (1, string_length), 
            status);                                                                                          
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    restart_file_seq_p := duv$execution_environment.data_file_p^.segment_pointer.sequence_pointer;            
    cell_p := #ADDRESS (#RING (restart_file_seq_p), #SEGMENT (restart_file_seq_p), entry_p^.first_byte);      
    RESET restart_file_seq_p TO cell_p;                                                                       
    NEXT buffer_controlware_p: [0 .. buffer_controlware_size] IN restart_file_seq_p;                          
    IF buffer_controlware_p = NIL THEN                                                                        
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                            
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    clp$make_integer_value (buffer_controlware_p^ [desired_word], 16, TRUE, work_area_p, result_p);           
                                                                                                              
  PROCEND dup$$buffer_controlware;                                                                            
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'dup$$buffer_controlware_string', EJECT ??                                                     
                                                                                                              
{ PURPOSE:                                                                                                    
{   This function returns the value of a specified buffer controlware word as a string.                       
                                                                                                              
  PROCEDURE [XDCL] dup$$buffer_controlware_string                                                             
    (    parameter_list: clt$parameter_list;                                                                  
     VAR work_area_p: ^clt$work_area;                                                                         
     VAR result_p: ^clt$data_value;                                                                           
     VAR status: ost$status);                                                                                 
                                                                                                              
{ FUNCTION $buffer_controlware_string, $bcs (                                                                 
{   word: integer 0..8192 = $required                                                                         
{   channel_number: integer 0..33 = $required                                                                 
{   )                                                                                                         
                                                                                                              
?? PUSH (LISTEXT := ON) ??                                                                                    
?? FMT (FORMAT := OFF) ??                                                                                     
  VAR                                                                                                         
    pdt: [STATIC, READ, cls$declaration_section] record                                                       
      header: clt$pdt_header,                                                                                 
      names: array [1 .. 2] of clt$pdt_parameter_name,                                                        
      parameters: array [1 .. 2] of clt$pdt_parameter,                                                        
      type1: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
      recend,                                                                                                 
      type2: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
      recend,                                                                                                 
    recend := [                                                                                               
    [1,                                                                                                       
    [89, 6, 16, 12, 30, 37, 547],                                                                             
    clc$function, 2, 2, 2, 0, 0, 0, 0, ''], [                                                                 
    ['CHANNEL_NUMBER                 ',clc$nominal_entry, 2],                                                 
    ['WORD                           ',clc$nominal_entry, 1]],                                                
    [                                                                                                         
{ PARAMETER 1                                                                                                 
    [2, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$required_parameter, 
  0, 0],                                                                                                      
{ PARAMETER 2                                                                                                 
    [1, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$required_parameter, 
  0, 0]],                                                                                                     
{ PARAMETER 1                                                                                                 
    [[1, 0, clc$integer_type], [0, 8192, 10]],                                                                
{ PARAMETER 2                                                                                                 
    [[1, 0, clc$integer_type], [0, 33, 10]]];                                                                 
?? FMT (FORMAT := ON) ??                                                                                      
?? POP ??                                                                                                     
                                                                                                              
    CONST                                                                                                     
      p$word = 1,                                                                                             
      p$channel_number = 2;                                                                                   
                                                                                                              
    VAR                                                                                                       
      pvt: array [1 .. 2] of clt$parameter_value;                                                             
                                                                                                              
    VAR                                                                                                       
      buffer_controlware_p: ^array [0 .. * ] of dut$de_buffer_controlware_word,                               
      buffer_controlware_size: 0 .. duc$de_maximum_bc_size,                                                   
      cell_p: ^cell,                                                                                          
      channel_number: 0 .. duc$de_maximum_channels,                                                           
      desired_word: 0 .. duc$de_maximum_bc_size,                                                              
      display_string: string (osc$max_string_size),                                                           
      entry_p: ^dut$de_buffer_controlware_entry,                                                              
      restart_file_seq_p: ^SEQ ( * ),                                                                         
      string_4: string (4),                                                                                   
      string_length: integer;                                                                                 
                                                                                                              
    status.normal := TRUE;                                                                                    
    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);                                  
    IF NOT status.normal THEN                                                                                 
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    IF duv$dump_environment_p = NIL THEN                                                                      
      osp$set_status_abnormal (duc$dump_analyzer_id, due$no_restart_file, '', status);                        
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    channel_number := pvt [p$channel_number].value^.integer_value.value;                                      
    dup$retrieve_bc_entry (channel_number, entry_p);                                                          
    IF entry_p = NIL THEN                                                                                     
      osp$set_status_abnormal (duc$dump_analyzer_id, due$data_not_on_dump,                                    
            'The buffer controlware for channel', status);                                                    
      osp$append_status_integer (osc$status_parameter_delimiter, channel_number, 10, FALSE, status);          
      osp$append_status_parameter (osc$status_parameter_delimiter, 'is', status);                             
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    desired_word := pvt [p$word].value^.integer_value.value;                                                  
    buffer_controlware_size := entry_p^.words - 1;                                                            
    IF desired_word > buffer_controlware_size THEN                                                            
      STRINGREP (display_string, string_length, 'Buffer controlware address ', desired_word: #(16),           
            '(16) is');                                                                                       
      osp$set_status_abnormal (duc$dump_analyzer_id, due$data_not_on_dump, display_string (1, string_length), 
            status);                                                                                          
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    restart_file_seq_p := duv$execution_environment.data_file_p^.segment_pointer.sequence_pointer;            
    cell_p := #ADDRESS (#RING (restart_file_seq_p), #SEGMENT (restart_file_seq_p), entry_p^.first_byte);      
    RESET restart_file_seq_p TO cell_p;                                                                       
    NEXT buffer_controlware_p: [0 .. buffer_controlware_size] IN restart_file_seq_p;                          
    IF buffer_controlware_p = NIL THEN                                                                        
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                            
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    convert_integer_to_hex_string (buffer_controlware_p^ [desired_word], 4, string_4);                        
                                                                                                              
    clp$make_string_value (string_4, work_area_p, result_p);                                                  
                                                                                                              
  PROCEND dup$$buffer_controlware_string;                                                                     
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'dup$$channel_available', EJECT ??                                                             
                                                                                                              
{ PURPOSE:                                                                                                    
{   This function returns a boolean of TRUE if the specified channel is available on the dump.                
                                                                                                              
  PROCEDURE [XDCL] dup$$channel_available                                                                     
    (    parameter_list: clt$parameter_list;                                                                  
     VAR work_area_p: ^clt$work_area;                                                                         
     VAR result_p: ^clt$data_value;                                                                           
     VAR status: ost$status);                                                                                 
                                                                                                              
{ FUNCTION $channel_available, $ca (                                                                          
{   channel_number: integer 0..33 = $required                                                                 
{   )                                                                                                         
                                                                                                              
?? PUSH (LISTEXT := ON) ??                                                                                    
?? FMT (FORMAT := OFF) ??                                                                                     
  VAR                                                                                                         
    pdt: [STATIC, READ, cls$declaration_section] record                                                       
      header: clt$pdt_header,                                                                                 
      names: array [1 .. 1] of clt$pdt_parameter_name,                                                        
      parameters: array [1 .. 1] of clt$pdt_parameter,                                                        
      type1: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
      recend,                                                                                                 
    recend := [                                                                                               
    [1,                                                                                                       
    [89, 6, 8, 14, 42, 32, 773],                                                                              
    clc$function, 1, 1, 1, 0, 0, 0, 0, ''], [                                                                 
    ['CHANNEL_NUMBER                 ',clc$nominal_entry, 1]],                                                
    [                                                                                                         
{ PARAMETER 1                                                                                                 
    [1, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$required_parameter, 
  0, 0]],                                                                                                     
{ PARAMETER 1                                                                                                 
    [[1, 0, clc$integer_type], [0, 33, 10]]];                                                                 
?? FMT (FORMAT := ON) ??                                                                                      
?? POP ??                                                                                                     
                                                                                                              
    CONST                                                                                                     
      p$channel_number = 1;                                                                                   
                                                                                                              
    VAR                                                                                                       
      pvt: array [1 .. 1] of clt$parameter_value;                                                             
                                                                                                              
    VAR                                                                                                       
      channel_exists: boolean,                                                                                
      channel_number: 0 .. duc$de_maximum_channels,                                                           
      entry_p: ^dut$de_buffer_controlware_entry;                                                              
                                                                                                              
    status.normal := TRUE;                                                                                    
    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);                                  
    IF NOT status.normal THEN                                                                                 
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    IF duv$dump_environment_p = NIL THEN                                                                      
      osp$set_status_abnormal (duc$dump_analyzer_id, due$no_restart_file, '', status);                        
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    channel_number := pvt [p$channel_number].value^.integer_value.value;                                      
    dup$retrieve_bc_entry (channel_number, entry_p);                                                          
    channel_exists := (entry_p <> NIL);                                                                       
                                                                                                              
    clp$make_boolean_value (channel_exists, clc$true_false_boolean, work_area_p, result_p);                   
                                                                                                              
  PROCEND dup$$channel_available;                                                                             
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'dup$$control_store', EJECT ??                                                                 
                                                                                                              
{ PURPOSE:                                                                                                    
{   This function returns the contents of the specified control store register as a string.                   
                                                                                                              
  PROCEDURE [XDCL] dup$$control_store                                                                         
    (    parameter_list: clt$parameter_list;                                                                  
     VAR work_area_p: ^clt$work_area;                                                                         
     VAR result_p: ^clt$data_value;                                                                           
     VAR status: ost$status);                                                                                 
                                                                                                              
{ FUNCTION $control_store, $cs (                                                                              
{   word: integer 0..32768 = $required                                                                        
{   processor: integer 0..3 = 0                                                                               
{   shadow: boolean = FALSE                                                                                   
{   )                                                                                                         
                                                                                                              
?? PUSH (LISTEXT := ON) ??                                                                                    
?? FMT (FORMAT := OFF) ??                                                                                     
  VAR                                                                                                         
    pdt: [STATIC, READ, cls$declaration_section] record                                                       
      header: clt$pdt_header,                                                                                 
      names: array [1 .. 3] of clt$pdt_parameter_name,                                                        
      parameters: array [1 .. 3] of clt$pdt_parameter,                                                        
      type1: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
      recend,                                                                                                 
      type2: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
        default_value: string (1),                                                                            
      recend,                                                                                                 
      type3: record                                                                                           
        header: clt$type_specification_header,                                                                
        default_value: string (5),                                                                            
      recend,                                                                                                 
    recend := [                                                                                               
    [1,                                                                                                       
    [90, 9, 19, 8, 11, 20, 639],                                                                              
    clc$function, 3, 3, 1, 0, 0, 0, 0, ''], [                                                                 
    ['PROCESSOR                      ',clc$nominal_entry, 2],                                                 
    ['SHADOW                         ',clc$nominal_entry, 3],                                                 
    ['WORD                           ',clc$nominal_entry, 1]],                                                
    [                                                                                                         
{ PARAMETER 1                                                                                                 
    [3, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$required_parameter, 
  0, 0],                                                                                                      
{ PARAMETER 2                                                                                                 
    [1, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20,                         
  clc$optional_default_parameter, 0, 1],                                                                      
{ PARAMETER 3                                                                                                 
    [2, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3,                          
  clc$optional_default_parameter, 0, 5]],                                                                     
{ PARAMETER 1                                                                                                 
    [[1, 0, clc$integer_type], [0, 32768, 10]],                                                               
{ PARAMETER 2                                                                                                 
    [[1, 0, clc$integer_type], [0, 3, 10],                                                                    
    '0'],                                                                                                     
{ PARAMETER 3                                                                                                 
    [[1, 0, clc$boolean_type],                                                                                
    'FALSE']];                                                                                                
?? FMT (FORMAT := ON) ??                                                                                      
?? POP ??                                                                                                     
                                                                                                              
    CONST                                                                                                     
      p$word = 1,                                                                                             
      p$processor = 2,                                                                                        
      p$shadow = 3;                                                                                           
                                                                                                              
    VAR                                                                                                       
      pvt: array [1 .. 3] of clt$parameter_value;                                                             
                                                                                                              
    VAR                                                                                                       
      cell_p: ^cell,                                                                                          
      control_store_entry: dut$de_control_store_entry,                                                        
      control_store_p: ^array [0 .. * ] of dut$de_control_store_word,                                         
      control_store_size: 0 .. duc$de_control_store_size,                                                     
      default_list: array [1 .. 1] of dut$default_change_list_entry,                                          
      desired_word: 0 .. duc$de_control_store_size,                                                           
      display_string: string (osc$max_string_size),                                                           
      lower: string (16),                                                                                     
      processor: 0 .. duc$de_maximum_processors,                                                              
      restart_file_seq_p: ^SEQ ( * ),                                                                         
      string_33: string (33),                                                                                 
      string_length: integer,                                                                                 
      upper: string (16);                                                                                     
                                                                                                              
    status.normal := TRUE;                                                                                    
                                                                                                              
    { Change the default value for the PROCESSOR parameter.                                                   
                                                                                                              
    default_list [1].default_name := duc$dp_processor;                                                        
    default_list [1].number := p$processor;                                                                   
    dup$evaluate_parameters (parameter_list, default_list, #SEQ (pdt), ^pvt, status);                         
    IF NOT status.normal THEN                                                                                 
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    IF duv$dump_environment_p = NIL THEN                                                                      
      osp$set_status_abnormal (duc$dump_analyzer_id, due$no_restart_file, '', status);                        
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    processor := pvt [p$processor].value^.integer_value.value;                                                
    IF pvt [p$shadow].value^.boolean_value.value THEN                                                         
      control_store_entry := duv$dump_environment_p^.control_store.shadow [processor];                        
    ELSE                                                                                                      
      control_store_entry := duv$dump_environment_p^.control_store.main [processor];                          
    IFEND;                                                                                                    
    IF NOT control_store_entry.available THEN                                                                 
      IF pvt [p$shadow].value^.boolean_value.value THEN                                                       
        osp$set_status_abnormal (duc$dump_analyzer_id, due$data_not_on_dump,                                  
              'The shadow control store for processor', status);                                              
      ELSE                                                                                                    
        osp$set_status_abnormal (duc$dump_analyzer_id, due$data_not_on_dump,                                  
              'The main control store for processor', status);                                                
      IFEND;                                                                                                  
      osp$append_status_integer (osc$status_parameter_delimiter, processor, 10, FALSE, status);               
      osp$append_status_parameter (osc$status_parameter_delimiter, 'is', status);                             
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    desired_word := pvt [p$word].value^.integer_value.value;                                                  
    control_store_size := control_store_entry.size - 1;                                                       
    IF desired_word > control_store_size THEN                                                                 
      STRINGREP (display_string, string_length, 'Control store address ', desired_word: #(16), '(16) is');    
      osp$set_status_abnormal (duc$dump_analyzer_id, due$data_not_on_dump, display_string (1, string_length), 
            status);                                                                                          
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    restart_file_seq_p := duv$execution_environment.data_file_p^.segment_pointer.sequence_pointer;            
    cell_p := #ADDRESS (#RING (restart_file_seq_p), #SEGMENT (restart_file_seq_p),                            
          control_store_entry.first_byte);                                                                    
    RESET restart_file_seq_p TO cell_p;                                                                       
    NEXT control_store_p: [0 .. control_store_size] IN restart_file_seq_p;                                    
    IF control_store_p = NIL THEN                                                                             
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                            
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    convert_integer_to_hex_string (control_store_p^ [desired_word].upper, 16, upper);                         
    convert_integer_to_hex_string (control_store_p^ [desired_word].lower, 16, lower);                         
                                                                                                              
    STRINGREP (string_33, string_length, upper, ' ', lower);                                                  
    clp$make_string_value (string_33 (1, string_length), work_area_p, result_p);                              
                                                                                                              
  PROCEND dup$$control_store;                                                                                 
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'dup$$control_store_byte', EJECT ??                                                            
                                                                                                              
{ PURPOSE:                                                                                                    
{   This function returns the value of a specified byte of a specified control store register as an integer.  
                                                                                                              
  PROCEDURE [XDCL] dup$$control_store_byte                                                                    
    (    parameter_list: clt$parameter_list;                                                                  
     VAR work_area_p: ^clt$work_area;                                                                         
     VAR result_p: ^clt$data_value;                                                                           
     VAR status: ost$status);                                                                                 
                                                                                                              
{ FUNCTION $control_store_byte, $csb (                                                                        
{   word: integer 0..32768 = $required                                                                        
{   byte: integer 0..15 = $required                                                                           
{   processor: integer 0..3 = 0                                                                               
{   shadow: boolean = FALSE                                                                                   
{   )                                                                                                         
                                                                                                              
?? PUSH (LISTEXT := ON) ??                                                                                    
?? FMT (FORMAT := OFF) ??                                                                                     
  VAR                                                                                                         
    pdt: [STATIC, READ, cls$declaration_section] record                                                       
      header: clt$pdt_header,                                                                                 
      names: array [1 .. 4] of clt$pdt_parameter_name,                                                        
      parameters: array [1 .. 4] of clt$pdt_parameter,                                                        
      type1: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
      recend,                                                                                                 
      type2: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
      recend,                                                                                                 
      type3: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
        default_value: string (1),                                                                            
      recend,                                                                                                 
      type4: record                                                                                           
        header: clt$type_specification_header,                                                                
        default_value: string (5),                                                                            
      recend,                                                                                                 
    recend := [                                                                                               
    [1,                                                                                                       
    [90, 9, 19, 8, 14, 53, 691],                                                                              
    clc$function, 4, 4, 2, 0, 0, 0, 0, ''], [                                                                 
    ['BYTE                           ',clc$nominal_entry, 2],                                                 
    ['PROCESSOR                      ',clc$nominal_entry, 3],                                                 
    ['SHADOW                         ',clc$nominal_entry, 4],                                                 
    ['WORD                           ',clc$nominal_entry, 1]],                                                
    [                                                                                                         
{ PARAMETER 1                                                                                                 
    [4, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$required_parameter, 
  0, 0],                                                                                                      
{ PARAMETER 2                                                                                                 
    [1, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$required_parameter, 
  0, 0],                                                                                                      
{ PARAMETER 3                                                                                                 
    [2, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20,                         
  clc$optional_default_parameter, 0, 1],                                                                      
{ PARAMETER 4                                                                                                 
    [3, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3,                          
  clc$optional_default_parameter, 0, 5]],                                                                     
{ PARAMETER 1                                                                                                 
    [[1, 0, clc$integer_type], [0, 32768, 10]],                                                               
{ PARAMETER 2                                                                                                 
    [[1, 0, clc$integer_type], [0, 15, 10]],                                                                  
{ PARAMETER 3                                                                                                 
    [[1, 0, clc$integer_type], [0, 3, 10],                                                                    
    '0'],                                                                                                     
{ PARAMETER 4                                                                                                 
    [[1, 0, clc$boolean_type],                                                                                
    'FALSE']];                                                                                                
?? FMT (FORMAT := ON) ??                                                                                      
?? POP ??                                                                                                     
                                                                                                              
    CONST                                                                                                     
      p$word = 1,                                                                                             
      p$byte = 2,                                                                                             
      p$processor = 3,                                                                                        
      p$shadow = 4;                                                                                           
                                                                                                              
    VAR                                                                                                       
      pvt: array [1 .. 4] of clt$parameter_value;                                                             
                                                                                                              
    TYPE                                                                                                      
      t$byte_or_word = record                                                                                 
        case boolean of                                                                                       
        = FALSE =                                                                                             
          word: dut$de_control_store_word,                                                                    
        = TRUE =                                                                                              
          byte: packed array [0 .. 15] of 0 .. 0ff(16),                                                       
        casend,                                                                                               
      recend;                                                                                                 
                                                                                                              
    VAR                                                                                                       
      byte_or_word: t$byte_or_word,                                                                           
      cell_p: ^cell,                                                                                          
      control_store_entry: dut$de_control_store_entry,                                                        
      control_store_p: ^array [0 .. * ] of dut$de_control_store_word,                                         
      control_store_size: 0 .. duc$de_control_store_size,                                                     
      default_list: array [1 .. 1] of dut$default_change_list_entry,                                          
      desired_word: 0 .. duc$de_control_store_size,                                                           
      display_string: string (osc$max_string_size),                                                           
      processor: 0 .. duc$de_maximum_processors,                                                              
      restart_file_seq_p: ^SEQ ( * ),                                                                         
      string_length: integer;                                                                                 
                                                                                                              
    status.normal := TRUE;                                                                                    
                                                                                                              
    { Change the default value for the PROCESSOR parameter.                                                   
                                                                                                              
    default_list [1].default_name := duc$dp_processor;                                                        
    default_list [1].number := p$processor;                                                                   
    dup$evaluate_parameters (parameter_list, default_list, #SEQ (pdt), ^pvt, status);                         
    IF NOT status.normal THEN                                                                                 
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    IF duv$dump_environment_p = NIL THEN                                                                      
      osp$set_status_abnormal (duc$dump_analyzer_id, due$no_restart_file, '', status);                        
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    processor := pvt [p$processor].value^.integer_value.value;                                                
    IF pvt [p$shadow].value^.boolean_value.value THEN                                                         
      control_store_entry := duv$dump_environment_p^.control_store.shadow [processor];                        
    ELSE                                                                                                      
      control_store_entry := duv$dump_environment_p^.control_store.main [processor];                          
    IFEND;                                                                                                    
    IF NOT control_store_entry.available THEN                                                                 
      IF pvt [p$shadow].value^.boolean_value.value THEN                                                       
        osp$set_status_abnormal (duc$dump_analyzer_id, due$data_not_on_dump,                                  
              'The shadow control store for processor', status);                                              
      ELSE                                                                                                    
        osp$set_status_abnormal (duc$dump_analyzer_id, due$data_not_on_dump,                                  
              'The main control store for processor', status);                                                
      IFEND;                                                                                                  
      osp$append_status_integer (osc$status_parameter_delimiter, processor, 10, FALSE, status);               
      osp$append_status_parameter (osc$status_parameter_delimiter, 'is', status);                             
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    desired_word := pvt [p$word].value^.integer_value.value;                                                  
    control_store_size := control_store_entry.size - 1;                                                       
    IF desired_word > control_store_size THEN                                                                 
      STRINGREP (display_string, string_length, 'Control store address ', desired_word: #(16), '(16) is');    
      osp$set_status_abnormal (duc$dump_analyzer_id, due$data_not_on_dump, display_string (1, string_length), 
            status);                                                                                          
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    restart_file_seq_p := duv$execution_environment.data_file_p^.segment_pointer.sequence_pointer;            
    cell_p := #ADDRESS (#RING (restart_file_seq_p), #SEGMENT (restart_file_seq_p),                            
          control_store_entry.first_byte);                                                                    
    RESET restart_file_seq_p TO cell_p;                                                                       
    NEXT control_store_p: [0 .. control_store_size] IN restart_file_seq_p;                                    
    IF control_store_p = NIL THEN                                                                             
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                            
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    byte_or_word.word := control_store_p^ [desired_word];                                                     
                                                                                                              
    clp$make_integer_value (byte_or_word.byte [pvt [p$byte].value^.integer_value.value], 16, TRUE,            
          work_area_p, result_p);                                                                             
                                                                                                              
  PROCEND dup$$control_store_byte;                                                                            
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'dup$$defaults', EJECT ??                                                                      
                                                                                                              
{ PURPOSE:                                                                                                    
{   This function returns the defaults (changable by change_default and change_processor_register)            
{   as an SCL record.                                                                                         
                                                                                                              
  PROCEDURE [XDCL] dup$$defaults                                                                              
    (    parameter_list: clt$parameter_list;                                                                  
     VAR work_area: ^clt$work_area;                                                                           
     VAR result: ^clt$data_value;                                                                             
     VAR status: ost$status);                                                                                 
                                                                                                              
{ FUNCTION $defaults, $d, $default (                                                                          
{   values: list of key                                                                                       
{       (all, a)                                                                                              
{       (address_mode, am)                                                                                    
{       (exchange, e)                                                                                         
{       (iou, i)                                                                                              
{       (pp_type, pt)                                                                                         
{       (processor, p)                                                                                        
{       (processor_registers, processor_register, pr)                                                         
{     advanced_key                                                                                            
{       (defaults_pushed, dp)                                                                                 
{       (defaults_push_count, dpc)                                                                            
{     keyend = all                                                                                            
{   )                                                                                                         
                                                                                                              
?? PUSH (LISTEXT := ON) ??                                                                                    
?? FMT (FORMAT := OFF) ??                                                                                     
                                                                                                              
  VAR                                                                                                         
    pdt: [STATIC, READ, cls$declaration_section] record                                                       
      header: clt$pdt_header,                                                                                 
      names: array [1 .. 1] of clt$pdt_parameter_name,                                                        
      parameters: array [1 .. 1] of clt$pdt_parameter,                                                        
      type1: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$list_type_qualifier_v2,                                                                
        element_type_spec: record                                                                             
          header: clt$type_specification_header,                                                              
          qualifier: clt$keyword_type_qualifier,                                                              
          keyword_specs: array [1 .. 19] of clt$keyword_specification,                                        
        recend,                                                                                               
        default_value: string (3),                                                                            
      recend,                                                                                                 
    recend := [                                                                                               
    [1,                                                                                                       
    [103, 5, 6, 13, 18, 36, 671],                                                                             
    clc$function, 1, 1, 0, 0, 0, 0, 0, ''], [                                                                 
    ['VALUES                         ',clc$nominal_entry, 1]],                                                
    [                                                                                                         
{ PARAMETER 1                                                                                                 
    [1, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 726,                        
  clc$optional_default_parameter, 0, 3]],                                                                     
{ PARAMETER 1                                                                                                 
    [[1, 0, clc$list_type], [710, 1, clc$max_list_size, 0, FALSE, FALSE],                                     
      [[1, 0, clc$keyword_type], [19], [                                                                      
      ['A                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],                 
      ['ADDRESS_MODE                   ', clc$nominal_entry, clc$normal_usage_entry, 2],                      
      ['ALL                            ', clc$nominal_entry, clc$normal_usage_entry, 1],                      
      ['AM                             ', clc$abbreviation_entry, clc$normal_usage_entry, 2],                 
      ['DEFAULTS_PUSHED                ', clc$nominal_entry, clc$advanced_usage_entry, 8],                    
      ['DEFAULTS_PUSH_COUNT            ', clc$nominal_entry, clc$advanced_usage_entry, 9],                    
      ['DP                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 8],               
      ['DPC                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 9],               
      ['E                              ', clc$abbreviation_entry, clc$normal_usage_entry, 3],                 
      ['EXCHANGE                       ', clc$nominal_entry, clc$normal_usage_entry, 3],                      
      ['I                              ', clc$abbreviation_entry, clc$normal_usage_entry, 4],                 
      ['IOU                            ', clc$nominal_entry, clc$normal_usage_entry, 4],                      
      ['P                              ', clc$abbreviation_entry, clc$normal_usage_entry, 6],                 
      ['PP_TYPE                        ', clc$nominal_entry, clc$normal_usage_entry, 5],                      
      ['PR                             ', clc$abbreviation_entry, clc$normal_usage_entry, 7],                 
      ['PROCESSOR                      ', clc$nominal_entry, clc$normal_usage_entry, 6],                      
      ['PROCESSOR_REGISTER             ', clc$alias_entry, clc$normal_usage_entry, 7],                        
      ['PROCESSOR_REGISTERS            ', clc$nominal_entry, clc$normal_usage_entry, 7],                      
      ['PT                             ', clc$abbreviation_entry, clc$normal_usage_entry, 5]]                 
      ]                                                                                                       
    ,                                                                                                         
    'all']];                                                                                                  
                                                                                                              
?? FMT (FORMAT := ON) ??                                                                                      
?? POP ??                                                                                                     
                                                                                                              
    CONST                                                                                                     
      p$values = 1;                                                                                           
                                                                                                              
    VAR                                                                                                       
      pvt: array [1 .. 1] of clt$parameter_value;                                                             
                                                                                                              
    TYPE                                                                                                      
      t$selected_default = (c$address_mode, c$exchange, c$iou, c$pp_type, c$processor, c$processor_registers, 
            c$defaults_pushed, c$defaults_push_count),                                                        
      t$selected_defaults = set of t$selected_default;                                                        
                                                                                                              
    TYPE                                                                                                      
      t$default_index_converter = array [dut$default_parameters] of t$selected_default;                       
                                                                                                              
    VAR                                                                                                       
      v$default_index_converter: [READ] array [dut$default_parameters] of t$selected_default := [             
{ DUC$DP_ADDRESS_MODE        } c$address_mode,                                                                
{ DUC$DP_EXCHANGE            } c$exchange,                                                                    
{ DUC$DP_IOU                 } c$iou,                                                                         
{ DUC$DP_PP_TYPE             } c$pp_type,                                                                     
{ DUC$DP_PROCESSOR           } c$processor];                                                                  
                                                                                                              
    VAR                                                                                                       
      v$default_parameter_names: [READ] array [t$selected_default] of string (19) := [                        
{ C$DP_ADDRESS_MODE          } 'ADDRESS_MODE',                                                                
{ C$DP_EXCHANGE              } 'EXCHANGE',                                                                    
{ C$DP_IOU                   } 'IOU',                                                                         
{ C$DP_PP_TYPE               } 'PP_TYPE',                                                                     
{ C$DP_PROCESSOR             } 'PROCESSOR',                                                                   
{ C$PROCESSOR_REGISTERS      } 'PROCESSOR_REGISTERS',                                                         
{ C$DEFAULTS_PUSHED          } 'DEFAULTS_PUSHED',                                                             
{ C$DEFAULTS_PUSH_COUNT      } 'DEFAULTS_PUSH_COUNT'];                                                        
                                                                                                              
    VAR                                                                                                       
      attribute_count: 0 .. clc$max_fields,                                                                   
      attribute_record_index: 0 .. clc$max_fields,                                                            
      attribute_record_p: ^clt$data_value,                                                                    
      default_parameter: dut$default_parameters,                                                              
      default_parameters_p: ^dut$default_parameter_lists,                                                     
      defaults_pushed_count: integer,                                                                         
      element_p: ^clt$data_value,                                                                             
      selected_default: t$selected_default,                                                                   
      selected_defaults: t$selected_defaults,                                                                 
      value_p: ^clt$data_value;                                                                               
                                                                                                              
?? NEWTITLE := '[inline] F$DEFAULT_INDEX', EJECT ??                                                           
                                                                                                              
    FUNCTION [INLINE] f$default_index                                                                         
      (    name: string ( * <= 31)): t$selected_default;                                                      
                                                                                                              
      VAR                                                                                                     
        index: t$selected_default;                                                                            
                                                                                                              
      FOR index := LOWERBOUND (v$default_parameter_names) TO UPPERBOUND (v$default_parameter_names) DO        
        IF name = v$default_parameter_names [index] THEN                                                      
          f$default_index := index;                                                                           
          RETURN; {----->                                                                                     
        IFEND;                                                                                                
      FOREND;                                                                                                 
                                                                                                              
{ we must always find it. Otherwise, we are completly off....                                                 
                                                                                                              
    FUNCEND f$default_index;                                                                                  
?? OLDTITLE ??                                                                                                
?? NEWTITLE := '[unsafe] F$MAKE_INTEGER_OR_KEYWORD_VALUE', EJECT ??                                           
                                                                                                              
    FUNCTION [UNSAFE] f$make_integer_or_keyword_value                                                         
      (    str: ost$name;                                                                                     
       VAR work_area: ^clt$work_area): ^clt$data_value;                                                       
                                                                                                              
      VAR                                                                                                     
        int: clt$integer,                                                                                     
        status: ost$status;                                                                                   
                                                                                                              
{ It can only be a keyword or an integer. So, if the first char is between 0 and 9                            
                                                                                                              
      IF (str (1) >= '0') AND (str (1) <= '9') THEN                                                           
        clp$convert_string_to_integer (str, int, status);                                                     
        IF status.normal THEN                                                                                 
          f$make_integer_or_keyword_value := clf#make_clt$integer_value                                       
                (int.value, int.radix, int.radix_specified, work_area);                                       
        ELSE                                                                                                  
          f$make_integer_or_keyword_value := clf#make_keyword_value ('illegal_value', work_area);             
        IFEND;                                                                                                
      ELSE                                                                                                    
        f$make_integer_or_keyword_value := clf#make_keyword_value (str, work_area);                           
      IFEND;                                                                                                  
                                                                                                              
    FUNCEND f$make_integer_or_keyword_value;                                                                  
?? OLDTITLE ??                                                                                                
?? EJECT ??                                                                                                   
                                                                                                              
    status.normal := TRUE;                                                                                    
    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);                                  
    IF NOT status.normal THEN                                                                                 
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
{Determine the selected attributes                                                                            
    selected_defaults := $t$selected_defaults [];                                                             
    value_p := pvt [p$values].value;                                                                          
    WHILE (value_p <> NIL) AND (value_p^.kind = clc$list) DO                                                  
      element_p := value_p^.element_value;                                                                    
      value_p := value_p^.link;                                                                               
      IF (element_p <> NIL) AND (element_p^.kind = clc$keyword) THEN                                          
        IF element_p^.keyword_value = 'ALL' THEN                                                              
          selected_defaults := -$t$selected_defaults [c$defaults_pushed, c$defaults_push_count];              
        ELSE                                                                                                  
          selected_defaults := selected_defaults + $t$selected_defaults                                       
                [f$default_index (element_p^.keyword_value)];                                                 
        IFEND;                                                                                                
      IFEND;                                                                                                  
    WHILEND;                                                                                                  
                                                                                                              
{Count the selected attributes to build the record fields                                                     
    attribute_count := 0;                                                                                     
    FOR selected_default := LOWERVALUE (selected_default) TO UPPERVALUE (selected_default) DO                 
      IF selected_default IN selected_defaults THEN                                                           
        attribute_count := attribute_count + 1;                                                               
      IFEND;                                                                                                  
    FOREND;                                                                                                   
                                                                                                              
{Build the SCL record header                                                                                  
    attribute_record_p := clf#make_record_header_value (attribute_count, work_area);                          
    attribute_record_index := 0;                                                                              
                                                                                                              
{Add the values (if selected) coming from the default parameters (or change_default)                          
    FOR default_parameter := LOWERBOUND (duv$default_parameters^.value)                                       
          TO UPPERBOUND (duv$default_parameters^.value) DO                                                    
      selected_default := v$default_index_converter [default_parameter];                                      
      IF selected_default IN selected_defaults THEN                                                           
        IF duv$default_parameters^.value [default_parameter].default_set THEN                                 
          #SPOIL (work_area);                                                                                 
          clp#add_record_field (v$default_parameter_names [selected_default],                                 
                f$make_integer_or_keyword_value (duv$default_parameters^.value [default_parameter].value,     
                work_area), attribute_record_index, attribute_record_p);                                      
        ELSE                                                                                                  
          #SPOIL (work_area);                                                                                 
          clp#add_record_field (v$default_parameter_names [selected_default],                                 
                clf#make_unspecified_value (work_area), attribute_record_index, attribute_record_p);          
        IFEND;                                                                                                
      IFEND;                                                                                                  
    FOREND;                                                                                                   
                                                                                                              
{Add the values (if selected) coming from the processor registers of the execution environment                
    IF c$processor_registers IN selected_defaults THEN                                                        
      #SPOIL (work_area);                                                                                     
      clp#add_record_field (v$default_parameter_names [c$processor_registers],                                
            f$make_proc_register_values (duv$execution_environment.processor_registers, FALSE                 
            {=exclude status summary} , work_area), attribute_record_index, attribute_record_p);              
    IFEND;                                                                                                    
                                                                                                              
    IF c$defaults_pushed IN selected_defaults THEN                                                            
      #SPOIL (work_area);                                                                                     
      clp#add_record_field (v$default_parameter_names [c$defaults_pushed],                                    
            clf#make_boolean_value (duv$default_parameters^.next_p <> NIL, work_area), attribute_record_index,
            attribute_record_p);                                                                              
    IFEND;                                                                                                    
                                                                                                              
    IF c$defaults_push_count IN selected_defaults THEN                                                        
      defaults_pushed_count := -1;                                                                            
      default_parameters_p := duv$default_parameters;                                                         
      WHILE default_parameters_p <> NIL DO                                                                    
        default_parameters_p := default_parameters_p^.next_p;                                                 
        defaults_pushed_count := defaults_pushed_count + 1;                                                   
      WHILEND;                                                                                                
                                                                                                              
      #SPOIL (work_area);                                                                                     
      clp#add_record_field (v$default_parameter_names [c$defaults_push_count],                                
            clf#make_integer_value (defaults_pushed_count, work_area), attribute_record_index,                
            attribute_record_p);                                                                              
    IFEND;                                                                                                    
                                                                                                              
    result := attribute_record_p;                                                                             
                                                                                                              
  PROCEND dup$$defaults;                                                                                      
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'dup$$dump_environment', EJECT ??                                                              
                                                                                                              
{ PURPOSE:                                                                                                    
{   This function returns the internal dump_environment structure as an SCL record.                           
                                                                                                              
  PROCEDURE [XDCL] dup$$dump_environment                                                                      
    (    parameter_list: clt$parameter_list;                                                                  
     VAR work_area: ^clt$work_area;                                                                           
     VAR result: ^clt$data_value;                                                                             
     VAR status: ost$status);                                                                                 
                                                                                                              
{ FUNCTION $dump_environment, $de (                                                                           
{   display_option: key                                                                                       
{       (full, all, f, a)                                                                                     
{       (brief, b)                                                                                            
{     keyend = brief                                                                                          
{   )                                                                                                         
                                                                                                              
?? PUSH (LISTEXT := ON) ??                                                                                    
?? FMT (FORMAT := OFF) ??                                                                                     
                                                                                                              
  VAR                                                                                                         
    pdt: [STATIC, READ, cls$declaration_section] record                                                       
      header: clt$pdt_header,                                                                                 
      names: array [1 .. 1] of clt$pdt_parameter_name,                                                        
      parameters: array [1 .. 1] of clt$pdt_parameter,                                                        
      type1: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$keyword_type_qualifier,                                                                
        keyword_specs: array [1 .. 6] of clt$keyword_specification,                                           
        default_value: string (5),                                                                            
      recend,                                                                                                 
    recend := [                                                                                               
    [1,                                                                                                       
    [102, 3, 20, 16, 50, 52, 802],                                                                            
    clc$function, 1, 1, 0, 0, 0, 0, 0, ''], [                                                                 
    ['DISPLAY_OPTION                 ',clc$nominal_entry, 1]],                                                
    [                                                                                                         
{ PARAMETER 1                                                                                                 
    [1, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 229,                        
  clc$optional_default_parameter, 0, 5]],                                                                     
{ PARAMETER 1                                                                                                 
    [[1, 0, clc$keyword_type], [6], [                                                                         
    ['A                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],                   
    ['ALL                            ', clc$alias_entry, clc$normal_usage_entry, 1],                          
    ['B                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],                   
    ['BRIEF                          ', clc$nominal_entry, clc$normal_usage_entry, 2],                        
    ['F                              ', clc$alias_entry, clc$normal_usage_entry, 1],                          
    ['FULL                           ', clc$nominal_entry, clc$normal_usage_entry, 1]]                        
    ,                                                                                                         
    'brief']];                                                                                                
                                                                                                              
?? FMT (FORMAT := ON) ??                                                                                      
?? POP ??                                                                                                     
                                                                                                              
    CONST                                                                                                     
      p$display_option = 1;                                                                                   
                                                                                                              
    VAR                                                                                                       
      pvt: array [1 .. 1] of clt$parameter_value;                                                             
                                                                                                              
    VAR                                                                                                       
      attribute_record_index: 0 .. clc$max_fields,                                                            
      attribute_record_p: ^clt$data_value,                                                                    
      i: integer,                                                                                             
      old_dump_identifier: boolean;                                                                           
                                                                                                              
?? NEWTITLE := '[unsafe] F$MAKE_CENTRAL_MEMORY', EJECT ??                                                     
                                                                                                              
    FUNCTION [UNSAFE] f$make_central_memory                                                                   
      (    central_memory: dut$de_central_memory;                                                             
       VAR work_area: ^clt$work_area): ^clt$data_value;                                                       
                                                                                                              
      VAR                                                                                                     
        attribute_record_index: 0 .. clc$max_fields,                                                          
        attribute_record_p: ^clt$data_value;                                                                  
                                                                                                              
      attribute_record_index := 0;                                                                            
      attribute_record_p := clf#make_record_header_value (4, work_area);                                      
      clp#add_record_field ('AVAILABLE', clf#make_boolean_value (central_memory.available, work_area),        
            attribute_record_index, attribute_record_p);                                                      
                                                                                                              
      clp#add_record_field ('FIRST_BYTE', clf#make_integer_value (central_memory.first_byte, work_area),      
            attribute_record_index, attribute_record_p);                                                      
                                                                                                              
      clp#add_record_field ('LAST_BYTE', clf#make_integer_value (central_memory.last_byte, work_area),        
            attribute_record_index, attribute_record_p);                                                      
                                                                                                              
      clp#add_record_field ('BIAS', clf#make_integer_value (central_memory.bias, work_area),                  
            attribute_record_index, attribute_record_p);                                                      
                                                                                                              
      f$make_central_memory := attribute_record_p;                                                            
                                                                                                              
    FUNCEND f$make_central_memory;                                                                            
?? OLDTITLE ??                                                                                                
?? NEWTITLE := '[unsafe] F$MAKE_CRITICAL_MEMORY', EJECT ??                                                    
                                                                                                              
    FUNCTION [UNSAFE] f$make_critical_memory                                                                  
      (    critical_memory: dut$de_critical_memory;                                                           
       VAR work_area: ^clt$work_area): ^clt$data_value;                                                       
                                                                                                              
      VAR                                                                                                     
        attribute_record_index: 0 .. clc$max_fields,                                                          
        attribute_record_p: ^clt$data_value;                                                                  
                                                                                                              
      attribute_record_index := 0;                                                                            
      attribute_record_p := clf#make_record_header_value (16, work_area);                                     
      clp#add_record_field ('AVAILABLE', clf#make_boolean_value (critical_memory.available, work_area),       
            attribute_record_index, attribute_record_p);                                                      
                                                                                                              
      clp#add_record_field ('PAGE_SIZE', clf#make_integer_value (critical_memory.page_size, work_area),       
            attribute_record_index, attribute_record_p);                                                      
                                                                                                              
      clp#add_record_field ('PAGE_TABLE_SIZE', clf#make_integer_value                                         
            (critical_memory.page_table_size, work_area), attribute_record_index, attribute_record_p);        
                                                                                                              
      clp#add_record_field ('CPT_START', clf#make_integer_value (critical_memory.cpt_start, work_area),       
            attribute_record_index, attribute_record_p);                                                      
                                                                                                              
      clp#add_record_field ('CPT_END', clf#make_integer_value (critical_memory.cpt_end, work_area),           
            attribute_record_index, attribute_record_p);                                                      
                                                                                                              
      clp#add_record_field ('CRITICAL_PAGE_TABLE_OFFSET', clf#make_integer_value                              
            (critical_memory.critical_page_table_offset, work_area), attribute_record_index,                  
            attribute_record_p);                                                                              
                                                                                                              
      clp#add_record_field ('FIRST_ENTRY', clf#make_integer_value (critical_memory.first_entry, work_area),   
            attribute_record_index, attribute_record_p);                                                      
                                                                                                              
      clp#add_record_field ('LAST_ENTRY', clf#make_integer_value (critical_memory.last_entry, work_area),     
            attribute_record_index, attribute_record_p);                                                      
                                                                                                              
      clp#add_record_field ('CURRENT_ENTRY', clf#make_integer_value                                           
            (critical_memory.current_entry, work_area), attribute_record_index, attribute_record_p);          
                                                                                                              
      clp#add_record_field ('FIRST_PAGE', clf#make_integer_value (critical_memory.first_page, work_area),     
            attribute_record_index, attribute_record_p);                                                      
                                                                                                              
      clp#add_record_field ('CURRENT_PAGE_OFFSET', clf#make_integer_value                                     
            (critical_memory.current_page_offset, work_area), attribute_record_index, attribute_record_p);    
                                                                                                              
      clp#add_record_field ('FIRST_RMA_AVAILABLE', clf#make_integer_value                                     
            (critical_memory.first_rma_available, work_area), attribute_record_index, attribute_record_p);    
                                                                                                              
      clp#add_record_field ('LAST_RMA_AVAILABLE', clf#make_integer_value                                      
            (critical_memory.last_rma_available, work_area), attribute_record_index, attribute_record_p);     
                                                                                                              
      clp#add_record_field ('LAST_CCM_OTHER_RECORD', clf#make_integer_value                                   
            (critical_memory.last_ccm_other_record, work_area), attribute_record_index, attribute_record_p);  
                                                                                                              
      clp#add_record_field ('TOTAL_CCM_SIZE', clf#make_integer_value                                          
            (critical_memory.total_ccm_size, work_area), attribute_record_index, attribute_record_p);         
                                                                                                              
      clp#add_record_field ('MULTIPLE_CCM_EXISTS', clf#make_boolean_value                                     
            (critical_memory.multiple_ccm_exists, work_area), attribute_record_index, attribute_record_p);    
                                                                                                              
      f$make_critical_memory := attribute_record_p;                                                           
                                                                                                              
    FUNCEND f$make_critical_memory;                                                                           
?? OLDTITLE ??                                                                                                
?? NEWTITLE := '[unsafe] F$MAKE_EXCHANGE_PACKAGES', EJECT ??                                                  
                                                                                                              
    FUNCTION [UNSAFE] f$make_exchange_packages                                                                
      (    active_exchange: dut$de_exchange_packages;                                                         
           display_option_full: boolean;                                                                      
       VAR work_area: ^clt$work_area): ^clt$data_value;                                                       
                                                                                                              
      VAR                                                                                                     
        processor: integer,                                                                                   
        value_p: ^clt$data_value,                                                                             
        value_pp: ^^clt$data_value;                                                                           
                                                                                                              
?? NEWTITLE := '[unsafe] F$MAKE_EXCHANGE_DATA', EJECT ??                                                      
                                                                                                              
      FUNCTION [UNSAFE] f$make_exchange_data                                                                  
        (    exchange: dut$de_exchange_data;                                                                  
             display_option_full: boolean;                                                                    
         VAR work_area: ^clt$work_area): ^clt$data_value;                                                     
                                                                                                              
        VAR                                                                                                   
          attribute_record_index: 0 .. clc$max_fields,                                                        
          attribute_record_p: ^clt$data_value,                                                                
          result_p: ^clt$data_value;                                                                          
                                                                                                              
        IF display_option_full THEN                                                                           
          attribute_record_index := 0;                                                                        
          IF exchange.available THEN                                                                          
            attribute_record_p := clf#make_record_header_value (3, work_area);                                
          ELSE                                                                                                
            attribute_record_p := clf#make_record_header_value (1, work_area);                                
          IFEND;                                                                                              
                                                                                                              
          clp#add_record_field ('AVAILABLE', clf#make_boolean_value (exchange.available, work_area),          
                attribute_record_index, attribute_record_p);                                                  
                                                                                                              
          IF exchange.available THEN                                                                          
            p$make_exchange_package (exchange.value, display_option_full, result_p, work_area);               
            clp#add_record_field ('VALUE', result_p, attribute_record_index, attribute_record_p);             
                                                                                                              
            clp#add_record_field ('RADIAL_MCI', clf#make_integer_value (exchange.radial_mci, work_area),      
                  attribute_record_index, attribute_record_p);                                                
          IFEND;                                                                                              
        ELSE                                                                                                  
          p$make_exchange_package (exchange.value, display_option_full, attribute_record_p, work_area);       
        IFEND;                                                                                                
                                                                                                              
        f$make_exchange_data := attribute_record_p;                                                           
                                                                                                              
      FUNCEND f$make_exchange_data;                                                                           
?? OLDTITLE ??                                                                                                
?? EJECT ??                                                                                                   
      value_pp := ^value_p;                                                                                   
                                                                                                              
      FOR processor := LOWERBOUND (active_exchange) TO UPPERBOUND (active_exchange) DO                        
        value_pp^ := clf#make_list_value (f$make_exchange_data                                                
              (active_exchange [processor], display_option_full, work_area), work_area);                      
        value_pp := ^value_pp^^.link;                                                                         
      FOREND;                                                                                                 
                                                                                                              
      IF value_pp = ^value_p THEN                                                                             
        f$make_exchange_packages := clf#make_list_value (NIL, work_area);                                     
      ELSE                                                                                                    
        f$make_exchange_packages := value_p;                                                                  
      IFEND;                                                                                                  
                                                                                                              
    FUNCEND f$make_exchange_packages;                                                                         
?? OLDTITLE ??                                                                                                
?? NEWTITLE := '[unsafe] F$MAKE_DUMP_IDENTIFIER', EJECT ??                                                    
                                                                                                              
    FUNCTION [UNSAFE] f$make_dump_identifier                                                                  
      (    dump_identifier: dut$de_dump_identifier;                                                           
       VAR work_area: ^clt$work_area): ^clt$data_value;                                                       
                                                                                                              
      VAR                                                                                                     
        attribute_record_index: 0 .. clc$max_fields,                                                          
        attribute_record_p: ^clt$data_value;                                                                  
                                                                                                              
      attribute_record_index := 0;                                                                            
      attribute_record_p := clf#make_record_header_value (4, work_area);                                      
      clp#add_record_field ('AVAILABLE', clf#make_boolean_value (dump_identifier.available, work_area),       
            attribute_record_index, attribute_record_p);                                                      
                                                                                                              
      clp#add_record_field ('EDD_REVISION_LEVEL', clf#make_string_value                                       
            (dump_identifier.edd_revision_level, work_area), attribute_record_index, attribute_record_p);     
                                                                                                              
      clp#add_record_field ('SIZE', clf#make_integer_value (dump_identifier.size, work_area),                 
            attribute_record_index, attribute_record_p);                                                      
                                                                                                              
      clp#add_record_field ('FIRST_BYTE', clf#make_integer_value (dump_identifier.first_byte, work_area),     
            attribute_record_index, attribute_record_p);                                                      
                                                                                                              
      f$make_dump_identifier := attribute_record_p;                                                           
                                                                                                              
    FUNCEND f$make_dump_identifier;                                                                           
?? OLDTITLE ??                                                                                                
?? EJECT ??                                                                                                   
    status.normal := TRUE;                                                                                    
    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);                                  
    IF NOT status.normal THEN                                                                                 
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    IF duv$dump_environment_p = NIL THEN                                                                      
      result := clf#make_unspecified_value (work_area);                                                       
      RETURN; {----->                                                                                         
    IFEND;                                                                                                    
                                                                                                              
{Build the SCL record header                                                                                  
    old_dump_identifier := duv$dump_environment_p^.revision_level = duc$revision_level_old;                   
    attribute_record_index := 0;                                                                              
    #SPOIL (work_area);                                                                                       
    IF old_dump_identifier THEN                                                                               
      attribute_record_p := clf#make_record_header_value (15, work_area);                                     
      clp#add_record_field ('REVISION_LEVEL', clf#make_integer_value                                          
            (duv$dump_environment_p^.revision_level, work_area), attribute_record_index, attribute_record_p); 
    ELSE                                                                                                      
      attribute_record_p := clf#make_record_header_value (16, work_area);                                     
      clp#add_record_field ('REVISION_LEVEL', clf#make_integer_value                                          
            (duv$dump_environment_p^.revision_level DIV 100(16), work_area), attribute_record_index,          
            attribute_record_p);                                                                              
    IFEND;                                                                                                    
                                                                                                              
    clp#add_record_field ('DUMP_IDENITIFIER', f$make_dump_identifier                                          
          (duv$dump_environment_p^.dump_identifier, work_area), attribute_record_index, attribute_record_p);  
                                                                                                              
    clp#add_record_field ('CENTRAL_MEMORY', f$make_central_memory                                             
          (duv$dump_environment_p^.central_memory, work_area), attribute_record_index, attribute_record_p);   
                                                                                                              
    clp#add_record_field ('CRITICAL_MEMORY', f$make_critical_memory                                           
          (duv$dump_environment_p^.critical_memory, work_area), attribute_record_index, attribute_record_p);  
                                                                                                              
    clp#add_record_field ('ACTIVE_EXCHANGE', f$make_exchange_packages                                         
          (duv$dump_environment_p^.active_exchange, pvt [p$display_option].value^.keyword_value = 'FULL',     
          work_area), attribute_record_index, attribute_record_p);                                            
                                                                                                              
    clp#add_record_field ('JPS_EXCHANGE', f$make_exchange_packages                                            
          (duv$dump_environment_p^.jps_exchange, pvt [p$display_option].value^.keyword_value = 'FULL',        
          work_area), attribute_record_index, attribute_record_p);                                            
                                                                                                              
    clp#add_record_field ('MPS_EXCHANGE', f$make_exchange_packages                                            
          (duv$dump_environment_p^.mps_exchange, pvt [p$display_option].value^.keyword_value = 'FULL',        
          work_area), attribute_record_index, attribute_record_p);                                            
                                                                                                              
    FOR i := 8 TO 15 DO                                                                                       
      clp#add_record_field ('DUMMY', clf#make_unspecified_value (work_area), attribute_record_index,          
            attribute_record_p);                                                                              
    FOREND;                                                                                                   
    IF NOT old_dump_identifier THEN                                                                           
      clp#add_record_field ('DUMMY', clf#make_unspecified_value (work_area), attribute_record_index,          
            attribute_record_p);                                                                              
    IFEND;                                                                                                    
                                                                                                              
    result := attribute_record_p;                                                                             
                                                                                                              
  PROCEND dup$$dump_environment;                                                                              
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'dup$$dump_information', EJECT ??                                                              
                                                                                                              
{ PURPOSE:                                                                                                    
{   This function returns the internal dump_information structure as an SCL record.                           
                                                                                                              
  PROCEDURE [XDCL] dup$$dump_information                                                                      
    (    parameter_list: clt$parameter_list;                                                                  
     VAR work_area: ^clt$work_area;                                                                           
     VAR result: ^clt$data_value;                                                                             
     VAR status: ost$status);                                                                                 
                                                                                                              
{ FUNCTION $dump_information, $di                                                                             
                                                                                                              
?? PUSH (LISTEXT := ON) ??                                                                                    
?? FMT (FORMAT := OFF) ??                                                                                     
                                                                                                              
  VAR                                                                                                         
    pdt: [STATIC, READ, cls$declaration_section] record                                                       
      header: clt$pdt_header,                                                                                 
    recend := [                                                                                               
    [1,                                                                                                       
    [101, 7, 6, 10, 32, 2, 602],                                                                              
    clc$function, 0, 0, 0, 0, 0, 0, 0, '']];                                                                  
                                                                                                              
?? FMT (FORMAT := ON) ??                                                                                      
?? POP ??                                                                                                     
                                                                                                              
    VAR                                                                                                       
      v$dump_type_names: [READ] array [dut$di_dump_type] of string (10) := [                                  
{ DUC$DI_DT_UNKNOWN          } 'UNKNOWN   ',                                                                  
{ DUC$DI_DT_EDD              } 'EDD       ',                                                                  
{ DUC$DI_DT_DUAL_STATE       } 'DUAL_STATE',                                                                  
{ DUC$DI_DT_ES0,             } 'ES0,      ',                                                                  
{ DUC$DI_DT_CY2000           } 'CY2000    '];                                                                 
                                                                                                              
    VAR                                                                                                       
      attribute_record_index: 0 .. clc$max_fields,                                                            
      attribute_record_p: ^clt$data_value,                                                                    
      dump_information: dut$dump_information;                                                                 
                                                                                                              
?? NEWTITLE := '[unsafe] F$MAKE_IOU_VALUE', EJECT ??                                                          
                                                                                                              
    FUNCTION [UNSAFE] f$make_iou_value                                                                        
      (    iou: dut$di_iou_data;                                                                              
       VAR work_area: ^clt$work_area): ^clt$data_value;                                                       
                                                                                                              
      VAR                                                                                                     
        v$iou_class_names: [READ] array [dut$di_iou_class] of string (7) := [                                 
{ DUC$DI_IC_UNKNOWN          } 'UNKNOWN',                                                                     
{ DUC$DI_IC_IOU_4K           } 'IOU_4K ',                                                                     
{ DUC$DI_IC_IOU_8K           } 'IOU_8K ',                                                                     
{ DUC$DI_IC_IOU_16K          } 'IOU_16K'];                                                                    
                                                                                                              
      VAR                                                                                                     
        v$iou_model_names: [READ] array [dut$di_iou_model] of string (7) := [                                 
{ DUC$DI_IM_UNKNOWN          } 'UNKNOWN',                                                                     
{ DUC$DI_IM_I1_1X            } 'I1_1X  ',                                                                     
{ DUC$DI_IM_I2_20            } 'I2_20  ',                                                                     
{ DUC$DI_IM_I4_40            } 'I4_40  ',                                                                     
{ DUC$DI_IM_I4_42            } 'I4_42  ',                                                                     
{ DUC$DI_IM_I4_43            } 'I4_43  ',                                                                     
{ DUC$DI_IM_I4_44            } 'I4_44  ',                                                                     
{ DUC$DI_IM_I4_46            } 'I4_46  ',                                                                     
{ DUC$DI_IM_I0_5X            } 'I0_5X  '];                                                                    
                                                                                                              
      VAR                                                                                                     
        attribute_record_index: 0 .. clc$max_fields,                                                          
        attribute_record_p: ^clt$data_value;                                                                  
                                                                                                              
      attribute_record_index := 0;                                                                            
      attribute_record_p := clf#make_record_header_value (3, work_area);                                      
                                                                                                              
      #SPOIL (work_area);                                                                                     
      clp#add_record_field ('CLASS', clf#make_keyword_value (v$iou_class_names [iou.class], work_area),       
            attribute_record_index, attribute_record_p);                                                      
                                                                                                              
      #SPOIL (work_area);                                                                                     
      clp#add_record_field ('PP_WORD_SIZE', clf#make_clt$integer_value (iou.pp_word_size, 10 {radix} , FALSE  
            {=exclude radix} , work_area), attribute_record_index, attribute_record_p);                       
                                                                                                              
      #SPOIL (work_area);                                                                                     
      clp#add_record_field ('MODEL', clf#make_keyword_value (v$iou_model_names [iou.model], work_area),       
            attribute_record_index, attribute_record_p);                                                      
                                                                                                              
      f$make_iou_value := attribute_record_p;                                                                 
                                                                                                              
    FUNCEND f$make_iou_value;                                                                                 
?? OLDTITLE ??                                                                                                
?? NEWTITLE := '[unsafe] F$MAKE_IOUS_VALUE', EJECT ??                                                         
                                                                                                              
    FUNCTION [UNSAFE] f$make_ious_value                                                                       
      (    ious: array [0 .. duc$de_maximum_ious] of dut$di_iou_data;                                         
       VAR work_area: ^clt$work_area): ^clt$data_value;                                                       
                                                                                                              
      VAR                                                                                                     
        iou: 0 .. duc$de_maximum_ious,                                                                        
        value_p: ^clt$data_value,                                                                             
        value_pp: ^^clt$data_value;                                                                           
                                                                                                              
      value_pp := ^value_p;                                                                                   
                                                                                                              
      FOR iou := 0 TO duc$de_maximum_ious DO                                                                  
        value_pp^ := clf#make_list_value (f$make_iou_value (ious [iou], work_area), work_area);               
        value_pp := ^value_pp^^.link;                                                                         
      FOREND;                                                                                                 
                                                                                                              
      IF value_pp = ^value_p THEN                                                                             
        f$make_ious_value := clf#make_list_value (NIL, work_area);                                            
      ELSE                                                                                                    
        f$make_ious_value := value_p;                                                                         
      IFEND;                                                                                                  
                                                                                                              
    FUNCEND f$make_ious_value;                                                                                
?? OLDTITLE ??                                                                                                
?? NEWTITLE := '[unsafe] F$MAKE_TAPE_TYPE_VALUE', EJECT ??                                                    
                                                                                                              
    FUNCTION [UNSAFE] f$make_tape_type_value                                                                  
      (    tape_type: dut$di_tape_type;                                                                       
       VAR work_area: ^clt$work_area): ^clt$data_value;                                                       
                                                                                                              
{ just output the octal number, as long as I don't know what they mean.                                       
                                                                                                              
      CASE tape_type OF                                                                                       
      = duc$di_tt_1 =                                                                                         
        f$make_tape_type_value := clf#make_clt$integer_value (1(8), 8 {radix} , TRUE {include radix} ,        
              work_area);                                                                                     
      = duc$di_tt_2 =                                                                                         
        f$make_tape_type_value := clf#make_clt$integer_value (2(8), 8 {radix} , TRUE {include radix} ,        
              work_area);                                                                                     
      = duc$di_tt_3 =                                                                                         
        f$make_tape_type_value := clf#make_clt$integer_value (3(8), 8 {radix} , TRUE {include radix} ,        
              work_area);                                                                                     
      = duc$di_tt_4 =                                                                                         
        f$make_tape_type_value := clf#make_clt$integer_value (4(8), 8 {radix} , TRUE {include radix} ,        
              work_area);                                                                                     
      = duc$di_tt_40 =                                                                                        
        f$make_tape_type_value := clf#make_clt$integer_value (40(8), 8 {radix} , TRUE {include radix} ,       
              work_area);                                                                                     
      = duc$di_tt_41 =                                                                                        
        f$make_tape_type_value := clf#make_clt$integer_value (41(8), 8 {radix} , TRUE {include radix} ,       
              work_area);                                                                                     
      ELSE                                                                                                    
        f$make_tape_type_value := clf#make_keyword_value ('unknown', work_area);                              
      CASEND;                                                                                                 
                                                                                                              
    FUNCEND f$make_tape_type_value;                                                                           
?? OLDTITLE ??                                                                                                
?? EJECT ??                                                                                                   
    status.normal := TRUE;                                                                                    
    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, NIL, status);                                   
    IF NOT status.normal THEN                                                                                 
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    dup$determine_dump_information (dump_information);                                                        
                                                                                                              
{Build the SCL record header                                                                                  
    attribute_record_p := clf#make_record_header_value (3, work_area);                                        
    attribute_record_index := 0;                                                                              
                                                                                                              
    #SPOIL (work_area);                                                                                       
    clp#add_record_field ('DUMP_TYPE', clf#make_keyword_value                                                 
          (v$dump_type_names [dump_information.dump_type], work_area), attribute_record_index,                
          attribute_record_p);                                                                                
                                                                                                              
    #SPOIL (work_area);                                                                                       
    clp#add_record_field ('TAPE_TYPE', f$make_tape_type_value (dump_information.tape_type, work_area),        
          attribute_record_index, attribute_record_p);                                                        
                                                                                                              
    #SPOIL (work_area);                                                                                       
    clp#add_record_field ('IOU', f$make_ious_value (dump_information.iou, work_area), attribute_record_index, 
          attribute_record_p);                                                                                
                                                                                                              
    result := attribute_record_p;                                                                             
                                                                                                              
  PROCEND dup$$dump_information;                                                                              
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'dup$$dump_record', EJECT ??                                                                   
                                                                                                              
{ PURPOSE:                                                                                                    
{   This function returns the dump record bytes specified as an integer.                                      
                                                                                                              
  PROCEDURE [XDCL] dup$$dump_record                                                                           
    (    parameter_list: clt$parameter_list;                                                                  
     VAR work_area_p: ^clt$work_area;                                                                         
     VAR result_p: ^clt$data_value;                                                                           
     VAR status: ost$status);                                                                                 
                                                                                                              
{ FUNCTION $dump_record, $dr (                                                                                
{   record_name: any of                                                                                       
{       string 1..3                                                                                           
{       name                                                                                                  
{       integer                                                                                               
{     anyend = $required                                                                                      
{   offset: integer 0..500000 = $required                                                                     
{   byte: integer 1..8 = 8                                                                                    
{   )                                                                                                         
                                                                                                              
?? PUSH (LISTEXT := ON) ??                                                                                    
?? FMT (FORMAT := OFF) ??                                                                                     
  VAR                                                                                                         
    pdt: [STATIC, READ, cls$declaration_section] record                                                       
      header: clt$pdt_header,                                                                                 
      names: array [1 .. 3] of clt$pdt_parameter_name,                                                        
      parameters: array [1 .. 3] of clt$pdt_parameter,                                                        
      type1: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$union_type_qualifier,                                                                  
        type_size_1: clt$type_specification_size,                                                             
        element_type_spec_1: record                                                                           
          header: clt$type_specification_header,                                                              
          qualifier: clt$string_type_qualifier,                                                               
        recend,                                                                                               
        type_size_2: clt$type_specification_size,                                                             
        element_type_spec_2: record                                                                           
          header: clt$type_specification_header,                                                              
          qualifier: clt$name_type_qualifier,                                                                 
        recend,                                                                                               
        type_size_3: clt$type_specification_size,                                                             
        element_type_spec_3: record                                                                           
          header: clt$type_specification_header,                                                              
          qualifier: clt$integer_type_qualifier,                                                              
        recend,                                                                                               
      recend,                                                                                                 
      type2: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
      recend,                                                                                                 
      type3: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
        default_value: string (1),                                                                            
      recend,                                                                                                 
    recend := [                                                                                               
    [1,                                                                                                       
    [89, 8, 16, 14, 44, 53, 350],                                                                             
    clc$function, 3, 3, 2, 0, 0, 0, 0, ''], [                                                                 
    ['BYTE                           ',clc$nominal_entry, 3],                                                 
    ['OFFSET                         ',clc$nominal_entry, 2],                                                 
    ['RECORD_NAME                    ',clc$nominal_entry, 1]],                                                
    [                                                                                                         
{ PARAMETER 1                                                                                                 
    [3, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 57, clc$required_parameter, 
  0, 0],                                                                                                      
{ PARAMETER 2                                                                                                 
    [2, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$required_parameter, 
  0, 0],                                                                                                      
{ PARAMETER 3                                                                                                 
    [1, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20,                         
  clc$optional_default_parameter, 0, 1]],                                                                     
{ PARAMETER 1                                                                                                 
    [[1, 0, clc$union_type], [[clc$integer_type, clc$name_type, clc$string_type],                             
    FALSE, 3],                                                                                                
    8, [[1, 0, clc$string_type], [1, 3, FALSE]],                                                              
    5, [[1, 0, clc$name_type], [1, osc$max_name_size]],                                                       
    20, [[1, 0, clc$integer_type], [clc$min_integer, clc$max_integer, 10]]                                    
    ],                                                                                                        
{ PARAMETER 2                                                                                                 
    [[1, 0, clc$integer_type], [0, 500000, 10]],                                                              
{ PARAMETER 3                                                                                                 
    [[1, 0, clc$integer_type], [1, 8, 10],                                                                    
    '8']];                                                                                                    
?? FMT (FORMAT := ON) ??                                                                                      
?? POP ??                                                                                                     
                                                                                                              
    CONST                                                                                                     
      p$record_name = 1,                                                                                      
      p$offset = 2,                                                                                           
      p$byte = 3;                                                                                             
                                                                                                              
    VAR                                                                                                       
      pvt: array [1 .. 3] of clt$parameter_value;                                                             
                                                                                                              
    VAR                                                                                                       
      byte_length: 1 .. 8,                                                                                    
      cell_p: ^cell,                                                                                          
      data_array_p: ^array [ * ] of 0 .. 0ff(16),                                                             
      data_p: ^integer,                                                                                       
      data_seq_p: ^SEQ ( * ),                                                                                 
      display_string: string (osc$max_string_size),                                                           
      entry_p: ^dut$de_other_record_entry,                                                                    
      offset: 0 .. duc$de_max_other_record_length,                                                            
      restart_file_array_p: ^array [ * ] of 0 .. 0ff(16),                                                     
      restart_file_seq_p: ^SEQ ( * ),                                                                         
      skip_data_p: ^SEQ ( * ),                                                                                
      string_length: integer;                                                                                 
                                                                                                              
    status.normal := TRUE;                                                                                    
    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);                                  
    IF NOT status.normal THEN                                                                                 
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    IF duv$dump_environment_p = NIL THEN                                                                      
      osp$set_status_abnormal (duc$dump_analyzer_id, due$no_restart_file, '', status);                        
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    { Search for the desired record.                                                                          
                                                                                                              
    dup$find_record_list_entry (pvt [p$record_name].value^, entry_p);                                         
    IF entry_p = NIL THEN                                                                                     
      osp$set_status_abnormal (duc$dump_analyzer_id, due$data_not_on_dump, 'The specified record is', status);
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    IF entry_p^.record_type = duc$de_ort_report THEN                                                          
      osp$set_status_abnormal (duc$dump_analyzer_id, due$record_type_supported, 'DUMP', status);              
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    { Determine offset and size of area to dump.                                                              
                                                                                                              
    offset := pvt [p$offset].value^.integer_value.value;                                                      
    byte_length := pvt [p$byte].value^.integer_value.value;                                                   
    IF offset > entry_p^.size THEN                                                                            
      STRINGREP (display_string, string_length, 'Dump record offset ', offset: #(16), '(16) is');             
      osp$set_status_abnormal (duc$dump_analyzer_id, due$data_not_on_dump, display_string (1, string_length), 
            status);                                                                                          
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
    IF (offset + byte_length) > entry_p^.size THEN                                                            
      byte_length := entry_p^.size - offset;                                                                  
    IFEND;                                                                                                    
                                                                                                              
    { Retrieve a pointer to the dump record.                                                                  
                                                                                                              
    restart_file_seq_p := duv$execution_environment.data_file_p^.segment_pointer.sequence_pointer;            
    cell_p := #ADDRESS (#RING (restart_file_seq_p), #SEGMENT (restart_file_seq_p),                            
          entry_p^.first_byte + offset);                                                                      
    RESET restart_file_seq_p TO cell_p;                                                                       
                                                                                                              
    { Allocate an area to store the data.                                                                     
                                                                                                              
    PUSH data_seq_p: [[REP 1 OF integer]];                                                                    
    RESET data_seq_p;                                                                                         
    IF data_seq_p = NIL THEN                                                                                  
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                            
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    { Zero out the temporary area.                                                                            
                                                                                                              
    NEXT data_p IN data_seq_p;                                                                                
    IF data_p = NIL THEN                                                                                      
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                            
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
    data_p^ := 0;                                                                                             
    RESET data_seq_p;                                                                                         
    IF byte_length < 8 THEN                                                                                   
      NEXT skip_data_p: [[REP (8 - byte_length) OF cell]] IN data_seq_p;                                      
      IF skip_data_p = NIL THEN                                                                               
        osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                          
        RETURN; {---->                                                                                        
      IFEND;                                                                                                  
    IFEND;                                                                                                    
                                                                                                              
    { Copy the data from the restart file to temporary area.                                                  
                                                                                                              
    NEXT restart_file_array_p: [1 .. byte_length] 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;                                                                                                    
    NEXT data_array_p: [1 .. byte_length] IN data_seq_p;                                                      
    IF data_array_p = NIL THEN                                                                                
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                            
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
    data_array_p^ := restart_file_array_p^;                                                                   
                                                                                                              
    clp$make_integer_value (data_p^, 16, TRUE, work_area_p, result_p);                                        
                                                                                                              
  PROCEND dup$$dump_record;                                                                                   
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'dup$$dump_record_available', EJECT ??                                                         
                                                                                                              
{ PURPOSE:                                                                                                    
{   This function returns a boolean of TRUE if the specified dump record is on the restart file.              
                                                                                                              
  PROCEDURE [XDCL] dup$$dump_record_available                                                                 
    (    parameter_list: clt$parameter_list;                                                                  
     VAR work_area_p: ^clt$work_area;                                                                         
     VAR result_p: ^clt$data_value;                                                                           
     VAR status: ost$status);                                                                                 
                                                                                                              
{ FUNCTION $dump_record_available, $dump_record_avail, $dra (                                                 
{   record_name: any of                                                                                       
{       string 1..3                                                                                           
{       name                                                                                                  
{       integer                                                                                               
{     anyend = $required                                                                                      
{   )                                                                                                         
                                                                                                              
?? PUSH (LISTEXT := ON) ??                                                                                    
?? FMT (FORMAT := OFF) ??                                                                                     
  VAR                                                                                                         
    pdt: [STATIC, READ, cls$declaration_section] record                                                       
      header: clt$pdt_header,                                                                                 
      names: array [1 .. 1] of clt$pdt_parameter_name,                                                        
      parameters: array [1 .. 1] of clt$pdt_parameter,                                                        
      type1: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$union_type_qualifier,                                                                  
        type_size_1: clt$type_specification_size,                                                             
        element_type_spec_1: record                                                                           
          header: clt$type_specification_header,                                                              
          qualifier: clt$string_type_qualifier,                                                               
        recend,                                                                                               
        type_size_2: clt$type_specification_size,                                                             
        element_type_spec_2: record                                                                           
          header: clt$type_specification_header,                                                              
          qualifier: clt$name_type_qualifier,                                                                 
        recend,                                                                                               
        type_size_3: clt$type_specification_size,                                                             
        element_type_spec_3: record                                                                           
          header: clt$type_specification_header,                                                              
          qualifier: clt$integer_type_qualifier,                                                              
        recend,                                                                                               
      recend,                                                                                                 
    recend := [                                                                                               
    [1,                                                                                                       
    [89, 8, 16, 14, 47, 24, 389],                                                                             
    clc$function, 1, 1, 1, 0, 0, 0, 0, ''], [                                                                 
    ['RECORD_NAME                    ',clc$nominal_entry, 1]],                                                
    [                                                                                                         
{ PARAMETER 1                                                                                                 
    [1, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 57, clc$required_parameter, 
  0, 0]],                                                                                                     
{ PARAMETER 1                                                                                                 
    [[1, 0, clc$union_type], [[clc$integer_type, clc$name_type, clc$string_type],                             
    FALSE, 3],                                                                                                
    8, [[1, 0, clc$string_type], [1, 3, FALSE]],                                                              
    5, [[1, 0, clc$name_type], [1, osc$max_name_size]],                                                       
    20, [[1, 0, clc$integer_type], [clc$min_integer, clc$max_integer, 10]]                                    
    ]];                                                                                                       
?? FMT (FORMAT := ON) ??                                                                                      
?? POP ??                                                                                                     
                                                                                                              
    CONST                                                                                                     
      p$record_name = 1;                                                                                      
                                                                                                              
    VAR                                                                                                       
      pvt: array [1 .. 1] of clt$parameter_value;                                                             
                                                                                                              
    VAR                                                                                                       
      entry_p: ^dut$de_other_record_entry,                                                                    
      record_available: boolean;                                                                              
                                                                                                              
    status.normal := TRUE;                                                                                    
    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);                                  
    IF NOT status.normal THEN                                                                                 
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    IF duv$dump_environment_p = NIL THEN                                                                      
      osp$set_status_abnormal (duc$dump_analyzer_id, due$no_restart_file, '', status);                        
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    { Search for the desired record.                                                                          
                                                                                                              
    record_available := FALSE;                                                                                
    dup$find_record_list_entry (pvt [p$record_name].value^, entry_p);                                         
    IF (entry_p <> NIL) AND (entry_p^.record_type <> duc$de_ort_detail) THEN                                  
      record_available := (entry_p^.size <> 0);                                                               
    IFEND;                                                                                                    
                                                                                                              
    clp$make_boolean_value (record_available, clc$true_false_boolean, work_area_p, result_p);                 
                                                                                                              
  PROCEND dup$$dump_record_available;                                                                         
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'dup$$dump_record_length', EJECT ??                                                            
                                                                                                              
{ PURPOSE:                                                                                                    
{   This function returns the length of the specified dump record.                                            
                                                                                                              
  PROCEDURE [XDCL] dup$$dump_record_length                                                                    
    (    parameter_list: clt$parameter_list;                                                                  
     VAR work_area_p: ^clt$work_area;                                                                         
     VAR result_p: ^clt$data_value;                                                                           
     VAR status: ost$status);                                                                                 
                                                                                                              
{ FUNCTION $dump_record_length, $drl (                                                                        
{   record_name: any of                                                                                       
{       string 1..3                                                                                           
{       name                                                                                                  
{       integer                                                                                               
{     anyend = $required                                                                                      
{   )                                                                                                         
                                                                                                              
?? PUSH (LISTEXT := ON) ??                                                                                    
?? FMT (FORMAT := OFF) ??                                                                                     
  VAR                                                                                                         
    pdt: [STATIC, READ, cls$declaration_section] record                                                       
      header: clt$pdt_header,                                                                                 
      names: array [1 .. 1] of clt$pdt_parameter_name,                                                        
      parameters: array [1 .. 1] of clt$pdt_parameter,                                                        
      type1: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$union_type_qualifier,                                                                  
        type_size_1: clt$type_specification_size,                                                             
        element_type_spec_1: record                                                                           
          header: clt$type_specification_header,                                                              
          qualifier: clt$string_type_qualifier,                                                               
        recend,                                                                                               
        type_size_2: clt$type_specification_size,                                                             
        element_type_spec_2: record                                                                           
          header: clt$type_specification_header,                                                              
          qualifier: clt$name_type_qualifier,                                                                 
        recend,                                                                                               
        type_size_3: clt$type_specification_size,                                                             
        element_type_spec_3: record                                                                           
          header: clt$type_specification_header,                                                              
          qualifier: clt$integer_type_qualifier,                                                              
        recend,                                                                                               
      recend,                                                                                                 
    recend := [                                                                                               
    [1,                                                                                                       
    [89, 8, 16, 14, 48, 58, 820],                                                                             
    clc$function, 1, 1, 1, 0, 0, 0, 0, ''], [                                                                 
    ['RECORD_NAME                    ',clc$nominal_entry, 1]],                                                
    [                                                                                                         
{ PARAMETER 1                                                                                                 
    [1, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 57, clc$required_parameter, 
  0, 0]],                                                                                                     
{ PARAMETER 1                                                                                                 
    [[1, 0, clc$union_type], [[clc$integer_type, clc$name_type, clc$string_type],                             
    FALSE, 3],                                                                                                
    8, [[1, 0, clc$string_type], [1, 3, FALSE]],                                                              
    5, [[1, 0, clc$name_type], [1, osc$max_name_size]],                                                       
    20, [[1, 0, clc$integer_type], [clc$min_integer, clc$max_integer, 10]]                                    
    ]];                                                                                                       
?? FMT (FORMAT := ON) ??                                                                                      
?? POP ??                                                                                                     
                                                                                                              
    CONST                                                                                                     
      p$record_name = 1;                                                                                      
                                                                                                              
    VAR                                                                                                       
      pvt: array [1 .. 1] of clt$parameter_value;                                                             
                                                                                                              
    VAR                                                                                                       
      entry_p: ^dut$de_other_record_entry;                                                                    
                                                                                                              
    status.normal := TRUE;                                                                                    
    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);                                  
    IF NOT status.normal THEN                                                                                 
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    IF duv$dump_environment_p = NIL THEN                                                                      
      osp$set_status_abnormal (duc$dump_analyzer_id, due$no_restart_file, '', status);                        
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    { Search for the desired record.                                                                          
                                                                                                              
    dup$find_record_list_entry (pvt [p$record_name].value^, entry_p);                                         
    IF entry_p = NIL THEN                                                                                     
      osp$set_status_abnormal (duc$dump_analyzer_id, due$data_not_on_dump, 'The specified record is', status);
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
    IF entry_p^.record_type = duc$de_ort_detail THEN                                                          
      osp$set_status_abnormal (duc$dump_analyzer_id, due$record_type_supported, 'DUMP or REPORT', status);    
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    clp$make_integer_value (entry_p^.size, 10, TRUE, work_area_p, result_p);                                  
                                                                                                              
  PROCEND dup$$dump_record_length;                                                                            
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'dup$$dump_record_type', EJECT ??                                                              
                                                                                                              
{ PURPOSE:                                                                                                    
{   This function returns the type of the specified dump record as a name.                                    
                                                                                                              
  PROCEDURE [XDCL] dup$$dump_record_type                                                                      
    (    parameter_list: clt$parameter_list;                                                                  
     VAR work_area_p: ^clt$work_area;                                                                         
     VAR result_p: ^clt$data_value;                                                                           
     VAR status: ost$status);                                                                                 
                                                                                                              
{ FUNCTION $dump_record_type, $drt (                                                                          
{   record_name: any of                                                                                       
{       string 1..3                                                                                           
{       name                                                                                                  
{       integer                                                                                               
{     anyend = $required                                                                                      
{   )                                                                                                         
                                                                                                              
?? PUSH (LISTEXT := ON) ??                                                                                    
?? FMT (FORMAT := OFF) ??                                                                                     
 VAR                                                                                                          
    pdt: [STATIC, READ, cls$declaration_section] record                                                       
      header: clt$pdt_header,                                                                                 
      names: array [1 .. 1] of clt$pdt_parameter_name,                                                        
      parameters: array [1 .. 1] of clt$pdt_parameter,                                                        
      type1: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$union_type_qualifier,                                                                  
        type_size_1: clt$type_specification_size,                                                             
        element_type_spec_1: record                                                                           
          header: clt$type_specification_header,                                                              
          qualifier: clt$string_type_qualifier,                                                               
        recend,                                                                                               
        type_size_2: clt$type_specification_size,                                                             
        element_type_spec_2: record                                                                           
          header: clt$type_specification_header,                                                              
          qualifier: clt$name_type_qualifier,                                                                 
        recend,                                                                                               
        type_size_3: clt$type_specification_size,                                                             
        element_type_spec_3: record                                                                           
          header: clt$type_specification_header,                                                              
          qualifier: clt$integer_type_qualifier,                                                              
        recend,                                                                                               
      recend,                                                                                                 
    recend := [                                                                                               
    [1,                                                                                                       
    [89, 12, 11, 12, 7, 54, 386],                                                                             
    clc$function, 1, 1, 1, 0, 0, 0, 0, ''], [                                                                 
    ['RECORD_NAME                    ',clc$nominal_entry, 1]],                                                
    [                                                                                                         
{ PARAMETER 1                                                                                                 
    [1, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 57, clc$required_parameter, 
  0, 0]],                                                                                                     
{ PARAMETER 1                                                                                                 
    [[1, 0, clc$union_type], [[clc$integer_type, clc$name_type, clc$string_type],                             
    FALSE, 3],                                                                                                
    8, [[1, 0, clc$string_type], [1, 3, FALSE]],                                                              
    5, [[1, 0, clc$name_type], [1, osc$max_name_size]],                                                       
    20, [[1, 0, clc$integer_type], [clc$min_integer, clc$max_integer, 10]]                                    
    ]];                                                                                                       
?? FMT (FORMAT := ON) ??                                                                                      
?? POP ??                                                                                                     
                                                                                                              
    CONST                                                                                                     
      p$record_name = 1;                                                                                      
                                                                                                              
    VAR                                                                                                       
      pvt: array [1 .. 1] of clt$parameter_value;                                                             
                                                                                                              
    VAR                                                                                                       
      entry_p: ^dut$de_other_record_entry,                                                                    
      record_type: ost$name;                                                                                  
                                                                                                              
    status.normal := TRUE;                                                                                    
    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);                                  
    IF NOT status.normal THEN                                                                                 
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    IF duv$dump_environment_p = NIL THEN                                                                      
      osp$set_status_abnormal (duc$dump_analyzer_id, due$no_restart_file, '', status);                        
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    { Search for the desired record.                                                                          
                                                                                                              
    dup$find_record_list_entry (pvt [p$record_name].value^, entry_p);                                         
    IF entry_p = NIL THEN                                                                                     
      osp$set_status_abnormal (duc$dump_analyzer_id, due$data_not_on_dump, 'The specified record is', status);
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
    IF entry_p^.record_type = duc$de_ort_dump THEN                                                            
      record_type := 'DUMP';                                                                                  
    ELSEIF entry_p^.record_type = duc$de_ort_report THEN                                                      
      record_type := 'REPORT';                                                                                
    ELSE                                                                                                      
      record_type := 'DETAIL';                                                                                
    IFEND;                                                                                                    
                                                                                                              
    clp$make_name_value (record_type, work_area_p, result_p);                                                 
                                                                                                              
  PROCEND dup$$dump_record_type;                                                                              
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'dup$$exchange_package', EJECT ??                                                              
                                                                                                              
{ PURPOSE:                                                                                                    
{   This function returns an exchange_package as an SCL record.                                               
                                                                                                              
  PROCEDURE [XDCL] dup$$exchange_package                                                                      
    (    parameter_list: clt$parameter_list;                                                                  
     VAR work_area: ^clt$work_area;                                                                           
     VAR result: ^clt$data_value;                                                                             
     VAR status: ost$status);                                                                                 
                                                                                                              
{ FUNCTION $exchange_package, $ep (                                                                           
{   exchange: any of                                                                                          
{       key                                                                                                   
{         (active, a)                                                                                         
{         (monitor, m)                                                                                        
{         (job, j)                                                                                            
{       keyend                                                                                                
{       integer 0..0ffffffff(16)                                                                              
{     anyend = active                                                                                         
{   processor: integer 0..3 = 0                                                                               
{   display_option: key                                                                                       
{       (full, all, f, a)                                                                                     
{       (brief, b)                                                                                            
{     keyend = brief                                                                                          
{   )                                                                                                         
                                                                                                              
?? PUSH (LISTEXT := ON) ??                                                                                    
?? FMT (FORMAT := OFF) ??                                                                                     
                                                                                                              
  VAR                                                                                                         
    pdt: [STATIC, READ, cls$declaration_section] record                                                       
      header: clt$pdt_header,                                                                                 
      names: array [1 .. 3] of clt$pdt_parameter_name,                                                        
      parameters: array [1 .. 3] of clt$pdt_parameter,                                                        
      type1: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$union_type_qualifier,                                                                  
        type_size_1: clt$type_specification_size,                                                             
        element_type_spec_1: record                                                                           
          header: clt$type_specification_header,                                                              
          qualifier: clt$keyword_type_qualifier,                                                              
          keyword_specs: array [1 .. 6] of clt$keyword_specification,                                         
        recend,                                                                                               
        type_size_2: clt$type_specification_size,                                                             
        element_type_spec_2: record                                                                           
          header: clt$type_specification_header,                                                              
          qualifier: clt$integer_type_qualifier,                                                              
        recend,                                                                                               
        default_value: string (6),                                                                            
      recend,                                                                                                 
      type2: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
        default_value: string (1),                                                                            
      recend,                                                                                                 
      type3: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$keyword_type_qualifier,                                                                
        keyword_specs: array [1 .. 6] of clt$keyword_specification,                                           
        default_value: string (5),                                                                            
      recend,                                                                                                 
    recend := [                                                                                               
    [1,                                                                                                       
    [102, 3, 21, 9, 58, 21, 601],                                                                             
    clc$function, 3, 3, 0, 0, 0, 0, 0, ''], [                                                                 
    ['DISPLAY_OPTION                 ',clc$nominal_entry, 3],                                                 
    ['EXCHANGE                       ',clc$nominal_entry, 1],                                                 
    ['PROCESSOR                      ',clc$nominal_entry, 2]],                                                
    [                                                                                                         
{ PARAMETER 1                                                                                                 
    [2, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 269,                        
  clc$optional_default_parameter, 0, 6],                                                                      
{ PARAMETER 2                                                                                                 
    [3, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20,                         
  clc$optional_default_parameter, 0, 1],                                                                      
{ PARAMETER 3                                                                                                 
    [1, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 229,                        
  clc$optional_default_parameter, 0, 5]],                                                                     
{ PARAMETER 1                                                                                                 
    [[1, 0, clc$union_type], [[clc$integer_type, clc$keyword_type],                                           
    FALSE, 2],                                                                                                
    229, [[1, 0, clc$keyword_type], [6], [                                                                    
      ['A                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],                 
      ['ACTIVE                         ', clc$nominal_entry, clc$normal_usage_entry, 1],                      
      ['J                              ', clc$abbreviation_entry, clc$normal_usage_entry, 3],                 
      ['JOB                            ', clc$nominal_entry, clc$normal_usage_entry, 3],                      
      ['M                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],                 
      ['MONITOR                        ', clc$nominal_entry, clc$normal_usage_entry, 2]]                      
      ],                                                                                                      
    20, [[1, 0, clc$integer_type], [0, 0ffffffff(16), 10]]                                                    
    ,                                                                                                         
    'active'],                                                                                                
{ PARAMETER 2                                                                                                 
    [[1, 0, clc$integer_type], [0, 3, 10],                                                                    
    '0'],                                                                                                     
{ PARAMETER 3                                                                                                 
    [[1, 0, clc$keyword_type], [6], [                                                                         
    ['A                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],                   
    ['ALL                            ', clc$alias_entry, clc$normal_usage_entry, 1],                          
    ['B                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],                   
    ['BRIEF                          ', clc$nominal_entry, clc$normal_usage_entry, 2],                        
    ['F                              ', clc$alias_entry, clc$normal_usage_entry, 1],                          
    ['FULL                           ', clc$nominal_entry, clc$normal_usage_entry, 1]]                        
    ,                                                                                                         
    'brief']];                                                                                                
                                                                                                              
?? FMT (FORMAT := ON) ??                                                                                      
?? POP ??                                                                                                     
                                                                                                              
    CONST                                                                                                     
      p$exchange = 1,                                                                                         
      p$processor = 2,                                                                                        
      p$display_option = 3;                                                                                   
                                                                                                              
    VAR                                                                                                       
      pvt: array [1 .. 3] of clt$parameter_value;                                                             
                                                                                                              
    VAR                                                                                                       
      exchange_package_p: ^dut$exchange_package;                                                              
                                                                                                              
    status.normal := TRUE;                                                                                    
                                                                                                              
    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);                                  
    IF NOT status.normal THEN                                                                                 
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    dup$retrieve_exchange_package (pvt [p$processor].value^.integer_value.value, pvt [p$exchange].value^,     
          exchange_package_p, status);                                                                        
    IF NOT status.normal THEN                                                                                 
      RETURN; {----->                                                                                         
    IFEND;                                                                                                    
                                                                                                              
    p$make_exchange_package (exchange_package_p^, pvt [p$display_option].value^.keyword_value = 'FULL',       
          result, work_area);                                                                                 
                                                                                                              
  PROCEND dup$$exchange_package;                                                                              
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'dup$$execution_environment', EJECT ??                                                         
                                                                                                              
{ PURPOSE:                                                                                                    
{   This function returns execution_environment as an SCL record.                                             
                                                                                                              
  PROCEDURE [XDCL] dup$$execution_environment                                                                 
    (    parameter_list: clt$parameter_list;                                                                  
     VAR work_area: ^clt$work_area;                                                                           
     VAR result: ^clt$data_value;                                                                             
     VAR status: ost$status);                                                                                 
                                                                                                              
{ FUNCTION $execution_environment, $ee                                                                        
                                                                                                              
?? PUSH (LISTEXT := ON) ??                                                                                    
?? FMT (FORMAT := OFF) ??                                                                                     
                                                                                                              
  VAR                                                                                                         
    pdt: [STATIC, READ, cls$declaration_section] record                                                       
      header: clt$pdt_header,                                                                                 
    recend := [                                                                                               
    [1,                                                                                                       
    [101, 7, 6, 10, 32, 2, 602],                                                                              
    clc$function, 0, 0, 0, 0, 0, 0, 0, '']];                                                                  
                                                                                                              
?? FMT (FORMAT := ON) ??                                                                                      
?? POP ??                                                                                                     
                                                                                                              
    VAR                                                                                                       
      v$processing_option_names: [READ] array [dut$ee_processing_options] of string (15) := [                 
{ DUC$EE_PO_ALL_MEMORY       } 'ALL_MEMORY     ',                                                             
{ DUC$EE_PO_CRITICAL_MEMORY  } 'CRITICAL_MEMORY',                                                             
{ DUC$EE_PO_NO_MEMORY        } 'NO_MEMORY      '];                                                            
                                                                                                              
    VAR                                                                                                       
      attribute_record_index: 0 .. clc$max_fields,                                                            
      attribute_record_p: ^clt$data_value;                                                                    
                                                                                                              
    status.normal := TRUE;                                                                                    
    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, NIL, status);                                   
    IF NOT status.normal THEN                                                                                 
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
{Build the SCL record header                                                                                  
    attribute_record_p := clf#make_record_header_value (4, work_area);                                        
    attribute_record_index := 0;                                                                              
                                                                                                              
    #SPOIL (work_area);                                                                                       
    clp#add_record_field ('PROCESSING_OPTIONS', clf#make_keyword_value                                        
          (v$processing_option_names [duv$execution_environment.processing_options], work_area),              
          attribute_record_index, attribute_record_p);                                                        
                                                                                                              
    #SPOIL (work_area);                                                                                       
    clp#add_record_field ('OUTPUT_FILE', f$make_output_file_value (work_area), attribute_record_index,        
          attribute_record_p);                                                                                
                                                                                                              
    #SPOIL (work_area);                                                                                       
    clp#add_record_field ('RESTART_FILE', f$make_restart_file_value (work_area), attribute_record_index,      
          attribute_record_p);                                                                                
                                                                                                              
    #SPOIL (work_area);                                                                                       
    clp#add_record_field ('PROCESSOR_REGISTERS', f$make_proc_register_values                                  
          (duv$execution_environment.processor_registers, TRUE {=include status summary} , work_area),        
          attribute_record_index, attribute_record_p);                                                        
                                                                                                              
    result := attribute_record_p;                                                                             
                                                                                                              
  PROCEND dup$$execution_environment;                                                                         
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'dup$$maintenance_register', EJECT ??                                                          
                                                                                                              
{ PURPOSE:                                                                                                    
{ This function returns the desired maintenance register as an integer.                                       
                                                                                                              
  PROCEDURE [XDCL] dup$$maintenance_register                                                                  
    (    parameter_list: clt$parameter_list;                                                                  
     VAR work_area_p: ^clt$work_area;                                                                         
     VAR result_p: ^clt$data_value;                                                                           
     VAR status: ost$status);                                                                                 
                                                                                                              
{ FUNCTION $maintenance_register, $mr (                                                                       
{   register: any of                                                                                          
{       key                                                                                                   
{         (job_process_state jps) (monitor_process_state mps)                                                 
{       keyend                                                                                                
{       integer 0..255                                                                                        
{     anyend = $required                                                                                      
{   element: key                                                                                              
{       (input_output_unit iou) (memory m) (processor p)                                                      
{     keyend = processor                                                                                      
{   processor: integer 0..3 = 0                                                                               
{   iou: integer 0..1 = 0                                                                                     
{   )                                                                                                         
                                                                                                              
?? PUSH (LISTEXT := ON) ??                                                                                    
?? FMT (FORMAT := OFF) ??                                                                                     
  VAR                                                                                                         
    pdt: [STATIC, READ, cls$declaration_section] record                                                       
      header: clt$pdt_header,                                                                                 
      names: array [1 .. 4] of clt$pdt_parameter_name,                                                        
      parameters: array [1 .. 4] of clt$pdt_parameter,                                                        
      type1: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$union_type_qualifier,                                                                  
        type_size_1: clt$type_specification_size,                                                             
        element_type_spec_1: record                                                                           
          header: clt$type_specification_header,                                                              
          qualifier: clt$keyword_type_qualifier,                                                              
          keyword_specs: array [1 .. 4] of clt$keyword_specification,                                         
        recend,                                                                                               
        type_size_2: clt$type_specification_size,                                                             
        element_type_spec_2: record                                                                           
          header: clt$type_specification_header,                                                              
          qualifier: clt$integer_type_qualifier,                                                              
        recend,                                                                                               
      recend,                                                                                                 
      type2: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$keyword_type_qualifier,                                                                
        keyword_specs: array [1 .. 6] of clt$keyword_specification,                                           
        default_value: string (9),                                                                            
      recend,                                                                                                 
      type3: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
        default_value: string (1),                                                                            
      recend,                                                                                                 
      type4: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
        default_value: string (1),                                                                            
      recend,                                                                                                 
    recend := [                                                                                               
    [1,                                                                                                       
    [89, 6, 20, 10, 26, 9, 732],                                                                              
    clc$function, 4, 4, 1, 0, 0, 0, 0, ''], [                                                                 
    ['ELEMENT                        ',clc$nominal_entry, 2],                                                 
    ['IOU                            ',clc$nominal_entry, 4],                                                 
    ['PROCESSOR                      ',clc$nominal_entry, 3],                                                 
    ['REGISTER                       ',clc$nominal_entry, 1]],                                                
    [                                                                                                         
{ PARAMETER 1                                                                                                 
    [4, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 195,                        
  clc$required_parameter, 0, 0],                                                                              
{ PARAMETER 2                                                                                                 
    [1, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 229,                        
  clc$optional_default_parameter, 0, 9],                                                                      
{ PARAMETER 3                                                                                                 
    [3, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20,                         
  clc$optional_default_parameter, 0, 1],                                                                      
{ PARAMETER 4                                                                                                 
    [2, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20,                         
  clc$optional_default_parameter, 0, 1]],                                                                     
{ PARAMETER 1                                                                                                 
    [[1, 0, clc$union_type], [[clc$integer_type, clc$keyword_type],                                           
    FALSE, 2],                                                                                                
    155, [[1, 0, clc$keyword_type], [4], [                                                                    
      ['JOB_PROCESS_STATE              ', clc$nominal_entry, clc$normal_usage_entry, 1],                      
      ['JPS                            ', clc$abbreviation_entry, clc$normal_usage_entry, 1],                 
      ['MONITOR_PROCESS_STATE          ', clc$nominal_entry, clc$normal_usage_entry, 2],                      
      ['MPS                            ', clc$abbreviation_entry, clc$normal_usage_entry, 2]]                 
      ],                                                                                                      
    20, [[1, 0, clc$integer_type], [0, 255, 10]]                                                              
    ],                                                                                                        
{ PARAMETER 2                                                                                                 
    [[1, 0, clc$keyword_type], [6], [                                                                         
    ['INPUT_OUTPUT_UNIT              ', clc$nominal_entry, clc$normal_usage_entry, 1],                        
    ['IOU                            ', clc$abbreviation_entry, clc$normal_usage_entry, 1],                   
    ['M                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],                   
    ['MEMORY                         ', clc$nominal_entry, clc$normal_usage_entry, 2],                        
    ['P                              ', clc$abbreviation_entry, clc$normal_usage_entry, 3],                   
    ['PROCESSOR                      ', clc$nominal_entry, clc$normal_usage_entry, 3]]                        
    ,                                                                                                         
    'processor'],                                                                                             
{ PARAMETER 3                                                                                                 
    [[1, 0, clc$integer_type], [0, 3, 10],                                                                    
    '0'],                                                                                                     
{ PARAMETER 4                                                                                                 
    [[1, 0, clc$integer_type], [0, 1, 10],                                                                    
    '0']];                                                                                                    
?? FMT (FORMAT := ON) ??                                                                                      
?? POP ??                                                                                                     
                                                                                                              
    CONST                                                                                                     
      p$register = 1,                                                                                         
      p$element = 2,                                                                                          
      p$processor = 3,                                                                                        
      p$iou = 4;                                                                                              
                                                                                                              
    VAR                                                                                                       
      pvt: array [1 .. 4] of clt$parameter_value;                                                             
                                                                                                              
    TYPE                                                                                                      
      t$integer_or_array = record                                                                             
        case boolean of                                                                                       
        = TRUE =                                                                                              
          array_part: array [1 .. duc$de_max_register_length] of 0 .. 0ff(16),                                
        = FALSE =                                                                                             
          integer_part: integer,                                                                              
        casend,                                                                                               
      recend;                                                                                                 
                                                                                                              
    VAR                                                                                                       
      default_list: array [1 .. 2] of dut$default_change_list_entry,                                          
      display_string: string (osc$max_string_size),                                                           
      integer_or_array: t$integer_or_array,                                                                   
      processor: 0 .. duc$de_maximum_processors,                                                              
      register: dut$de_maintenance_register,                                                                  
      string_length: integer;                                                                                 
                                                                                                              
    status.normal := TRUE;                                                                                    
                                                                                                              
    { Change the default value for the PROCESSOR and IOU parameters.                                          
                                                                                                              
    default_list [1].default_name := duc$dp_processor;                                                        
    default_list [1].number := p$processor;                                                                   
    default_list [2].default_name := duc$dp_iou;                                                              
    default_list [2].number := p$iou;                                                                         
    dup$evaluate_parameters (parameter_list, default_list, #SEQ (pdt), ^pvt, status);                         
    IF NOT status.normal THEN                                                                                 
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    IF duv$dump_environment_p = NIL THEN                                                                      
      osp$set_status_abnormal (duc$dump_analyzer_id, due$no_restart_file, '', status);                        
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    IF (pvt [p$register].value^.kind = clc$keyword) AND (pvt [p$element].value^.keyword_value <>              
          'PROCESSOR') THEN                                                                                   
      osp$set_status_abnormal (duc$dump_analyzer_id, due$register_not_defined,                                
            pvt [p$register].value^.keyword_value, status);                                                   
      osp$append_status_parameter (osc$status_parameter_delimiter, pvt [p$element].value^.keyword_value,      
            status);                                                                                          
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    IF pvt [p$element].value^.keyword_value = 'INPUT_OUTPUT_UNIT' THEN                                        
      dup$retrieve_register (duc$de_iou, pvt [p$iou].value^.integer_value.value,                              
            pvt [p$register].value^.integer_value.value, register);                                           
      IF register.available THEN                                                                              
        integer_or_array.array_part := register.value;                                                        
        clp$make_integer_value (integer_or_array.integer_part, 16, TRUE, work_area_p, result_p);              
      ELSE                                                                                                    
        STRINGREP (display_string, string_length, 'IOU register', pvt [p$register].value^.integer_value.      
              value: #(16), '(16) is');                                                                       
        osp$set_status_abnormal (duc$dump_analyzer_id, due$data_not_on_dump,                                  
              display_string (1, string_length), status);                                                     
      IFEND;                                                                                                  
                                                                                                              
    ELSEIF pvt [p$element].value^.keyword_value = 'MEMORY' THEN                                               
      dup$retrieve_register (duc$de_memory, 0, pvt [p$register].value^.integer_value.value, register);        
      IF register.available THEN                                                                              
        integer_or_array.array_part := register.value;                                                        
        clp$make_integer_value (integer_or_array.integer_part, 16, TRUE, work_area_p, result_p);              
      ELSE                                                                                                    
        STRINGREP (display_string, string_length, 'Memory register',                                          
              pvt [p$register].value^.integer_value.value: #(16), '(16) is');                                 
        osp$set_status_abnormal (duc$dump_analyzer_id, due$data_not_on_dump,                                  
              display_string (1, string_length), status);                                                     
      IFEND;                                                                                                  
                                                                                                              
    ELSE { pvt [p$element].value^.keyword_value = 'PROCESSOR' }                                               
      processor := pvt [p$processor].value^.integer_value.value;                                              
      IF NOT duv$execution_environment.processor_registers [processor].available THEN                         
        osp$set_status_abnormal (duc$dump_analyzer_id, due$data_not_on_dump,                                  
              'The processor maintenance registers for processor', status);                                   
        osp$append_status_integer (osc$status_parameter_delimiter, processor, 10, FALSE, status);             
        osp$append_status_parameter (osc$status_parameter_delimiter, 'are', status);                          
        RETURN; {---->                                                                                        
      IFEND;                                                                                                  
                                                                                                              
      IF pvt [p$register].value^.kind = clc$keyword THEN                                                      
        IF pvt [p$register].value^.keyword_value = 'JOB_PROCESS_STATE' THEN                                   
          integer_or_array.integer_part := duv$execution_environment.processor_registers [processor].         
                job_process_state;                                                                            
        ELSE                                                                                                  
          integer_or_array.integer_part := duv$execution_environment.processor_registers [processor].         
                monitor_process_state;                                                                        
        IFEND;                                                                                                
        clp$make_integer_value (integer_or_array.integer_part, 16, TRUE, work_area_p, result_p);              
                                                                                                              
      ELSEIF pvt [p$register].value^.integer_value.value = osc$pr_job_process_state THEN                      
        integer_or_array.integer_part := duv$execution_environment.processor_registers [processor].           
              job_process_state;                                                                              
        clp$make_integer_value (integer_or_array.integer_part, 16, TRUE, work_area_p, result_p);              
                                                                                                              
      ELSEIF pvt [p$register].value^.integer_value.value = osc$pr_monitor_process_state THEN                  
        integer_or_array.integer_part := duv$execution_environment.processor_registers [processor].           
              monitor_process_state;                                                                          
        clp$make_integer_value (integer_or_array.integer_part, 16, TRUE, work_area_p, result_p);              
                                                                                                              
      ELSE                                                                                                    
        dup$retrieve_register (duc$de_cpu, processor, pvt [p$register].value^.integer_value.value, register); 
        IF register.available THEN                                                                            
          integer_or_array.array_part := register.value;                                                      
          clp$make_integer_value (integer_or_array.integer_part, 16, TRUE, work_area_p, result_p);            
        ELSE                                                                                                  
          STRINGREP (display_string, string_length, 'The processor register',                                 
                pvt [p$register].value^.integer_value.value: #(16), '(16) for processor');                    
          osp$set_status_abnormal (duc$dump_analyzer_id, due$data_not_on_dump,                                
                display_string (1, string_length), status);                                                   
          osp$append_status_integer (osc$status_parameter_delimiter, processor, 10, FALSE, status);           
          osp$append_status_parameter (osc$status_parameter_delimiter, 'is', status);                         
        IFEND;                                                                                                
      IFEND;                                                                                                  
    IFEND;                                                                                                    
                                                                                                              
  PROCEND dup$$maintenance_register;                                                                          
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'dup$$memory', EJECT ??                                                                        
                                                                                                              
{ PURPOSE:                                                                                                    
{   This function returns the contents of the memory address specified as an integer.                         
                                                                                                              
  PROCEDURE [XDCL] dup$$memory                                                                                
    (    parameter_list: clt$parameter_list;                                                                  
     VAR work_area_p: ^clt$work_area;                                                                         
     VAR result_p: ^clt$data_value;                                                                           
     VAR status: ost$status);                                                                                 
                                                                                                              
{ FUNCTION $memory, $mem (                                                                                    
{   address: integer 0..0ffffffffffff(16) = $required                                                         
{   byte_count: integer 1..8 = 6                                                                              
{   exchange: any of                                                                                          
{       key                                                                                                   
{         (active a) (monitor m) (job j)                                                                      
{       keyend                                                                                                
{       integer 0..0ffffffff(16)                                                                              
{     anyend = 0ffffffff(16)                                                                                  
{   processor: integer 0..3 = 0                                                                               
{   address_mode: key                                                                                         
{       (process_virtual_address pva) (system_virtual_address sva) (real_memory_address rma)                  
{     keyend = process_virtual_address                                                                        
{   )                                                                                                         
                                                                                                              
?? PUSH (LISTEXT := ON) ??                                                                                    
?? FMT (FORMAT := OFF) ??                                                                                     
  VAR                                                                                                         
    pdt: [STATIC, READ, cls$declaration_section] record                                                       
      header: clt$pdt_header,                                                                                 
      names: array [1 .. 5] of clt$pdt_parameter_name,                                                        
      parameters: array [1 .. 5] of clt$pdt_parameter,                                                        
      type1: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
      recend,                                                                                                 
      type2: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
        default_value: string (1),                                                                            
      recend,                                                                                                 
      type3: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$union_type_qualifier,                                                                  
        type_size_1: clt$type_specification_size,                                                             
        element_type_spec_1: record                                                                           
          header: clt$type_specification_header,                                                              
          qualifier: clt$keyword_type_qualifier,                                                              
          keyword_specs: array [1 .. 6] of clt$keyword_specification,                                         
        recend,                                                                                               
        type_size_2: clt$type_specification_size,                                                             
        element_type_spec_2: record                                                                           
          header: clt$type_specification_header,                                                              
          qualifier: clt$integer_type_qualifier,                                                              
        recend,                                                                                               
        default_value: string (13),                                                                           
      recend,                                                                                                 
      type4: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
        default_value: string (1),                                                                            
      recend,                                                                                                 
      type5: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$keyword_type_qualifier,                                                                
        keyword_specs: array [1 .. 6] of clt$keyword_specification,                                           
        default_value: string (23),                                                                           
      recend,                                                                                                 
    recend := [                                                                                               
    [1,                                                                                                       
    [89, 6, 14, 10, 10, 17, 787],                                                                             
    clc$function, 5, 5, 1, 0, 0, 0, 0, ''], [                                                                 
    ['ADDRESS                        ',clc$nominal_entry, 1],                                                 
    ['ADDRESS_MODE                   ',clc$nominal_entry, 5],                                                 
    ['BYTE_COUNT                     ',clc$nominal_entry, 2],                                                 
    ['EXCHANGE                       ',clc$nominal_entry, 3],                                                 
    ['PROCESSOR                      ',clc$nominal_entry, 4]],                                                
    [                                                                                                         
{ PARAMETER 1                                                                                                 
    [1, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$required_parameter, 
  0, 0],                                                                                                      
{ PARAMETER 2                                                                                                 
    [3, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20,                         
  clc$optional_default_parameter, 0, 1],                                                                      
{ PARAMETER 3                                                                                                 
    [4, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 269,                        
  clc$optional_default_parameter, 0, 13],                                                                     
{ PARAMETER 4                                                                                                 
    [5, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20,                         
  clc$optional_default_parameter, 0, 1],                                                                      
{ PARAMETER 5                                                                                                 
    [2, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 229,                        
  clc$optional_default_parameter, 0, 23]],                                                                    
{ PARAMETER 1                                                                                                 
    [[1, 0, clc$integer_type], [0, 0ffffffffffff(16), 10]],                                                   
{ PARAMETER 2                                                                                                 
    [[1, 0, clc$integer_type], [1, 8, 10],                                                                    
    '6'],                                                                                                     
{ PARAMETER 3                                                                                                 
    [[1, 0, clc$union_type], [[clc$integer_type, clc$keyword_type],                                           
    FALSE, 2],                                                                                                
    229, [[1, 0, clc$keyword_type], [6], [                                                                    
      ['A                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],                 
      ['ACTIVE                         ', clc$nominal_entry, clc$normal_usage_entry, 1],                      
      ['J                              ', clc$abbreviation_entry, clc$normal_usage_entry, 3],                 
      ['JOB                            ', clc$nominal_entry, clc$normal_usage_entry, 3],                      
      ['M                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],                 
      ['MONITOR                        ', clc$nominal_entry, clc$normal_usage_entry, 2]]                      
      ],                                                                                                      
    20, [[1, 0, clc$integer_type], [0, 0ffffffff(16), 10]]                                                    
    ,                                                                                                         
    '0ffffffff(16)'],                                                                                         
{ PARAMETER 4                                                                                                 
    [[1, 0, clc$integer_type], [0, 3, 10],                                                                    
    '0'],                                                                                                     
{ PARAMETER 5                                                                                                 
    [[1, 0, clc$keyword_type], [6], [                                                                         
    ['PROCESS_VIRTUAL_ADDRESS        ', clc$nominal_entry, clc$normal_usage_entry, 1],                        
    ['PVA                            ', clc$abbreviation_entry, clc$normal_usage_entry, 1],                   
    ['REAL_MEMORY_ADDRESS            ', clc$nominal_entry, clc$normal_usage_entry, 3],                        
    ['RMA                            ', clc$abbreviation_entry, clc$normal_usage_entry, 3],                   
    ['SVA                            ', clc$abbreviation_entry, clc$normal_usage_entry, 2],                   
    ['SYSTEM_VIRTUAL_ADDRESS         ', clc$nominal_entry, clc$normal_usage_entry, 2]]                        
    ,                                                                                                         
    'process_virtual_address']];                                                                              
?? FMT (FORMAT := ON) ??                                                                                      
?? POP ??                                                                                                     
                                                                                                              
    CONST                                                                                                     
      p$address = 1,                                                                                          
      p$byte_count = 2,                                                                                       
      p$exchange = 3,                                                                                         
      p$processor = 4,                                                                                        
      p$address_mode = 5;                                                                                     
                                                                                                              
    VAR                                                                                                       
      pvt: array [1 .. 5] of clt$parameter_value;                                                             
                                                                                                              
    VAR                                                                                                       
      access_data: dut$access_data,                                                                           
      address: dut$ee_address_parameter,                                                                      
      byte_count: 1 .. 8,                                                                                     
      bytes_returned: ost$segment_length,                                                                     
      data_array_p: ^array [ * ] of 0 .. 0ff(16),                                                             
      data_p: ^integer,                                                                                       
      data_seq_p: ^SEQ ( * ),                                                                                 
      default_list: array [1 .. 3] of dut$default_change_list_entry,                                          
      exchange_package_p: ^dut$exchange_package,                                                              
      memory_file_array_p: ^array [ * ] of 0 .. 0ff(16),                                                      
      memory_p: ^cell,                                                                                        
      new_byte_size: ost$segment_length,                                                                      
      processor: 0 .. duc$de_maximum_processors,                                                              
      skip_data_p: ^SEQ ( * );                                                                                
                                                                                                              
    status.normal := TRUE;                                                                                    
                                                                                                              
    { Change the default value for the EXCHANGE, PROCESSOR and ADDRESS_MODE parameters.                       
                                                                                                              
    default_list [1].default_name := duc$dp_exchange;                                                         
    default_list [1].number := p$exchange;                                                                    
    default_list [2].default_name := duc$dp_processor;                                                        
    default_list [2].number := p$processor;                                                                   
    default_list [3].default_name := duc$dp_address_mode;                                                     
    default_list [3].number := p$address_mode;                                                                
    dup$evaluate_parameters (parameter_list, default_list, #SEQ (pdt), ^pvt, status);                         
    IF NOT status.normal THEN                                                                                 
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    IF duv$dump_environment_p = NIL THEN                                                                      
      osp$set_status_abnormal (duc$dump_analyzer_id, due$no_restart_file, '', status);                        
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    address.rma_part := pvt [p$address].value^.integer_value.value;                                           
    processor := pvt [p$processor].value^.integer_value.value;                                                
    byte_count := pvt [p$byte_count].value^.integer_value.value;                                              
                                                                                                              
    PUSH data_seq_p: [[REP 1 OF integer]];                                                                    
    RESET data_seq_p;                                                                                         
    IF data_seq_p = NIL THEN                                                                                  
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                            
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
    NEXT data_p IN data_seq_p;                                                                                
    IF data_p = NIL THEN                                                                                      
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                            
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
    data_p^ := 0;                                                                                             
    RESET data_seq_p;                                                                                         
                                                                                                              
    IF pvt [p$address_mode].value^.keyword_value = 'PROCESS_VIRTUAL_ADDRESS' THEN                             
      dup$retrieve_exchange_package (processor, pvt [p$exchange].value^, exchange_package_p, status);         
      IF NOT status.normal THEN                                                                               
        RETURN; {---->                                                                                        
      IFEND;                                                                                                  
      IF byte_count < 8 THEN                                                                                  
        NEXT skip_data_p: [[REP (8 - byte_count) OF cell]] IN data_seq_p;                                     
        IF skip_data_p = NIL THEN                                                                             
          osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                        
          RETURN; {---->                                                                                      
        IFEND;                                                                                                
      IFEND;                                                                                                  
      dup$copy_virtual_memory_pva (address.pva_part, exchange_package_p^, processor, byte_count, TRUE,        
            bytes_returned, data_seq_p, access_data, status);                                                 
      IF NOT status.normal AND (status.condition <> due$memory_partially_avail) THEN                          
        RETURN; {---->                                                                                        
      IFEND;                                                                                                  
      IF access_data.page_fault AND NOT access_data.memory_found THEN                                         
        osp$set_status_abnormal (duc$dump_analyzer_id, due$page_fault_error_severity, '', status);            
        osp$append_status_parameter (osc$status_parameter_delimiter, ', segment = ', status);                 
        osp$append_status_integer (osc$status_parameter_delimiter, address.pva_part.seg, 16, TRUE, status);   
        osp$append_status_parameter (osc$status_parameter_delimiter, ', offset = ', status);                  
        osp$append_status_integer (osc$status_parameter_delimiter, access_data.page_fault_offset, 16, TRUE,   
              status);                                                                                        
        RETURN; {---->                                                                                        
      IFEND;                                                                                                  
                                                                                                              
    ELSEIF pvt [p$address_mode].value^.keyword_value = 'SYSTEM_VIRTUAL_ADDRESS' THEN                          
      IF byte_count < 8 THEN                                                                                  
        NEXT skip_data_p: [[REP (8 - byte_count) OF cell]] IN data_seq_p;                                     
        IF skip_data_p = NIL THEN                                                                             
          osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                        
          RETURN; {---->                                                                                      
        IFEND;                                                                                                
      IFEND;                                                                                                  
      dup$copy_virtual_memory_sva (address.sva_part, processor, byte_count, TRUE, bytes_returned, data_seq_p, 
            access_data, status);                                                                             
      IF NOT status.normal AND (status.condition <> due$memory_partially_avail) THEN                          
        RETURN; {---->                                                                                        
      IFEND;                                                                                                  
      IF access_data.page_fault AND NOT access_data.memory_found THEN                                         
        osp$set_status_abnormal (duc$dump_analyzer_id, due$page_fault_error_severity, '', status);            
        osp$append_status_parameter (osc$status_parameter_delimiter, ', asid = ', status);                    
        osp$append_status_integer (osc$status_parameter_delimiter, address.sva_part.asid.value, 16, TRUE,     
              status);                                                                                        
        osp$append_status_parameter (osc$status_parameter_delimiter, ', offset = ', status);                  
        osp$append_status_integer (osc$status_parameter_delimiter, access_data.page_fault_offset, 16, TRUE,   
              status);                                                                                        
        RETURN; {---->                                                                                        
      IFEND;                                                                                                  
                                                                                                              
    ELSE { pvt [p$address_mode].value^.keyword_value = 'REAL_MEMORY_ADDRESS' }                                
      dup$access_real_memory (byte_count, address.rma_part, memory_p, new_byte_size, status);                 
      IF NOT status.normal AND (status.condition <> due$memory_partially_avail) THEN                          
        RETURN; {---->                                                                                        
      IFEND;                                                                                                  
      IF new_byte_size < 8 THEN                                                                               
        NEXT skip_data_p: [[REP (8 - new_byte_size) OF cell]] IN data_seq_p;                                  
        IF skip_data_p = NIL THEN                                                                             
          osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                        
          RETURN; {---->                                                                                      
        IFEND;                                                                                                
      IFEND;                                                                                                  
      RESET duv$execution_environment.memory_file_p^.segment_pointer.sequence_pointer TO memory_p;            
      NEXT memory_file_array_p: [1 .. new_byte_size] IN duv$execution_environment.memory_file_p^.             
            segment_pointer.sequence_pointer;                                                                 
      IF memory_file_array_p = NIL THEN                                                                       
        osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                          
        RETURN; {---->                                                                                        
      IFEND;                                                                                                  
      NEXT data_array_p: [1 .. new_byte_size] IN data_seq_p;                                                  
      IF data_array_p = NIL THEN                                                                              
        osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                          
        RETURN; {---->                                                                                        
      IFEND;                                                                                                  
      data_array_p^ := memory_file_array_p^;                                                                  
    IFEND;                                                                                                    
                                                                                                              
    clp$make_integer_value (data_p^, 16, TRUE, work_area_p, result_p);                                        
                                                                                                              
  PROCEND dup$$memory;                                                                                        
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'dup$$memory_available', EJECT ??                                                              
                                                                                                              
{ PURPOSE:                                                                                                    
{   This function returns weather the contents of the memory address specified as an integer is               
{   available or not.                                                                                         
                                                                                                              
  PROCEDURE [XDCL] dup$$memory_available                                                                      
    (    parameter_list: clt$parameter_list;                                                                  
     VAR work_area_p: ^clt$work_area;                                                                         
     VAR result_p: ^clt$data_value;                                                                           
     VAR status: ost$status);                                                                                 
                                                                                                              
{ FUNCTION $memory_available, $ma (                                                                           
{   address: integer 0..0ffffffffffff(16) = $required                                                         
{   byte_count: integer 1..8 = 6                                                                              
{   exchange: any of                                                                                          
{       key                                                                                                   
{         (active, a)                                                                                         
{         (monitor, m)                                                                                        
{         (job, j)                                                                                            
{       keyend                                                                                                
{       integer 0..0ffffffff(16)                                                                              
{     anyend = 0ffffffff(16)                                                                                  
{   processor: integer 0..3 = 0                                                                               
{   address_mode: key                                                                                         
{       (process_virtual_address, pva)                                                                        
{       (system_virtual_address, sva)                                                                         
{       (real_memory_address, rma)                                                                            
{     keyend = process_virtual_address                                                                        
{   )                                                                                                         
                                                                                                              
?? PUSH (LISTEXT := ON) ??                                                                                    
?? FMT (FORMAT := OFF) ??                                                                                     
                                                                                                              
  VAR                                                                                                         
    pdt: [STATIC, READ, cls$declaration_section] record                                                       
      header: clt$pdt_header,                                                                                 
      names: array [1 .. 5] of clt$pdt_parameter_name,                                                        
      parameters: array [1 .. 5] of clt$pdt_parameter,                                                        
      type1: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
      recend,                                                                                                 
      type2: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
        default_value: string (1),                                                                            
      recend,                                                                                                 
      type3: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$union_type_qualifier,                                                                  
        type_size_1: clt$type_specification_size,                                                             
        element_type_spec_1: record                                                                           
          header: clt$type_specification_header,                                                              
          qualifier: clt$keyword_type_qualifier,                                                              
          keyword_specs: array [1 .. 6] of clt$keyword_specification,                                         
        recend,                                                                                               
        type_size_2: clt$type_specification_size,                                                             
        element_type_spec_2: record                                                                           
          header: clt$type_specification_header,                                                              
          qualifier: clt$integer_type_qualifier,                                                              
        recend,                                                                                               
        default_value: string (13),                                                                           
      recend,                                                                                                 
      type4: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
        default_value: string (1),                                                                            
      recend,                                                                                                 
      type5: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$keyword_type_qualifier,                                                                
        keyword_specs: array [1 .. 6] of clt$keyword_specification,                                           
        default_value: string (23),                                                                           
      recend,                                                                                                 
    recend := [                                                                                               
    [1,                                                                                                       
    [102, 6, 12, 10, 2, 33, 841],                                                                             
    clc$function, 5, 5, 1, 0, 0, 0, 0, ''], [                                                                 
    ['ADDRESS                        ',clc$nominal_entry, 1],                                                 
    ['ADDRESS_MODE                   ',clc$nominal_entry, 5],                                                 
    ['BYTE_COUNT                     ',clc$nominal_entry, 2],                                                 
    ['EXCHANGE                       ',clc$nominal_entry, 3],                                                 
    ['PROCESSOR                      ',clc$nominal_entry, 4]],                                                
    [                                                                                                         
{ PARAMETER 1                                                                                                 
    [1, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$required_parameter, 
  0, 0],                                                                                                      
{ PARAMETER 2                                                                                                 
    [3, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20,                         
  clc$optional_default_parameter, 0, 1],                                                                      
{ PARAMETER 3                                                                                                 
    [4, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 269,                        
  clc$optional_default_parameter, 0, 13],                                                                     
{ PARAMETER 4                                                                                                 
    [5, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20,                         
  clc$optional_default_parameter, 0, 1],                                                                      
{ PARAMETER 5                                                                                                 
    [2, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 229,                        
  clc$optional_default_parameter, 0, 23]],                                                                    
{ PARAMETER 1                                                                                                 
    [[1, 0, clc$integer_type], [0, 0ffffffffffff(16), 10]],                                                   
{ PARAMETER 2                                                                                                 
    [[1, 0, clc$integer_type], [1, 8, 10],                                                                    
    '6'],                                                                                                     
{ PARAMETER 3                                                                                                 
    [[1, 0, clc$union_type], [[clc$integer_type, clc$keyword_type],                                           
    FALSE, 2],                                                                                                
    229, [[1, 0, clc$keyword_type], [6], [                                                                    
      ['A                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],                 
      ['ACTIVE                         ', clc$nominal_entry, clc$normal_usage_entry, 1],                      
      ['J                              ', clc$abbreviation_entry, clc$normal_usage_entry, 3],                 
      ['JOB                            ', clc$nominal_entry, clc$normal_usage_entry, 3],                      
      ['M                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],                 
      ['MONITOR                        ', clc$nominal_entry, clc$normal_usage_entry, 2]]                      
      ],                                                                                                      
    20, [[1, 0, clc$integer_type], [0, 0ffffffff(16), 10]]                                                    
    ,                                                                                                         
    '0ffffffff(16)'],                                                                                         
{ PARAMETER 4                                                                                                 
    [[1, 0, clc$integer_type], [0, 3, 10],                                                                    
    '0'],                                                                                                     
{ PARAMETER 5                                                                                                 
    [[1, 0, clc$keyword_type], [6], [                                                                         
    ['PROCESS_VIRTUAL_ADDRESS        ', clc$nominal_entry, clc$normal_usage_entry, 1],                        
    ['PVA                            ', clc$abbreviation_entry, clc$normal_usage_entry, 1],                   
    ['REAL_MEMORY_ADDRESS            ', clc$nominal_entry, clc$normal_usage_entry, 3],                        
    ['RMA                            ', clc$abbreviation_entry, clc$normal_usage_entry, 3],                   
    ['SVA                            ', clc$abbreviation_entry, clc$normal_usage_entry, 2],                   
    ['SYSTEM_VIRTUAL_ADDRESS         ', clc$nominal_entry, clc$normal_usage_entry, 2]]                        
    ,                                                                                                         
    'process_virtual_address']];                                                                              
                                                                                                              
?? FMT (FORMAT := ON) ??                                                                                      
?? POP ??                                                                                                     
                                                                                                              
    CONST                                                                                                     
      p$address = 1,                                                                                          
      p$byte_count = 2,                                                                                       
      p$exchange = 3,                                                                                         
      p$processor = 4,                                                                                        
      p$address_mode = 5;                                                                                     
                                                                                                              
    VAR                                                                                                       
      pvt: array [1 .. 5] of clt$parameter_value;                                                             
                                                                                                              
    VAR                                                                                                       
      available: boolean,                                                                                     
      default_list: array [1 .. 3] of dut$default_change_list_entry;                                          
                                                                                                              
?? NEWTITLE := 'p$$memory_available', EJECT ??                                                                
                                                                                                              
    PROCEDURE p$$memory_available                                                                             
      (VAR available: boolean);                                                                               
                                                                                                              
      VAR                                                                                                     
        access_data: dut$access_data,                                                                         
        address: dut$ee_address_parameter,                                                                    
        byte_count: 1 .. 8,                                                                                   
        bytes_returned: ost$segment_length,                                                                   
        data_p: ^integer,                                                                                     
        data_seq_p: ^SEQ ( * ),                                                                               
        exchange_package_p: ^dut$exchange_package,                                                            
        memory_p: ^cell,                                                                                      
        new_byte_size: ost$segment_length,                                                                    
        processor: 0 .. duc$de_maximum_processors,                                                            
        status: ost$status;                                                                                   
                                                                                                              
      address.rma_part := pvt [p$address].value^.integer_value.value;                                         
      processor := pvt [p$processor].value^.integer_value.value;                                              
      byte_count := pvt [p$byte_count].value^.integer_value.value;                                            
                                                                                                              
      PUSH data_seq_p: [[REP 1 OF integer]];                                                                  
      RESET data_seq_p;                                                                                       
      NEXT data_p IN data_seq_p;                                                                              
      data_p^ := 0;                                                                                           
      RESET data_seq_p;                                                                                       
                                                                                                              
      available := FALSE;                                                                                     
      IF pvt [p$address_mode].value^.keyword_value = 'PROCESS_VIRTUAL_ADDRESS' THEN                           
        dup$retrieve_exchange_package (processor, pvt [p$exchange].value^, exchange_package_p, status);       
        IF NOT status.normal THEN                                                                             
          RETURN; {---->                                                                                      
        IFEND;                                                                                                
                                                                                                              
        dup$copy_virtual_memory_pva (address.pva_part, exchange_package_p^, processor, byte_count, TRUE,      
              bytes_returned, data_seq_p, access_data, status);                                               
        IF NOT status.normal AND (status.condition <> due$memory_partially_avail) THEN                        
          RETURN; {---->                                                                                      
        IFEND;                                                                                                
                                                                                                              
        available := NOT (access_data.page_fault AND NOT access_data.memory_found);                           
                                                                                                              
      ELSEIF pvt [p$address_mode].value^.keyword_value = 'SYSTEM_VIRTUAL_ADDRESS' THEN                        
        dup$copy_virtual_memory_sva (address.sva_part, processor, byte_count, TRUE, bytes_returned,           
              data_seq_p, access_data, status);                                                               
        IF NOT status.normal AND (status.condition <> due$memory_partially_avail) THEN                        
          RETURN; {---->                                                                                      
        IFEND;                                                                                                
                                                                                                              
        available := NOT (access_data.page_fault AND NOT access_data.memory_found);                           
                                                                                                              
      ELSE { pvt [p$address_mode].value^.keyword_value = 'REAL_MEMORY_ADDRESS' }                              
        dup$access_real_memory (byte_count, address.rma_part, memory_p, new_byte_size, status);               
        available := status.normal OR (status.condition = due$memory_partially_avail);                        
      IFEND;                                                                                                  
                                                                                                              
    PROCEND p$$memory_available;                                                                              
?? OLDTITLE ??                                                                                                
?? EJECT ??                                                                                                   
    status.normal := TRUE;                                                                                    
                                                                                                              
    { Change the default value for the EXCHANGE, PROCESSOR and ADDRESS_MODE parameters.                       
                                                                                                              
    default_list [1].default_name := duc$dp_exchange;                                                         
    default_list [1].number := p$exchange;                                                                    
    default_list [2].default_name := duc$dp_processor;                                                        
    default_list [2].number := p$processor;                                                                   
    default_list [3].default_name := duc$dp_address_mode;                                                     
    default_list [3].number := p$address_mode;                                                                
    dup$evaluate_parameters (parameter_list, default_list, #SEQ (pdt), ^pvt, status);                         
    IF NOT status.normal THEN                                                                                 
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    IF duv$dump_environment_p = NIL THEN                                                                      
      result_p := clf#make_boolean_value (FALSE, work_area_p);                                                
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    p$$memory_available (available);                                                                          
    result_p := clf#make_boolean_value (available, work_area_p);                                              
                                                                                                              
  PROCEND dup$$memory_available;                                                                              
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'dup$$memory_string', EJECT ??                                                                 
                                                                                                              
{ PURPOSE:                                                                                                    
{   This function returns the contents of the memory address as a string.                                     
                                                                                                              
  PROCEDURE [XDCL] dup$$memory_string                                                                         
    (    parameter_list: clt$parameter_list;                                                                  
     VAR work_area_p: ^clt$work_area;                                                                         
     VAR result_p: ^clt$data_value;                                                                           
     VAR status: ost$status);                                                                                 
                                                                                                              
{ FUNCTION $memory_string, $ms (                                                                              
{   address: integer 0..0ffffffffffff(16) = $required                                                         
{   byte_count: integer 0..65535 = 1                                                                          
{   exchange: any of                                                                                          
{       key                                                                                                   
{         (active, a)                                                                                         
{         (monitor, m)                                                                                        
{         (job, j)                                                                                            
{       keyend                                                                                                
{       integer 0..0ffffffff(16)                                                                              
{     anyend = 0ffffffff(16)                                                                                  
{   processor: integer 0..3 = 0                                                                               
{   address_mode: key                                                                                         
{       (process_virtual_address, pva)                                                                        
{       (system_virtual_address, sva)                                                                         
{       (real_memory_address, rma)                                                                            
{     keyend = process_virtual_address                                                                        
{   )                                                                                                         
                                                                                                              
?? PUSH (LISTEXT := ON) ??                                                                                    
?? FMT (FORMAT := OFF) ??                                                                                     
                                                                                                              
  VAR                                                                                                         
    pdt: [STATIC, READ, cls$declaration_section] record                                                       
      header: clt$pdt_header,                                                                                 
      names: array [1 .. 5] of clt$pdt_parameter_name,                                                        
      parameters: array [1 .. 5] of clt$pdt_parameter,                                                        
      type1: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
      recend,                                                                                                 
      type2: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
        default_value: string (1),                                                                            
      recend,                                                                                                 
      type3: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$union_type_qualifier,                                                                  
        type_size_1: clt$type_specification_size,                                                             
        element_type_spec_1: record                                                                           
          header: clt$type_specification_header,                                                              
          qualifier: clt$keyword_type_qualifier,                                                              
          keyword_specs: array [1 .. 6] of clt$keyword_specification,                                         
        recend,                                                                                               
        type_size_2: clt$type_specification_size,                                                             
        element_type_spec_2: record                                                                           
          header: clt$type_specification_header,                                                              
          qualifier: clt$integer_type_qualifier,                                                              
        recend,                                                                                               
        default_value: string (13),                                                                           
      recend,                                                                                                 
      type4: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
        default_value: string (1),                                                                            
      recend,                                                                                                 
      type5: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$keyword_type_qualifier,                                                                
        keyword_specs: array [1 .. 6] of clt$keyword_specification,                                           
        default_value: string (23),                                                                           
      recend,                                                                                                 
    recend := [                                                                                               
    [1,                                                                                                       
    [100, 8, 16, 13, 46, 11, 138],                                                                            
    clc$function, 5, 5, 1, 0, 0, 0, 0, ''], [                                                                 
    ['ADDRESS                        ',clc$nominal_entry, 1],                                                 
    ['ADDRESS_MODE                   ',clc$nominal_entry, 5],                                                 
    ['BYTE_COUNT                     ',clc$nominal_entry, 2],                                                 
    ['EXCHANGE                       ',clc$nominal_entry, 3],                                                 
    ['PROCESSOR                      ',clc$nominal_entry, 4]],                                                
    [                                                                                                         
{ PARAMETER 1                                                                                                 
    [1, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$required_parameter, 
  0, 0],                                                                                                      
{ PARAMETER 2                                                                                                 
    [3, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20,                         
  clc$optional_default_parameter, 0, 1],                                                                      
{ PARAMETER 3                                                                                                 
    [4, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 269,                        
  clc$optional_default_parameter, 0, 13],                                                                     
{ PARAMETER 4                                                                                                 
    [5, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20,                         
  clc$optional_default_parameter, 0, 1],                                                                      
{ PARAMETER 5                                                                                                 
    [2, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 229,                        
  clc$optional_default_parameter, 0, 23]],                                                                    
{ PARAMETER 1                                                                                                 
    [[1, 0, clc$integer_type], [0, 0ffffffffffff(16), 10]],                                                   
{ PARAMETER 2                                                                                                 
    [[1, 0, clc$integer_type], [0, 65535, 10],                                                                
    '1'],                                                                                                     
{ PARAMETER 3                                                                                                 
    [[1, 0, clc$union_type], [[clc$integer_type, clc$keyword_type],                                           
    FALSE, 2],                                                                                                
    229, [[1, 0, clc$keyword_type], [6], [                                                                    
      ['A                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],                 
      ['ACTIVE                         ', clc$nominal_entry, clc$normal_usage_entry, 1],                      
      ['J                              ', clc$abbreviation_entry, clc$normal_usage_entry, 3],                 
      ['JOB                            ', clc$nominal_entry, clc$normal_usage_entry, 3],                      
      ['M                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],                 
      ['MONITOR                        ', clc$nominal_entry, clc$normal_usage_entry, 2]]                      
      ],                                                                                                      
    20, [[1, 0, clc$integer_type], [0, 0ffffffff(16), 10]]                                                    
    ,                                                                                                         
    '0ffffffff(16)'],                                                                                         
{ PARAMETER 4                                                                                                 
    [[1, 0, clc$integer_type], [0, 3, 10],                                                                    
    '0'],                                                                                                     
{ PARAMETER 5                                                                                                 
    [[1, 0, clc$keyword_type], [6], [                                                                         
    ['PROCESS_VIRTUAL_ADDRESS        ', clc$nominal_entry, clc$normal_usage_entry, 1],                        
    ['PVA                            ', clc$abbreviation_entry, clc$normal_usage_entry, 1],                   
    ['REAL_MEMORY_ADDRESS            ', clc$nominal_entry, clc$normal_usage_entry, 3],                        
    ['RMA                            ', clc$abbreviation_entry, clc$normal_usage_entry, 3],                   
    ['SVA                            ', clc$abbreviation_entry, clc$normal_usage_entry, 2],                   
    ['SYSTEM_VIRTUAL_ADDRESS         ', clc$nominal_entry, clc$normal_usage_entry, 2]]                        
    ,                                                                                                         
    'process_virtual_address']];                                                                              
                                                                                                              
?? FMT (FORMAT := ON) ??                                                                                      
?? POP ??                                                                                                     
                                                                                                              
    CONST                                                                                                     
      p$address = 1,                                                                                          
      p$byte_count = 2,                                                                                       
      p$exchange = 3,                                                                                         
      p$processor = 4,                                                                                        
      p$address_mode = 5;                                                                                     
                                                                                                              
    VAR                                                                                                       
      pvt: array [1 .. 5] of clt$parameter_value;                                                             
                                                                                                              
    VAR                                                                                                       
      access_data: dut$access_data,                                                                           
      address: dut$ee_address_parameter,                                                                      
      byte_count: 0 .. 0ffff(16),                                                                             
      bytes_returned: ost$segment_length,                                                                     
      data_array_p: ^array [ * ] of 0 .. 0ff(16),                                                             
      data_p: ^string ( * ),                                                                                  
      data_seq_p: ^SEQ ( * ),                                                                                 
      default_list: array [1 .. 3] of dut$default_change_list_entry,                                          
      exchange_package_p: ^dut$exchange_package,                                                              
      memory_file_array_p: ^array [ * ] of 0 .. 0ff(16),                                                      
      memory_p: ^cell,                                                                                        
      new_byte_size: ost$segment_length,                                                                      
      processor: 0 .. duc$de_maximum_processors,                                                              
      skip_data_p: ^SEQ ( * );                                                                                
                                                                                                              
    status.normal := TRUE;                                                                                    
                                                                                                              
    { Change the default value for the EXCHANGE, PROCESSOR and ADDRESS_MODE parameters.                       
                                                                                                              
    default_list [1].default_name := duc$dp_exchange;                                                         
    default_list [1].number := p$exchange;                                                                    
    default_list [2].default_name := duc$dp_processor;                                                        
    default_list [2].number := p$processor;                                                                   
    default_list [3].default_name := duc$dp_address_mode;                                                     
    default_list [3].number := p$address_mode;                                                                
    dup$evaluate_parameters (parameter_list, default_list, #SEQ (pdt), ^pvt, status);                         
    IF NOT status.normal THEN                                                                                 
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    IF duv$dump_environment_p = NIL THEN                                                                      
      osp$set_status_abnormal (duc$dump_analyzer_id, due$no_restart_file, '', status);                        
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    address.rma_part := pvt [p$address].value^.integer_value.value;                                           
    processor := pvt [p$processor].value^.integer_value.value;                                                
    byte_count := pvt [p$byte_count].value^.integer_value.value;                                              
                                                                                                              
    IF byte_count = 0 THEN                                                                                    
      clp$make_string_value ('', work_area_p, result_p);                                                      
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    PUSH data_seq_p: [[REP byte_count OF char]];                                                              
    RESET data_seq_p;                                                                                         
    IF data_seq_p = NIL THEN                                                                                  
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                            
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
    NEXT data_p: [byte_count] IN data_seq_p;                                                                  
    IF data_p = NIL THEN                                                                                      
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                            
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
    data_p^ := ' ';                                                                                           
    RESET data_seq_p;                                                                                         
                                                                                                              
    IF pvt [p$address_mode].value^.keyword_value = 'PROCESS_VIRTUAL_ADDRESS' THEN                             
      dup$retrieve_exchange_package (processor, pvt [p$exchange].value^, exchange_package_p, status);         
      IF NOT status.normal THEN                                                                               
        RETURN; {---->                                                                                        
      IFEND;                                                                                                  
      dup$copy_virtual_memory_pva (address.pva_part, exchange_package_p^, processor, byte_count, TRUE,        
            bytes_returned, data_seq_p, access_data, status);                                                 
      IF NOT status.normal AND (status.condition <> due$memory_partially_avail) THEN                          
        RETURN; {---->                                                                                        
      IFEND;                                                                                                  
      IF access_data.page_fault AND NOT access_data.memory_found THEN                                         
        osp$set_status_abnormal (duc$dump_analyzer_id, due$page_fault_error_severity, '', status);            
        osp$append_status_parameter (osc$status_parameter_delimiter, ', segment = ', status);                 
        osp$append_status_integer (osc$status_parameter_delimiter, address.pva_part.seg, 16, TRUE, status);   
        osp$append_status_parameter (osc$status_parameter_delimiter, ', offset = ', status);                  
        osp$append_status_integer (osc$status_parameter_delimiter, access_data.page_fault_offset, 16, TRUE,   
              status);                                                                                        
        RETURN; {---->                                                                                        
      IFEND;                                                                                                  
                                                                                                              
    ELSEIF pvt [p$address_mode].value^.keyword_value = 'SYSTEM_VIRTUAL_ADDRESS' THEN                          
      dup$copy_virtual_memory_sva (address.sva_part, processor, byte_count, TRUE, bytes_returned, data_seq_p, 
            access_data, status);                                                                             
      IF NOT status.normal AND (status.condition <> due$memory_partially_avail) THEN                          
        RETURN; {---->                                                                                        
      IFEND;                                                                                                  
      IF access_data.page_fault AND NOT access_data.memory_found THEN                                         
        osp$set_status_abnormal (duc$dump_analyzer_id, due$page_fault_error_severity, '', status);            
        osp$append_status_parameter (osc$status_parameter_delimiter, ', asid = ', status);                    
        osp$append_status_integer (osc$status_parameter_delimiter, address.sva_part.asid.value, 16, TRUE,     
              status);                                                                                        
        osp$append_status_parameter (osc$status_parameter_delimiter, ', offset = ', status);                  
        osp$append_status_integer (osc$status_parameter_delimiter, access_data.page_fault_offset, 16, TRUE,   
              status);                                                                                        
        RETURN; {---->                                                                                        
      IFEND;                                                                                                  
                                                                                                              
    ELSE { pvt [p$address_mode].value^.keyword_value = 'REAL_MEMORY_ADDRESS' }                                
      dup$access_real_memory (byte_count, address.rma_part, memory_p, new_byte_size, status);                 
      IF NOT status.normal AND (status.condition <> due$memory_partially_avail) THEN                          
        RETURN; {---->                                                                                        
      IFEND;                                                                                                  
      RESET duv$execution_environment.memory_file_p^.segment_pointer.sequence_pointer TO memory_p;            
      NEXT memory_file_array_p: [1 .. new_byte_size] IN duv$execution_environment.memory_file_p^.             
            segment_pointer.sequence_pointer;                                                                 
      IF memory_file_array_p = NIL THEN                                                                       
        osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                          
        RETURN; {---->                                                                                        
      IFEND;                                                                                                  
      NEXT data_array_p: [1 .. new_byte_size] IN data_seq_p;                                                  
      IF data_array_p = NIL THEN                                                                              
        osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                          
        RETURN; {---->                                                                                        
      IFEND;                                                                                                  
      data_array_p^ := memory_file_array_p^;                                                                  
    IFEND;                                                                                                    
                                                                                                              
    clp$make_string_value (data_p^, work_area_p, result_p);                                                   
                                                                                                              
  PROCEND dup$$memory_string;                                                                                 
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'dup$$pp_available', EJECT ??                                                                  
                                                                                                              
{ PURPOSE:                                                                                                    
{   This function returns a boolean of TRUE if the specified pp is available in the dump.                     
                                                                                                              
  PROCEDURE [XDCL] dup$$pp_available                                                                          
    (    parameter_list: clt$parameter_list;                                                                  
     VAR work_area_p: ^clt$work_area;                                                                         
     VAR result_p: ^clt$data_value;                                                                           
     VAR status: ost$status);                                                                                 
                                                                                                              
{ FUNCTION $pp_available, $ppa (                                                                              
{   pp_number: integer 0..25 = $required                                                                      
{   pp_type: key of                                                                                           
{       (normal n) (concurrent_input_output cio c)                                                            
{     keyend = concurrent_input_output                                                                        
{   iou: integer 0..1 = 0                                                                                     
{   )                                                                                                         
                                                                                                              
?? PUSH (LISTEXT := ON) ??                                                                                    
?? FMT (FORMAT := OFF) ??                                                                                     
  VAR                                                                                                         
    pdt: [STATIC, READ, cls$declaration_section] record                                                       
      header: clt$pdt_header,                                                                                 
      names: array [1 .. 3] of clt$pdt_parameter_name,                                                        
      parameters: array [1 .. 3] of clt$pdt_parameter,                                                        
      type1: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
      recend,                                                                                                 
      type2: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$keyword_type_qualifier,                                                                
        keyword_specs: array [1 .. 6] of clt$keyword_specification,                                           
        default_value: string (23),                                                                           
      recend,                                                                                                 
      type3: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
        default_value: string (1),                                                                            
      recend,                                                                                                 
    recend := [                                                                                               
    [1,                                                                                                       
    [89, 6, 14, 10, 36, 47, 99],                                                                              
    clc$function, 3, 3, 1, 0, 0, 0, 0, ''], [                                                                 
    ['IOU                            ',clc$nominal_entry, 3],                                                 
    ['PP_NUMBER                      ',clc$nominal_entry, 1],                                                 
    ['PP_TYPE                        ',clc$nominal_entry, 2]],                                                
    [                                                                                                         
{ PARAMETER 1                                                                                                 
    [2, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$required_parameter, 
  0, 0],                                                                                                      
{ PARAMETER 2                                                                                                 
    [3, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 229,                        
  clc$optional_default_parameter, 0, 23],                                                                     
{ PARAMETER 3                                                                                                 
    [1, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20,                         
  clc$optional_default_parameter, 0, 1]],                                                                     
{ PARAMETER 1                                                                                                 
    [[1, 0, clc$integer_type], [0, 25, 10]],                                                                  
{ PARAMETER 2                                                                                                 
    [[1, 0, clc$keyword_type], [6], [                                                                         
    ['C                              ', clc$abbreviation_entry, clc$normal_usage_entry, 3],                   
    ['CIO                            ', clc$alias_entry, clc$normal_usage_entry, 3],                          
    ['CONCURRENT_INPUT_OUTPUT        ', clc$nominal_entry, clc$normal_usage_entry, 3],                        
    ['N                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],                   
    ['NORMAL                         ', clc$nominal_entry, clc$normal_usage_entry, 2],                        
    ['OF                             ', clc$nominal_entry, clc$normal_usage_entry, 1]]                        
    ,                                                                                                         
    'concurrent_input_output'],                                                                               
{ PARAMETER 3                                                                                                 
    [[1, 0, clc$integer_type], [0, 1, 10],                                                                    
    '0']];                                                                                                    
?? FMT (FORMAT := ON) ??                                                                                      
?? POP ??                                                                                                     
                                                                                                              
    CONST                                                                                                     
      p$pp_number = 1,                                                                                        
      p$pp_type = 2,                                                                                          
      p$iou = 3;                                                                                              
                                                                                                              
    VAR                                                                                                       
      pvt: array [1 .. 3] of clt$parameter_value;                                                             
                                                                                                              
    VAR                                                                                                       
      default_list: array [1 .. 2] of dut$default_change_list_entry,                                          
      iou: 0 .. duc$de_maximum_ious,                                                                          
      pp_exists: boolean,                                                                                     
      pp_number: 0 .. duc$de_max_pp_memories;                                                                 
                                                                                                              
    status.normal := TRUE;                                                                                    
                                                                                                              
    { Change the default value for the PP_TYPE and IOU parameters.                                            
                                                                                                              
    default_list [1].default_name := duc$dp_pp_type;                                                          
    default_list [1].number := p$pp_type;                                                                     
    default_list [2].default_name := duc$dp_iou;                                                              
    default_list [2].number := p$iou;                                                                         
    dup$evaluate_parameters (parameter_list, default_list, #SEQ (pdt), ^pvt, status);                         
    IF NOT status.normal THEN                                                                                 
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    IF duv$dump_environment_p = NIL THEN                                                                      
      osp$set_status_abnormal (duc$dump_analyzer_id, due$no_restart_file, '', status);                        
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    pp_number := pvt [p$pp_number].value^.integer_value.value;                                                
    iou := pvt [p$iou].value^.integer_value.value;                                                            
                                                                                                              
    IF pvt [p$pp_type].value^.keyword_value = 'NORMAL' THEN                                                   
      pp_exists := duv$dump_environment_p^.iou_memory [iou].nio_pp [pp_number].available;                     
    ELSE                                                                                                      
      pp_exists := duv$dump_environment_p^.iou_memory [iou].cio_pp [pp_number].available;                     
    IFEND;                                                                                                    
                                                                                                              
    clp$make_boolean_value (pp_exists, clc$true_false_boolean, work_area_p, result_p);                        
                                                                                                              
  PROCEND dup$$pp_available;                                                                                  
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'dup$$pp_memory', EJECT ??                                                                     
                                                                                                              
{ PURPOSE:                                                                                                    
{   This function returns the contents of the PP memory address specified as an integer.                      
                                                                                                              
  PROCEDURE [XDCL] dup$$pp_memory                                                                             
    (    parameter_list: clt$parameter_list;                                                                  
     VAR work_area_p: ^clt$work_area;                                                                         
     VAR result_p: ^clt$data_value;                                                                           
     VAR status: ost$status);                                                                                 
                                                                                                              
{ FUNCTION $pp_memory, $pm (                                                                                  
{   pp_number: integer 0..25 = $required                                                                      
{   address: integer 0..16383 = $required                                                                     
{   pp_type: key                                                                                              
{       (normal n) (concurrent_input_output cio c)                                                            
{     keyend = concurrent_input_output                                                                        
{   iou: integer 0..1 = 0                                                                                     
{   )                                                                                                         
                                                                                                              
?? PUSH (LISTEXT := ON) ??                                                                                    
?? FMT (FORMAT := OFF) ??                                                                                     
  VAR                                                                                                         
    pdt: [STATIC, READ, cls$declaration_section] record                                                       
      header: clt$pdt_header,                                                                                 
      names: array [1 .. 4] of clt$pdt_parameter_name,                                                        
      parameters: array [1 .. 4] of clt$pdt_parameter,                                                        
      type1: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
      recend,                                                                                                 
      type2: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
      recend,                                                                                                 
      type3: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$keyword_type_qualifier,                                                                
        keyword_specs: array [1 .. 5] of clt$keyword_specification,                                           
        default_value: string (23),                                                                           
      recend,                                                                                                 
      type4: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
        default_value: string (1),                                                                            
      recend,                                                                                                 
    recend := [                                                                                               
    [1,                                                                                                       
    [89, 6, 16, 7, 5, 41, 942],                                                                               
    clc$function, 4, 4, 2, 0, 0, 0, 0, ''], [                                                                 
    ['ADDRESS                        ',clc$nominal_entry, 2],                                                 
    ['IOU                            ',clc$nominal_entry, 4],                                                 
    ['PP_NUMBER                      ',clc$nominal_entry, 1],                                                 
    ['PP_TYPE                        ',clc$nominal_entry, 3]],                                                
    [                                                                                                         
{ PARAMETER 1                                                                                                 
    [3, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$required_parameter, 
  0, 0],                                                                                                      
{ PARAMETER 2                                                                                                 
    [1, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$required_parameter, 
  0, 0],                                                                                                      
{ PARAMETER 3                                                                                                 
    [4, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 192,                        
  clc$optional_default_parameter, 0, 23],                                                                     
{ PARAMETER 4                                                                                                 
    [2, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20,                         
  clc$optional_default_parameter, 0, 1]],                                                                     
{ PARAMETER 1                                                                                                 
    [[1, 0, clc$integer_type], [0, 25, 10]],                                                                  
{ PARAMETER 2                                                                                                 
    [[1, 0, clc$integer_type], [0, 16383, 10]],                                                               
{ PARAMETER 3                                                                                                 
    [[1, 0, clc$keyword_type], [5], [                                                                         
    ['C                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],                   
    ['CIO                            ', clc$alias_entry, clc$normal_usage_entry, 2],                          
    ['CONCURRENT_INPUT_OUTPUT        ', clc$nominal_entry, clc$normal_usage_entry, 2],                        
    ['N                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],                   
    ['NORMAL                         ', clc$nominal_entry, clc$normal_usage_entry, 1]]                        
    ,                                                                                                         
    'concurrent_input_output'],                                                                               
{ PARAMETER 4                                                                                                 
    [[1, 0, clc$integer_type], [0, 1, 10],                                                                    
    '0']];                                                                                                    
?? FMT (FORMAT := ON) ??                                                                                      
?? POP ??                                                                                                     
                                                                                                              
    CONST                                                                                                     
      p$pp_number = 1,                                                                                        
      p$address = 2,                                                                                          
      p$pp_type = 3,                                                                                          
      p$iou = 4;                                                                                              
                                                                                                              
    VAR                                                                                                       
      pvt: array [1 .. 4] of clt$parameter_value;                                                             
                                                                                                              
    VAR                                                                                                       
      address: 0 .. 16383,                                                                                    
      cell_p: ^cell,                                                                                          
      default_list: array [1 .. 2] of dut$default_change_list_entry,                                          
      dump_information: dut$dump_information,                                                                 
      iou: 0 .. duc$de_maximum_ious,                                                                          
      pp_memory_array_p: ^array [0 .. * ] of 0 .. 0ffff(16),                                                  
      pp_number: 0 .. duc$de_max_pp_memories,                                                                 
      restart_file_seq_p: ^SEQ ( * );                                                                         
                                                                                                              
    status.normal := TRUE;                                                                                    
                                                                                                              
    { Change the default value for the PP_TYPE and IOU parameters.                                            
                                                                                                              
    default_list [1].default_name := duc$dp_pp_type;                                                          
    default_list [1].number := p$pp_type;                                                                     
    default_list [2].default_name := duc$dp_iou;                                                              
    default_list [2].number := p$iou;                                                                         
    dup$evaluate_parameters (parameter_list, default_list, #SEQ (pdt), ^pvt, status);                         
    IF NOT status.normal THEN                                                                                 
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    IF duv$dump_environment_p = NIL THEN                                                                      
      osp$set_status_abnormal (duc$dump_analyzer_id, due$no_restart_file, '', status);                        
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    pp_number := pvt [p$pp_number].value^.integer_value.value;                                                
    iou := pvt [p$iou].value^.integer_value.value;                                                            
    dup$determine_dump_information (dump_information);                                                        
                                                                                                              
  /determine_pp_availability/                                                                                 
    BEGIN                                                                                                     
      IF pvt [p$pp_type].value^.keyword_value = 'NORMAL' THEN                                                 
        IF duv$dump_environment_p^.iou_memory [iou].nio_pp [pp_number].available THEN                         
          EXIT /determine_pp_availability/; {---->                                                            
        IFEND;                                                                                                
      ELSEIF (pp_number <= duc$de_max_cio_pp_memories) AND duv$dump_environment_p^.iou_memory [iou].          
            cio_pp [pp_number].available THEN                                                                 
        EXIT /determine_pp_availability/; {---->                                                              
      IFEND;                                                                                                  
      osp$set_status_abnormal (duc$dump_analyzer_id, due$data_not_on_dump, 'The peripheral processor',        
            status);                                                                                          
      osp$append_status_integer (osc$status_parameter_delimiter, pp_number, 8, TRUE, status);                 
      osp$append_status_parameter (osc$status_parameter_delimiter, 'is', status);                             
      RETURN; {---->                                                                                          
    END /determine_pp_availability/;                                                                          
                                                                                                              
    address := pvt [p$address].value^.integer_value.value;                                                    
    IF address > dump_information.iou [iou].pp_word_size THEN                                                 
      osp$set_status_abnormal (duc$dump_analyzer_id, due$invalid_address, '', status);                        
      osp$append_status_integer (osc$status_parameter_delimiter, address, 16, TRUE, status);                  
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    restart_file_seq_p := duv$execution_environment.data_file_p^.segment_pointer.sequence_pointer;            
    IF pvt [p$pp_type].value^.keyword_value = 'NORMAL' THEN                                                   
      cell_p := #ADDRESS (#RING (restart_file_seq_p), #SEGMENT (restart_file_seq_p),                          
            duv$dump_environment_p^.iou_memory [iou].nio_pp [pp_number].first_byte);                          
    ELSE                                                                                                      
      cell_p := #ADDRESS (#RING (restart_file_seq_p), #SEGMENT (restart_file_seq_p),                          
            duv$dump_environment_p^.iou_memory [iou].cio_pp [pp_number].first_byte);                          
    IFEND;                                                                                                    
    RESET restart_file_seq_p TO cell_p;                                                                       
                                                                                                              
    NEXT pp_memory_array_p: [0 .. address] IN restart_file_seq_p;                                             
    IF pp_memory_array_p = NIL THEN                                                                           
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                            
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    IF pvt [p$address].value^.integer_value.radix_specified THEN                                              
      clp$make_integer_value (pp_memory_array_p^ [address], pvt [p$address].                                  
            value^.integer_value.radix, TRUE, work_area_p, result_p);                                         
    ELSE                                                                                                      
      clp$make_integer_value (pp_memory_array_p^ [address], 16, TRUE, work_area_p, result_p);                 
    IFEND;                                                                                                    
                                                                                                              
  PROCEND dup$$pp_memory;                                                                                     
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'dup$$process_register', EJECT ??                                                              
                                                                                                              
{ PURPOSE:                                                                                                    
{   This procedure returns the contents of the specified register as an integer.                              
                                                                                                              
  PROCEDURE [XDCL] dup$$process_register                                                                      
    (    parameter_list: clt$parameter_list;                                                                  
     VAR work_area_p: ^clt$work_area;                                                                         
     VAR result_p: ^clt$data_value;                                                                           
     VAR status: ost$status);                                                                                 
                                                                                                              
{ FUNCTION $process_register, $pr (                                                                           
{   register: key                                                                                             
{       (p) (a) (x) (monitor_condition_register mcr) (user_condition_register ucr) (segment_table_address sta)
{       (top_of_stack tos) (base_constant bc)                                                                 
{     keyend = $required                                                                                      
{   register_number: integer 0..15 = 0                                                                        
{   exchange: any of                                                                                          
{       key                                                                                                   
{         (active a) (monitor m) (job j)                                                                      
{       keyend                                                                                                
{       integer 0..0ffffffff(16)                                                                              
{     anyend = 0ffffffff(16)                                                                                  
{   processor: integer 0..3 = 0                                                                               
{   )                                                                                                         
                                                                                                              
?? PUSH (LISTEXT := ON) ??                                                                                    
?? FMT (FORMAT := OFF) ??                                                                                     
  VAR                                                                                                         
    pdt: [STATIC, READ, cls$declaration_section] record                                                       
      header: clt$pdt_header,                                                                                 
      names: array [1 .. 4] of clt$pdt_parameter_name,                                                        
      parameters: array [1 .. 4] of clt$pdt_parameter,                                                        
      type1: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$keyword_type_qualifier,                                                                
        keyword_specs: array [1 .. 13] of clt$keyword_specification,                                          
      recend,                                                                                                 
      type2: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
        default_value: string (1),                                                                            
      recend,                                                                                                 
      type3: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$union_type_qualifier,                                                                  
        type_size_1: clt$type_specification_size,                                                             
        element_type_spec_1: record                                                                           
          header: clt$type_specification_header,                                                              
          qualifier: clt$keyword_type_qualifier,                                                              
          keyword_specs: array [1 .. 6] of clt$keyword_specification,                                         
        recend,                                                                                               
        type_size_2: clt$type_specification_size,                                                             
        element_type_spec_2: record                                                                           
          header: clt$type_specification_header,                                                              
          qualifier: clt$integer_type_qualifier,                                                              
        recend,                                                                                               
        default_value: string (13),                                                                           
      recend,                                                                                                 
      type4: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
        default_value: string (1),                                                                            
      recend,                                                                                                 
    recend := [                                                                                               
    [1,                                                                                                       
    [89, 7, 12, 14, 6, 15, 261],                                                                              
    clc$function, 4, 4, 1, 0, 0, 0, 0, ''], [                                                                 
    ['EXCHANGE                       ',clc$nominal_entry, 3],                                                 
    ['PROCESSOR                      ',clc$nominal_entry, 4],                                                 
    ['REGISTER                       ',clc$nominal_entry, 1],                                                 
    ['REGISTER_NUMBER                ',clc$nominal_entry, 2]],                                                
    [                                                                                                         
{ PARAMETER 1                                                                                                 
    [3, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 488,                        
  clc$required_parameter, 0, 0],                                                                              
{ PARAMETER 2                                                                                                 
    [4, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20,                         
  clc$optional_default_parameter, 0, 1],                                                                      
{ PARAMETER 3                                                                                                 
    [1, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 269,                        
  clc$optional_default_parameter, 0, 13],                                                                     
{ PARAMETER 4                                                                                                 
    [2, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20,                         
  clc$optional_default_parameter, 0, 1]],                                                                     
{ PARAMETER 1                                                                                                 
    [[1, 0, clc$keyword_type], [13], [                                                                        
    ['A                              ', clc$nominal_entry, clc$normal_usage_entry, 2],                        
    ['BASE_CONSTANT                  ', clc$nominal_entry, clc$normal_usage_entry, 8],                        
    ['BC                             ', clc$abbreviation_entry, clc$normal_usage_entry, 8],                   
    ['MCR                            ', clc$abbreviation_entry, clc$normal_usage_entry, 4],                   
    ['MONITOR_CONDITION_REGISTER     ', clc$nominal_entry, clc$normal_usage_entry, 4],                        
    ['P                              ', clc$nominal_entry, clc$normal_usage_entry, 1],                        
    ['SEGMENT_TABLE_ADDRESS          ', clc$nominal_entry, clc$normal_usage_entry, 6],                        
    ['STA                            ', clc$abbreviation_entry, clc$normal_usage_entry, 6],                   
    ['TOP_OF_STACK                   ', clc$nominal_entry, clc$normal_usage_entry, 7],                        
    ['TOS                            ', clc$abbreviation_entry, clc$normal_usage_entry, 7],                   
    ['UCR                            ', clc$abbreviation_entry, clc$normal_usage_entry, 5],                   
    ['USER_CONDITION_REGISTER        ', clc$nominal_entry, clc$normal_usage_entry, 5],                        
    ['X                              ', clc$nominal_entry, clc$normal_usage_entry, 3]]                        
    ],                                                                                                        
{ PARAMETER 2                                                                                                 
    [[1, 0, clc$integer_type], [0, 15, 10],                                                                   
    '0'],                                                                                                     
{ PARAMETER 3                                                                                                 
    [[1, 0, clc$union_type], [[clc$integer_type, clc$keyword_type],                                           
    FALSE, 2],                                                                                                
    229, [[1, 0, clc$keyword_type], [6], [                                                                    
      ['A                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],                 
      ['ACTIVE                         ', clc$nominal_entry, clc$normal_usage_entry, 1],                      
      ['J                              ', clc$abbreviation_entry, clc$normal_usage_entry, 3],                 
      ['JOB                            ', clc$nominal_entry, clc$normal_usage_entry, 3],                      
      ['M                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],                 
      ['MONITOR                        ', clc$nominal_entry, clc$normal_usage_entry, 2]]                      
      ],                                                                                                      
    20, [[1, 0, clc$integer_type], [0, 0ffffffff(16), 10]]                                                    
    ,                                                                                                         
    '0ffffffff(16)'],                                                                                         
{ PARAMETER 4                                                                                                 
    [[1, 0, clc$integer_type], [0, 3, 10],                                                                    
    '0']];                                                                                                    
?? FMT (FORMAT := ON) ??                                                                                      
?? POP ??                                                                                                     
                                                                                                              
    CONST                                                                                                     
      p$register = 1,                                                                                         
      p$register_number = 2,                                                                                  
      p$exchange = 3,                                                                                         
      p$processor = 4;                                                                                        
                                                                                                              
    VAR                                                                                                       
      pvt: array [1 .. 4] of clt$parameter_value;                                                             
                                                                                                              
    VAR                                                                                                       
      address: dut$ee_address_parameter,                                                                      
      cell_p: ^cell,                                                                                          
      default_list: array [1 .. 2] of dut$default_change_list_entry,                                          
      exchange_package_p: ^dut$exchange_package,                                                              
      processor: 0 .. duc$de_maximum_processors,                                                              
      register_number: 0 .. 15,                                                                               
      xp_p: ^dut$ee_xp;                                                                                       
                                                                                                              
    status.normal := TRUE;                                                                                    
                                                                                                              
    { Change the default value for the EXCHANGE and PROCESSOR parameters.                                     
                                                                                                              
    default_list [1].default_name := duc$dp_exchange;                                                         
    default_list [1].number := p$exchange;                                                                    
    default_list [2].default_name := duc$dp_processor;                                                        
    default_list [2].number := p$processor;                                                                   
    dup$evaluate_parameters (parameter_list, default_list, #SEQ (pdt), ^pvt, status);                         
    IF NOT status.normal THEN                                                                                 
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    IF duv$dump_environment_p = NIL THEN                                                                      
      osp$set_status_abnormal (duc$dump_analyzer_id, due$no_restart_file, '', status);                        
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    processor := pvt [p$processor].value^.integer_value.value;                                                
    register_number := pvt [p$register_number].value^.integer_value.value;                                    
                                                                                                              
    dup$retrieve_exchange_package (processor, pvt [p$exchange].value^, exchange_package_p, status);           
    IF NOT status.normal THEN                                                                                 
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    cell_p := exchange_package_p;                                                                             
    xp_p := cell_p;                                                                                           
                                                                                                              
    address.rma_part := 0;                                                                                    
    IF pvt [p$register].value^.keyword_value = 'P' THEN                                                       
      address.pva_part := xp_p^.p_register.pva;                                                               
    ELSEIF pvt [p$register].value^.keyword_value = 'A' THEN                                                   
      address.pva_part := xp_p^.data.a_regs [register_number].pva;                                            
    ELSEIF pvt [p$register].value^.keyword_value = 'X' THEN                                                   
      address.rma_part := xp_p^.data.x_regs [register_number].int;                                            
    ELSEIF pvt [p$register].value^.keyword_value = 'MONITOR_CONDITION_REGISTER' THEN                          
      address.quarter_part_4 := xp_p^.data.a_regs [5].two_bytes;                                              
    ELSEIF pvt [p$register].value^.keyword_value = 'USER_CONDITION_REGISTER' THEN                             
      address.quarter_part_4 := xp_p^.data.a_regs [4].two_bytes;                                              
    ELSEIF pvt [p$register].value^.keyword_value = 'SEGMENT_TABLE_ADDRESS' THEN                               
      address.quarter_part_3 := xp_p^.data.sta1.two_bytes;                                                    
      address.quarter_part_4 := xp_p^.data.sta2.two_bytes;                                                    
    ELSEIF pvt [p$register].value^.keyword_value = 'TOP_OF_STACK' THEN                                        
      address.pva_part := xp_p^.tos_registers [register_number].pva;                                          
    ELSE { pvt [p$register].value^.keyword_value = 'BASE_CONSTANT' }                                          
      address.quarter_part_3 := xp_p^.data.a_regs [0c(16)].two_bytes;                                         
      address.quarter_part_4 := xp_p^.data.a_regs [0d(16)].two_bytes;                                         
    IFEND;                                                                                                    
                                                                                                              
    clp$make_integer_value (address.rma_part, 16, TRUE, work_area_p, result_p);                               
                                                                                                              
  PROCEND dup$$process_register;                                                                              
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'dup$$real_memory_address', EJECT ??                                                           
                                                                                                              
{ PURPOSE:                                                                                                    
{   This procedure returns the RMA of the specified address as an integer.                                    
                                                                                                              
  PROCEDURE [XDCL] dup$$real_memory_address                                                                   
    (    parameter_list: clt$parameter_list;                                                                  
     VAR work_area_p: ^clt$work_area;                                                                         
     VAR result_p: ^clt$data_value;                                                                           
     VAR status: ost$status);                                                                                 
                                                                                                              
{ FUNCTION $real_memory_address, $rma (                                                                       
{   address: integer 0..0ffffffffffff(16) = $required                                                         
{   exchange: any of                                                                                          
{       key                                                                                                   
{         (active a) (monitor m) (job j)                                                                      
{       keyend                                                                                                
{       integer 0..0ffffffff(16)                                                                              
{     anyend = 0ffffffff(16)                                                                                  
{   processor: integer 0..3 = 0                                                                               
{   address_mode: key                                                                                         
{       (process_virtual_address pva) (system_virtual_address sva) (real_memory_address rma)                  
{     keyend = process_virtual_address                                                                        
{   )                                                                                                         
                                                                                                              
?? PUSH (LISTEXT := ON) ??                                                                                    
?? FMT (FORMAT := OFF) ??                                                                                     
  VAR                                                                                                         
    pdt: [STATIC, READ, cls$declaration_section] record                                                       
      header: clt$pdt_header,                                                                                 
      names: array [1 .. 4] of clt$pdt_parameter_name,                                                        
      parameters: array [1 .. 4] of clt$pdt_parameter,                                                        
      type1: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
      recend,                                                                                                 
      type2: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$union_type_qualifier,                                                                  
        type_size_1: clt$type_specification_size,                                                             
        element_type_spec_1: record                                                                           
          header: clt$type_specification_header,                                                              
          qualifier: clt$keyword_type_qualifier,                                                              
          keyword_specs: array [1 .. 6] of clt$keyword_specification,                                         
        recend,                                                                                               
        type_size_2: clt$type_specification_size,                                                             
        element_type_spec_2: record                                                                           
          header: clt$type_specification_header,                                                              
          qualifier: clt$integer_type_qualifier,                                                              
        recend,                                                                                               
        default_value: string (13),                                                                           
      recend,                                                                                                 
      type3: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
        default_value: string (1),                                                                            
      recend,                                                                                                 
      type4: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$keyword_type_qualifier,                                                                
        keyword_specs: array [1 .. 6] of clt$keyword_specification,                                           
        default_value: string (23),                                                                           
      recend,                                                                                                 
    recend := [                                                                                               
    [1,                                                                                                       
    [89, 6, 14, 10, 38, 44, 440],                                                                             
    clc$function, 4, 4, 1, 0, 0, 0, 0, ''], [                                                                 
    ['ADDRESS                        ',clc$nominal_entry, 1],                                                 
    ['ADDRESS_MODE                   ',clc$nominal_entry, 4],                                                 
    ['EXCHANGE                       ',clc$nominal_entry, 2],                                                 
    ['PROCESSOR                      ',clc$nominal_entry, 3]],                                                
    [                                                                                                         
{ PARAMETER 1                                                                                                 
    [1, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$required_parameter, 
  0, 0],                                                                                                      
{ PARAMETER 2                                                                                                 
    [3, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 269,                        
  clc$optional_default_parameter, 0, 13],                                                                     
{ PARAMETER 3                                                                                                 
    [4, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20,                         
  clc$optional_default_parameter, 0, 1],                                                                      
{ PARAMETER 4                                                                                                 
    [2, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 229,                        
  clc$optional_default_parameter, 0, 23]],                                                                    
{ PARAMETER 1                                                                                                 
    [[1, 0, clc$integer_type], [0, 0ffffffffffff(16), 10]],                                                   
{ PARAMETER 2                                                                                                 
    [[1, 0, clc$union_type], [[clc$integer_type, clc$keyword_type],                                           
    FALSE, 2],                                                                                                
    229, [[1, 0, clc$keyword_type], [6], [                                                                    
      ['A                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],                 
      ['ACTIVE                         ', clc$nominal_entry, clc$normal_usage_entry, 1],                      
      ['J                              ', clc$abbreviation_entry, clc$normal_usage_entry, 3],                 
      ['JOB                            ', clc$nominal_entry, clc$normal_usage_entry, 3],                      
      ['M                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],                 
      ['MONITOR                        ', clc$nominal_entry, clc$normal_usage_entry, 2]]                      
      ],                                                                                                      
    20, [[1, 0, clc$integer_type], [0, 0ffffffff(16), 10]]                                                    
    ,                                                                                                         
    '0ffffffff(16)'],                                                                                         
{ PARAMETER 3                                                                                                 
    [[1, 0, clc$integer_type], [0, 3, 10],                                                                    
    '0'],                                                                                                     
{ PARAMETER 4                                                                                                 
    [[1, 0, clc$keyword_type], [6], [                                                                         
    ['PROCESS_VIRTUAL_ADDRESS        ', clc$nominal_entry, clc$normal_usage_entry, 1],                        
    ['PVA                            ', clc$abbreviation_entry, clc$normal_usage_entry, 1],                   
    ['REAL_MEMORY_ADDRESS            ', clc$nominal_entry, clc$normal_usage_entry, 3],                        
    ['RMA                            ', clc$abbreviation_entry, clc$normal_usage_entry, 3],                   
    ['SVA                            ', clc$abbreviation_entry, clc$normal_usage_entry, 2],                   
    ['SYSTEM_VIRTUAL_ADDRESS         ', clc$nominal_entry, clc$normal_usage_entry, 2]]                        
    ,                                                                                                         
    'process_virtual_address']];                                                                              
?? FMT (FORMAT := ON) ??                                                                                      
?? POP ??                                                                                                     
                                                                                                              
    CONST                                                                                                     
      p$address = 1,                                                                                          
      p$exchange = 2,                                                                                         
      p$processor = 3,                                                                                        
      p$address_mode = 4;                                                                                     
                                                                                                              
    VAR                                                                                                       
      pvt: array [1 .. 4] of clt$parameter_value;                                                             
                                                                                                              
    VAR                                                                                                       
      access_data: dut$access_data,                                                                           
      address: dut$ee_address_parameter,                                                                      
      bytes_left: 0 .. 10000(16),                                                                             
      default_list: array [1 .. 3] of dut$default_change_list_entry,                                          
      exchange_package_p: ^dut$exchange_package,                                                              
      memory_p: ^cell,                                                                                        
      new_byte_size: ost$segment_length,                                                                      
      processor: 0 .. duc$de_maximum_processors,                                                              
      rma: ost$real_memory_address;                                                                           
                                                                                                              
    status.normal := TRUE;                                                                                    
                                                                                                              
    { Change the default value for the EXCHANGE, PROCESSOR and ADDRESS_MODE parameters.                       
                                                                                                              
    default_list [1].default_name := duc$dp_exchange;                                                         
    default_list [1].number := p$exchange;                                                                    
    default_list [2].default_name := duc$dp_processor;                                                        
    default_list [2].number := p$processor;                                                                   
    default_list [3].default_name := duc$dp_address_mode;                                                     
    default_list [3].number := p$address_mode;                                                                
    dup$evaluate_parameters (parameter_list, default_list, #SEQ (pdt), ^pvt, status);                         
    IF NOT status.normal THEN                                                                                 
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    IF duv$dump_environment_p = NIL THEN                                                                      
      osp$set_status_abnormal (duc$dump_analyzer_id, due$no_restart_file, '', status);                        
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    address.rma_part := pvt [p$address].value^.integer_value.value;                                           
    processor := pvt [p$processor].value^.integer_value.value;                                                
                                                                                                              
    IF pvt [p$address_mode].value^.keyword_value = 'PROCESS_VIRTUAL_ADDRESS' THEN                             
      dup$retrieve_exchange_package (processor, pvt [p$exchange].value^, exchange_package_p, status);         
      IF NOT status.normal THEN                                                                               
        RETURN; {---->                                                                                        
      IFEND;                                                                                                  
      dup$translate_pva (address.pva_part, exchange_package_p^, processor, rma, bytes_left, access_data,      
            status);                                                                                          
      IF NOT status.normal THEN                                                                               
        RETURN; {---->                                                                                        
      IFEND;                                                                                                  
      IF access_data.page_fault AND NOT access_data.memory_found THEN                                         
        osp$set_status_abnormal (duc$dump_analyzer_id, due$page_fault_error_severity, '', status);            
        osp$append_status_parameter (osc$status_parameter_delimiter, ', segment = ', status);                 
        osp$append_status_integer (osc$status_parameter_delimiter, address.pva_part.seg, 16, TRUE, status);   
        osp$append_status_parameter (osc$status_parameter_delimiter, ', offset = ', status);                  
        osp$append_status_integer (osc$status_parameter_delimiter, access_data.page_fault_offset, 16, TRUE,   
              status);                                                                                        
        RETURN; {---->                                                                                        
      IFEND;                                                                                                  
                                                                                                              
    ELSEIF pvt [p$address_mode].value^.keyword_value = 'SYSTEM_VIRTUAL_ADDRESS' THEN                          
      dup$translate_sva (address.sva_part, processor, rma, bytes_left, access_data, status);                  
      IF NOT status.normal THEN                                                                               
        RETURN; {---->                                                                                        
      IFEND;                                                                                                  
      IF access_data.page_fault AND NOT access_data.memory_found THEN                                         
        osp$set_status_abnormal (duc$dump_analyzer_id, due$page_fault_error_severity, '', status);            
        osp$append_status_parameter (osc$status_parameter_delimiter, ', asid = ', status);                    
        osp$append_status_integer (osc$status_parameter_delimiter, address.sva_part.asid.value, 16, TRUE,     
              status);                                                                                        
        osp$append_status_parameter (osc$status_parameter_delimiter, ', offset = ', status);                  
        osp$append_status_integer (osc$status_parameter_delimiter, access_data.page_fault_offset, 16, TRUE,   
              status);                                                                                        
        RETURN; {---->                                                                                        
      IFEND;                                                                                                  
                                                                                                              
    ELSE { pvt [p$address_mode].value^.keyword_value = 'REAL_MEMORY_ADDRESS'                                  
      dup$access_real_memory (1, address.rma_part, memory_p, new_byte_size, status);                          
      IF NOT status.normal AND (status.condition <> due$memory_partially_avail) THEN                          
        RETURN; {---->                                                                                        
      IFEND;                                                                                                  
      rma := address.rma_part;                                                                                
    IFEND;                                                                                                    
                                                                                                              
    clp$make_integer_value (rma, 16, TRUE, work_area_p, result_p);                                            
                                                                                                              
  PROCEND dup$$real_memory_address;                                                                           
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'dup$$register_file', EJECT ??                                                                 
                                                                                                              
{ PURPOSE:                                                                                                    
{   This function returns the value of a specified register file entry as an integer.                         
                                                                                                              
  PROCEDURE [XDCL] dup$$register_file                                                                         
    (    parameter_list: clt$parameter_list;                                                                  
     VAR work_area_p: ^clt$work_area;                                                                         
     VAR result_p: ^clt$data_value;                                                                           
     VAR status: ost$status);                                                                                 
                                                                                                              
{ FUNCTION $register_file, $rf (                                                                              
{   register_number: integer 0..4095 = $required                                                              
{   processor: integer 0..3 = 0                                                                               
{   )                                                                                                         
                                                                                                              
?? PUSH (LISTEXT := ON) ??                                                                                    
?? FMT (FORMAT := OFF) ??                                                                                     
  VAR                                                                                                         
    pdt: [STATIC, READ, cls$declaration_section] record                                                       
      header: clt$pdt_header,                                                                                 
      names: array [1 .. 2] of clt$pdt_parameter_name,                                                        
      parameters: array [1 .. 2] of clt$pdt_parameter,                                                        
      type1: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
      recend,                                                                                                 
      type2: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
        default_value: string (1),                                                                            
      recend,                                                                                                 
    recend := [                                                                                               
    [1,                                                                                                       
    [89, 6, 12, 11, 55, 40, 666],                                                                             
    clc$function, 2, 2, 1, 0, 0, 0, 0, ''], [                                                                 
    ['PROCESSOR                      ',clc$nominal_entry, 2],                                                 
    ['REGISTER_NUMBER                ',clc$nominal_entry, 1]],                                                
    [                                                                                                         
{ PARAMETER 1                                                                                                 
    [2, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation,                                                              
  clc$standard_parameter_checking, 20, clc$required_parameter, 0, 0],                                         
{ PARAMETER 2                                                                                                 
    [1, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation,                                                              
  clc$standard_parameter_checking, 20, clc$optional_default_parameter, 0, 1]],                                
{ PARAMETER 1                                                                                                 
    [[1, 0, clc$integer_type], [0, 4095, 10]],                                                                
{ PARAMETER 2                                                                                                 
    [[1, 0, clc$integer_type], [0, 3, 10],                                                                    
    '0']];                                                                                                    
?? FMT (FORMAT := ON) ??                                                                                      
?? POP ??                                                                                                     
                                                                                                              
    CONST                                                                                                     
      p$register_number = 1,                                                                                  
      p$processor = 2;                                                                                        
                                                                                                              
    VAR                                                                                                       
      pvt: array [1 .. 2] of clt$parameter_value;                                                             
                                                                                                              
    VAR                                                                                                       
      default_list: array [1 .. 1] of dut$default_change_list_entry,                                          
      display_string: string (osc$max_string_size),                                                           
      processor: 0 .. duc$de_maximum_processors,                                                              
      register_number: 0 .. duc$de_max_register_number,                                                       
      register: integer,                                                                                      
      string_length: integer;                                                                                 
                                                                                                              
    status.normal := TRUE;                                                                                    
                                                                                                              
    { Change the default value for the PROCESSOR parameter.                                                   
                                                                                                              
    default_list [1].default_name := duc$dp_processor;                                                        
    default_list [1].number := p$processor;                                                                   
    dup$evaluate_parameters (parameter_list, default_list, #SEQ (pdt), ^pvt, status);                         
    IF NOT status.normal THEN                                                                                 
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    IF duv$dump_environment_p = NIL THEN                                                                      
      osp$set_status_abnormal (duc$dump_analyzer_id, due$no_restart_file, '', status);                        
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    processor := pvt [p$processor].value^.integer_value.value;                                                
    register_number := pvt [p$register_number].value^.integer_value.value;                                    
                                                                                                              
    IF NOT duv$dump_environment_p^.register_file [processor].available THEN                                   
      osp$set_status_abnormal (duc$dump_analyzer_id, due$data_not_on_dump, 'The register file for processor', 
            status);                                                                                          
      osp$append_status_integer (osc$status_parameter_delimiter, processor, 10, FALSE, status);               
      osp$append_status_parameter (osc$status_parameter_delimiter, 'is', status);                             
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    IF duv$dump_environment_p^.register_file [processor].register [register_number].available THEN            
      register := duv$dump_environment_p^.register_file [processor].register [register_number].value;         
      clp$make_integer_value (register, 16, TRUE, work_area_p, result_p);                                     
    ELSE                                                                                                      
      STRINGREP (display_string, string_length, 'Register file entry', register_number: #(16), '(16) is');    
      osp$set_status_abnormal (duc$dump_analyzer_id, due$data_not_on_dump, display_string (1, string_length), 
            status);                                                                                          
    IFEND;                                                                                                    
                                                                                                              
  PROCEND dup$$register_file;                                                                                 
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'dup$$register_file_string', EJECT ??                                                          
                                                                                                              
{ PURPOSE:                                                                                                    
{   This function returns the value of a specified register file entry as a string.                           
                                                                                                              
  PROCEDURE [XDCL] dup$$register_file_string                                                                  
    (    parameter_list: clt$parameter_list;                                                                  
     VAR work_area_p: ^clt$work_area;                                                                         
     VAR result_p: ^clt$data_value;                                                                           
     VAR status: ost$status);                                                                                 
                                                                                                              
{ FUNCTION $register_file_string, $rfs (                                                                      
{   register_number: integer 0..4095 = $required                                                              
{   processor: integer 0..3 = 0                                                                               
{   )                                                                                                         
                                                                                                              
?? PUSH (LISTEXT := ON) ??                                                                                    
?? FMT (FORMAT := OFF) ??                                                                                     
  VAR                                                                                                         
    pdt: [STATIC, READ, cls$declaration_section] record                                                       
      header: clt$pdt_header,                                                                                 
      names: array [1 .. 2] of clt$pdt_parameter_name,                                                        
      parameters: array [1 .. 2] of clt$pdt_parameter,                                                        
      type1: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
      recend,                                                                                                 
      type2: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
        default_value: string (1),                                                                            
      recend,                                                                                                 
    recend := [                                                                                               
    [1,                                                                                                       
    [89, 6, 12, 11, 49, 7, 783],                                                                              
    clc$function, 2, 2, 1, 0, 0, 0, 0, ''], [                                                                 
    ['PROCESSOR                      ',clc$nominal_entry, 2],                                                 
    ['REGISTER_NUMBER                ',clc$nominal_entry, 1]],                                                
    [                                                                                                         
{ PARAMETER 1                                                                                                 
    [2, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$required_parameter, 
  0, 0],                                                                                                      
{ PARAMETER 2                                                                                                 
    [1, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20,                         
  clc$optional_default_parameter, 0, 1]],                                                                     
{ PARAMETER 1                                                                                                 
    [[1, 0, clc$integer_type], [0, 4095, 10]],                                                                
{ PARAMETER 2                                                                                                 
    [[1, 0, clc$integer_type], [0, 3, 10],                                                                    
    '0']];                                                                                                    
?? FMT (FORMAT := ON) ??                                                                                      
?? POP ??                                                                                                     
                                                                                                              
    CONST                                                                                                     
      p$register_number = 1,                                                                                  
      p$processor = 2;                                                                                        
                                                                                                              
    VAR                                                                                                       
      pvt: array [1 .. 2] of clt$parameter_value;                                                             
                                                                                                              
    VAR                                                                                                       
      default_list: array [1 .. 1] of dut$default_change_list_entry,                                          
      display_string: string (osc$max_string_size),                                                           
      processor: 0 .. duc$de_maximum_processors,                                                              
      register_number: 0 .. duc$de_max_register_number,                                                       
      register: integer,                                                                                      
      string_16: string (16),                                                                                 
      string_length: integer;                                                                                 
                                                                                                              
    status.normal := TRUE;                                                                                    
                                                                                                              
    { Change the default value for the PROCESSOR parameter.                                                   
                                                                                                              
    default_list [1].default_name := duc$dp_processor;                                                        
    default_list [1].number := p$processor;                                                                   
    dup$evaluate_parameters (parameter_list, default_list, #SEQ (pdt), ^pvt, status);                         
    IF NOT status.normal THEN                                                                                 
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    IF duv$dump_environment_p = NIL THEN                                                                      
      osp$set_status_abnormal (duc$dump_analyzer_id, due$no_restart_file, '', status);                        
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    processor := pvt [p$processor].value^.integer_value.value;                                                
    register_number := pvt [p$register_number].value^.integer_value.value;                                    
                                                                                                              
    IF NOT duv$dump_environment_p^.register_file [processor].available THEN                                   
      osp$set_status_abnormal (duc$dump_analyzer_id, due$data_not_on_dump, 'The register file for processor', 
            status);                                                                                          
      osp$append_status_integer (osc$status_parameter_delimiter, processor, 10, FALSE, status);               
      osp$append_status_parameter (osc$status_parameter_delimiter, 'is', status);                             
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    IF duv$dump_environment_p^.register_file [processor].register [register_number].available THEN            
      register := duv$dump_environment_p^.register_file [processor].register [register_number].value;         
      convert_integer_to_hex_string (register, 16, string_16);                                                
      clp$make_string_value (string_16, work_area_p, result_p);                                               
    ELSE                                                                                                      
      STRINGREP (display_string, string_length, 'Register file entry', register_number: #(16), '(16) is');    
      osp$set_status_abnormal (duc$dump_analyzer_id, due$data_not_on_dump, display_string (1, string_length), 
            status);                                                                                          
    IFEND;                                                                                                    
                                                                                                              
  PROCEND dup$$register_file_string;                                                                          
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'dup$$restart_file', EJECT ??                                                                  
                                                                                                              
  PROCEDURE [XDCL] dup$$restart_file                                                                          
    (    parameter_list: clt$parameter_list;                                                                  
     VAR work_area_p: ^clt$work_area;                                                                         
     VAR result_p: ^clt$data_value;                                                                           
     VAR status: ost$status);                                                                                 
                                                                                                              
{ FUNCTION $restart_file, $rf                                                                                 
                                                                                                              
?? PUSH (LISTEXT := ON) ??                                                                                    
?? FMT (FORMAT := OFF) ??                                                                                     
                                                                                                              
  VAR                                                                                                         
    pdt: [STATIC, READ, cls$declaration_section] record                                                       
      header: clt$pdt_header,                                                                                 
    recend := [                                                                                               
    [1,                                                                                                       
    [101, 4, 26, 10, 29, 30, 181],                                                                            
    clc$function, 0, 0, 0, 0, 0, 0, 0, '']];                                                                  
                                                                                                              
?? FMT (FORMAT := ON) ??                                                                                      
?? POP ??                                                                                                     
                                                                                                              
    VAR                                                                                                       
      resolved_file_reference: fst$resolved_file_reference,                                                   
      ignore_user_def_attribute_size: fst$user_defined_attribute_size;                                        
                                                                                                              
    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, NIL, status);                                   
    IF NOT status.normal THEN                                                                                 
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    result_p := f$make_restart_file_value (work_area_p);                                                      
                                                                                                              
  PROCEND dup$$restart_file;                                                                                  
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'dup$$size_buffer_controlware', EJECT ??                                                       
                                                                                                              
{ PURPOSE:                                                                                                    
{   This function returns the size of a channel's buffer controlware as an integer.                           
                                                                                                              
  PROCEDURE [XDCL] dup$$size_buffer_controlware                                                               
    (    parameter_list: clt$parameter_list;                                                                  
     VAR work_area_p: ^clt$work_area;                                                                         
     VAR result_p: ^clt$data_value;                                                                           
     VAR status: ost$status);                                                                                 
                                                                                                              
{ FUNCTION $size_buffer_controlware, $sbc (                                                                   
{   channel_number: integer 0..33 = $required                                                                 
{   )                                                                                                         
                                                                                                              
?? PUSH (LISTEXT := ON) ??                                                                                    
?? FMT (FORMAT := OFF) ??                                                                                     
  VAR                                                                                                         
    pdt: [STATIC, READ, cls$declaration_section] record                                                       
      header: clt$pdt_header,                                                                                 
      names: array [1 .. 1] of clt$pdt_parameter_name,                                                        
      parameters: array [1 .. 1] of clt$pdt_parameter,                                                        
      type1: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
      recend,                                                                                                 
    recend := [                                                                                               
    [1,                                                                                                       
    [89, 6, 8, 14, 50, 19, 248],                                                                              
    clc$function, 1, 1, 1, 0, 0, 0, 0, ''], [                                                                 
    ['CHANNEL_NUMBER                 ',clc$nominal_entry, 1]],                                                
    [                                                                                                         
{ PARAMETER 1                                                                                                 
    [1, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$required_parameter, 
  0, 0]],                                                                                                     
{ PARAMETER 1                                                                                                 
    [[1, 0, clc$integer_type], [0, 33, 10]]];                                                                 
?? FMT (FORMAT := ON) ??                                                                                      
?? POP ??                                                                                                     
                                                                                                              
    CONST                                                                                                     
      p$channel_number = 1;                                                                                   
                                                                                                              
    VAR                                                                                                       
      pvt: array [1 .. 1] of clt$parameter_value;                                                             
                                                                                                              
    VAR                                                                                                       
      buffer_controlware_size: integer,                                                                       
      channel_number: 0 .. duc$de_maximum_channels,                                                           
      entry_p: ^dut$de_buffer_controlware_entry;                                                              
                                                                                                              
    status.normal := TRUE;                                                                                    
    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);                                  
    IF NOT status.normal THEN                                                                                 
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    IF duv$dump_environment_p = NIL THEN                                                                      
      osp$set_status_abnormal (duc$dump_analyzer_id, due$no_restart_file, '', status);                        
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    channel_number := pvt [p$channel_number].value^.integer_value.value;                                      
    dup$retrieve_bc_entry (channel_number, entry_p);                                                          
    IF entry_p <> NIL THEN                                                                                    
      buffer_controlware_size := entry_p^.words - 1;                                                          
    ELSE                                                                                                      
      buffer_controlware_size := 0;                                                                           
    IFEND;                                                                                                    
                                                                                                              
    clp$make_integer_value (buffer_controlware_size, 16, TRUE, work_area_p, result_p);                        
                                                                                                              
  PROCEND dup$$size_buffer_controlware;                                                                       
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'dup$$size_control_store', EJECT ??                                                            
                                                                                                              
{ PURPOSE:                                                                                                    
{   This function returns the size of control store as an integer.                                            
                                                                                                              
  PROCEDURE [XDCL] dup$$size_control_store                                                                    
    (    parameter_list: clt$parameter_list;                                                                  
     VAR work_area_p: ^clt$work_area;                                                                         
     VAR result_p: ^clt$data_value;                                                                           
     VAR status: ost$status);                                                                                 
                                                                                                              
{ FUNCTION $size_control_store, $scs (                                                                        
{   processor: integer 0..3 = 0                                                                               
{   shadow: boolean = FALSE                                                                                   
{   )                                                                                                         
                                                                                                              
?? PUSH (LISTEXT := ON) ??                                                                                    
?? FMT (FORMAT := OFF) ??                                                                                     
  VAR                                                                                                         
    pdt: [STATIC, READ, cls$declaration_section] record                                                       
      header: clt$pdt_header,                                                                                 
      names: array [1 .. 2] of clt$pdt_parameter_name,                                                        
      parameters: array [1 .. 2] of clt$pdt_parameter,                                                        
      type1: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
        default_value: string (1),                                                                            
      recend,                                                                                                 
      type2: record                                                                                           
        header: clt$type_specification_header,                                                                
        default_value: string (5),                                                                            
      recend,                                                                                                 
    recend := [                                                                                               
    [1,                                                                                                       
    [90, 9, 19, 8, 18, 1, 389],                                                                               
    clc$function, 2, 2, 0, 0, 0, 0, 0, ''], [                                                                 
    ['PROCESSOR                      ',clc$nominal_entry, 1],                                                 
    ['SHADOW                         ',clc$nominal_entry, 2]],                                                
    [                                                                                                         
{ PARAMETER 1                                                                                                 
    [1, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20,                         
  clc$optional_default_parameter, 0, 1],                                                                      
{ PARAMETER 2                                                                                                 
    [2, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3,                          
  clc$optional_default_parameter, 0, 5]],                                                                     
{ PARAMETER 1                                                                                                 
    [[1, 0, clc$integer_type], [0, 3, 10],                                                                    
    '0'],                                                                                                     
{ PARAMETER 2                                                                                                 
    [[1, 0, clc$boolean_type],                                                                                
    'FALSE']];                                                                                                
?? FMT (FORMAT := ON) ??                                                                                      
?? POP ??                                                                                                     
                                                                                                              
    CONST                                                                                                     
      p$processor = 1,                                                                                        
      p$shadow = 2;                                                                                           
                                                                                                              
    VAR                                                                                                       
      pvt: array [1 .. 2] of clt$parameter_value;                                                             
                                                                                                              
    VAR                                                                                                       
      control_store_entry: dut$de_control_store_entry,                                                        
      control_store_size: 0 .. duc$de_control_store_size,                                                     
      default_list: array [1 .. 1] of dut$default_change_list_entry,                                          
      processor: 0 .. duc$de_maximum_processors;                                                              
                                                                                                              
    status.normal := TRUE;                                                                                    
                                                                                                              
    { Change the default value for the PROCESSOR parameter.                                                   
                                                                                                              
    default_list [1].default_name := duc$dp_processor;                                                        
    default_list [1].number := p$processor;                                                                   
    dup$evaluate_parameters (parameter_list, default_list, #SEQ (pdt), ^pvt, status);                         
    IF NOT status.normal THEN                                                                                 
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    IF duv$dump_environment_p = NIL THEN                                                                      
      osp$set_status_abnormal (duc$dump_analyzer_id, due$no_restart_file, '', status);                        
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    processor := pvt [p$processor].value^.integer_value.value;                                                
    IF pvt [p$shadow].value^.boolean_value.value THEN                                                         
      control_store_entry := duv$dump_environment_p^.control_store.shadow [processor];                        
    ELSE                                                                                                      
      control_store_entry := duv$dump_environment_p^.control_store.main [processor];                          
    IFEND;                                                                                                    
    IF control_store_entry.available THEN                                                                     
      control_store_size := control_store_entry.size - 1;                                                     
    ELSE                                                                                                      
      control_store_size := 0;                                                                                
    IFEND;                                                                                                    
                                                                                                              
    clp$make_integer_value (control_store_size, 16, TRUE, work_area_p, result_p);                             
                                                                                                              
  PROCEND dup$$size_control_store;                                                                            
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'dup$$size_register_file', EJECT ??                                                            
                                                                                                              
{ PURPOSE:                                                                                                    
{   This function returns the size of the register file as an integer.                                        
                                                                                                              
  PROCEDURE [XDCL] dup$$size_register_file                                                                    
    (    parameter_list: clt$parameter_list;                                                                  
     VAR work_area_p: ^clt$work_area;                                                                         
     VAR result_p: ^clt$data_value;                                                                           
     VAR status: ost$status);                                                                                 
                                                                                                              
{ FUNCTION $size_register_file, $srf (                                                                        
{   processor: integer 0..3 = 0                                                                               
{   )                                                                                                         
                                                                                                              
?? PUSH (LISTEXT := ON) ??                                                                                    
?? FMT (FORMAT := OFF) ??                                                                                     
  VAR                                                                                                         
    pdt: [STATIC, READ, cls$declaration_section] record                                                       
      header: clt$pdt_header,                                                                                 
      names: array [1 .. 1] of clt$pdt_parameter_name,                                                        
      parameters: array [1 .. 1] of clt$pdt_parameter,                                                        
      type1: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
        default_value: string (1),                                                                            
      recend,                                                                                                 
    recend := [                                                                                               
    [1,                                                                                                       
    [89, 6, 12, 11, 36, 26, 18],                                                                              
    clc$function, 1, 1, 0, 0, 0, 0, 0, ''], [                                                                 
    ['PROCESSOR                      ',clc$nominal_entry, 1]],                                                
    [                                                                                                         
{ PARAMETER 1                                                                                                 
    [1, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_positionally],                                                    
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20,                         
  clc$optional_default_parameter, 0, 1]],                                                                     
{ PARAMETER 1                                                                                                 
    [[1, 0, clc$integer_type], [0, 3, 10],                                                                    
    '0']];                                                                                                    
?? FMT (FORMAT := ON) ??                                                                                      
?? POP ??                                                                                                     
                                                                                                              
    CONST                                                                                                     
      p$processor = 1;                                                                                        
                                                                                                              
    VAR                                                                                                       
      pvt: array [1 .. 1] of clt$parameter_value;                                                             
                                                                                                              
    VAR                                                                                                       
      default_list: array [1 .. 1] of dut$default_change_list_entry,                                          
      processor: 0 .. duc$de_maximum_processors,                                                              
      register_file_size: 0 .. duc$de_max_register_number;                                                    
                                                                                                              
    status.normal := TRUE;                                                                                    
                                                                                                              
    { Change the default value for the PROCESSOR parameter.                                                   
                                                                                                              
    default_list [1].default_name := duc$dp_processor;                                                        
    default_list [1].number := p$processor;                                                                   
    dup$evaluate_parameters (parameter_list, default_list, #SEQ (pdt), ^pvt, status);                         
    IF NOT status.normal THEN                                                                                 
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    IF duv$dump_environment_p = NIL THEN                                                                      
      osp$set_status_abnormal (duc$dump_analyzer_id, due$no_restart_file, '', status);                        
      RETURN; {---->                                                                                          
    IFEND;                                                                                                    
                                                                                                              
    processor := pvt [p$processor].value^.integer_value.value;                                                
                                                                                                              
    IF duv$dump_environment_p^.register_file [processor].available THEN                                       
      register_file_size := duv$dump_environment_p^.register_file [processor].number_of_registers - 1;        
    ELSE                                                                                                      
      register_file_size := 0;                                                                                
    IFEND;                                                                                                    
                                                                                                              
    clp$make_integer_value (register_file_size, 16, TRUE, work_area_p, result_p);                             
                                                                                                              
  PROCEND dup$$size_register_file;                                                                            
MODEND dum$dump_analyzer_functions;                                                                           
