?? RIGHT := 110 ??                                                                                            
?? NEWTITLE := 'NOS/VE Dump Analyzer : Display PP Memory Command' ??                                          
MODULE dum$display_pp_memory_command;                                                                         
                                                                                                              
{ PURPOSE:                                                                                                    
{   This module contains the code for the display_pp_memory command.                                          
                                                                                                              
?? NEWTITLE := 'Global Declarations Referenced by This Module', EJECT ??                                      
?? PUSH (LISTEXT := ON) ??                                                                                    
*copyc due$exception_condition_codes                                                                          
?? POP ??                                                                                                     
*copyc clp$close_display                                                                                      
*copyc clp$convert_integer_to_string                                                                          
*copyc clp$open_display_reference                                                                             
*copyc clp$put_display                                                                                        
*copyc dup$determine_dump_information                                                                         
*copyc dup$display_data                                                                                       
*copyc dup$evaluate_parameters                                                                                
*copyc dup$new_page_procedure                                                                                 
*copyc dup$retrieve_register                                                                                  
*copyc osp$append_status_integer                                                                              
*copyc osp$append_status_parameter                                                                            
*copyc osp$disestablish_cond_handler                                                                          
*copyc osp$establish_block_exit_hndlr                                                                         
*copyc osp$set_status_abnormal                                                                                
?? EJECT ??                                                                                                   
*copyc duv$dump_environment_p                                                                                 
*copyc duv$execution_environment                                                                              
*copyc duv$title_data                                                                                         
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'display_r_register_value', EJECT ??                                                           
                                                                                                              
{ PURPOSE:                                                                                                    
{   This procedure displays the R register value for the desired PP.                                          
                                                                                                              
  PROCEDURE display_r_register_value                                                                          
    (    dump_information: dut$dump_information;                                                              
         iou_number: 0 .. duc$de_maximum_ious;                                                                
         pp_number: 0 .. duc$de_max_pp_memories;                                                              
         radix: 8 .. 16;                                                                                      
         nio_pp: boolean;                                                                                     
     VAR display_control: clt$display_control);                                                               
                                                                                                              
    TYPE                                                                                                      
      t$byte_or_bits = PACKED RECORD                                                                          
        CASE boolean OF                                                                                       
        = TRUE =                                                                                              
          byte_part: 0 .. 0ff(16),                                                                            
        = FALSE =                                                                                             
          bit_part: PACKED ARRAY [56 .. 63] OF boolean,                                                       
        CASEND,                                                                                               
      RECEND;                                                                                                 
                                                                                                              
    VAR                                                                                                       
      byte_or_bits: t$byte_or_bits,                                                                           
      display_string: string (osc$max_string_size),                                                           
      register: dut$de_maintenance_register,                                                                  
      string_length: integer,                                                                                 
      ignore_status: ost$status,                                                                              
      integer_string: ost$string;                                                                             
                                                                                                              
    IF (iou_number > 0) AND (dump_information.dump_type <> duc$di_dt_cy2000) THEN                             
      STRINGREP (display_string, string_length,                                                               
            'WARNING: The R Register contents is invalid for each PP in IOU', iou_number, '.');               
      clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);          
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
                                                                                                              
    dup$retrieve_register (duc$de_iou, iou_number, 0, register);                                              
    IF register.available THEN                                                                                
      byte_or_bits.byte_part := register.value [8];                                                           
      IF byte_or_bits.bit_part [57] AND (dump_information.iou [iou_number].model <> duc$di_im_i0_5x) THEN     
        CASE dump_information.tape_type OF                                                                    
        = duc$di_tt_unknown =                                                                                 
          clp$put_display (display_control,                                                                   
                ' WARNING: Bit 57 in the IOU Status Summary Register is set and the',                         
                clc$trim, ignore_status);                                                                     
          clp$put_display (display_control,                                                                   
                '          dump was taken on a tape drive configured on an unknown channel.',                 
                clc$trim, ignore_status);                                                                     
          clp$put_display (display_control,                                                                   
                '          It might have been necessary to perform an ADU Master Clear and',                  
                clc$trim, ignore_status);                                                                     
          clp$put_display (display_control,                                                                   
                '          therefore the R Register contents might be invalid.', clc$trim, ignore_status);    
        = duc$di_tt_40, duc$di_tt_41 =                                                                        
          clp$put_display (display_control,                                                                   
                ' WARNING: Bit 57 in the IOU Status Summary Register is set and the',                         
                clc$trim, ignore_status);                                                                     
          clp$put_display (display_control,                                                                   
                '          dump was taken on a tape drive configured on an IPI channel.',                     
                clc$trim, ignore_status);                                                                     
          clp$put_display (display_control,                                                                   
                '          It was necessary to perform an ADU Master Clear and therefore',                    
                clc$trim, ignore_status);                                                                     
          clp$put_display (display_control,                                                                   
                '          the R Register contents are invalid.', clc$trim, ignore_status);                   
        ELSE                                                                                                  
        CASEND;                                                                                               
      IFEND;                                                                                                  
    IFEND;                                                                                                    
                                                                                                              
    IF nio_pp THEN                                                                                            
      clp$convert_integer_to_string (duv$dump_environment_p^.iou_memory [iou_number].                         
            nio_pp [pp_number].r_register, radix, TRUE, integer_string, ignore_status);                       
    ELSE                                                                                                      
      clp$convert_integer_to_string (duv$dump_environment_p^.iou_memory [iou_number].                         
            cio_pp [pp_number].r_register, radix, TRUE, integer_string, ignore_status);                       
    IFEND;                                                                                                    
    STRINGREP (display_string, string_length, 'R register = ',                                                
          integer_string.value (1, integer_string.size));                                                     
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);            
                                                                                                              
  PROCEND display_r_register_value;                                                                           
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'dup$display_pp_memory_command', EJECT ??                                                      
                                                                                                              
{ PURPOSE:                                                                                                    
{   This procedure displays the pp memory.                                                                    
{ NOTE:                                                                                                       
{   This procedure refers to a "word".  The definition of a word for this procedure is a two byte data        
{   structure.                                                                                                
                                                                                                              
  PROCEDURE [XDCL] dup$display_pp_memory_command                                                              
    (    parameter_list: clt$parameter_list;                                                                  
     VAR status: ost$status);                                                                                 
                                                                                                              
{ PROCEDURE display_pp_memory, dispm (                                                                        
{   pp_number, pn: integer 0..25 = $required                                                                  
{   address, a: integer 0..16383 = 0                                                                          
{   words, w: integer 0..16384 = 16384                                                                        
{   pp_type, pt: key                                                                                          
{       (normal n) (concurrent_input_output cio c)                                                            
{     keyend = concurrent_input_output                                                                        
{   display_option, do: list 1..2 of key                                                                      
{       (numeric n) (ascii a) (display_code dc)                                                               
{     keyend = (numeric ascii)                                                                                
{   radix, r: integer 8..16 = 8                                                                               
{   display_relocation_register, drr: boolean = $optional                                                     
{   title, t: string 1..31 = $optional                                                                        
{   output, o: file                                                                                           
{   iou, i: integer 0..1 = 0                                                                                  
{   status)                                                                                                   
                                                                                                              
?? PUSH (LISTEXT := ON) ??                                                                                    
?? FMT (FORMAT := OFF) ??                                                                                     
  VAR                                                                                                         
    pdt: [STATIC, READ, cls$declaration_section] record                                                       
      header: clt$pdt_header,                                                                                 
      names: array [1 .. 21] of clt$pdt_parameter_name,                                                       
      parameters: array [1 .. 11] 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$integer_type_qualifier,                                                                
        default_value: string (5),                                                                            
      recend,                                                                                                 
      type4: 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,                                                                                                 
      type5: 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 .. 6] of clt$keyword_specification,                                         
        recend,                                                                                               
        default_value: string (15),                                                                           
      recend,                                                                                                 
      type6: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
        default_value: string (1),                                                                            
      recend,                                                                                                 
      type7: record                                                                                           
        header: clt$type_specification_header,                                                                
      recend,                                                                                                 
      type8: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$string_type_qualifier,                                                                 
      recend,                                                                                                 
      type9: record                                                                                           
        header: clt$type_specification_header,                                                                
      recend,                                                                                                 
      type10: record                                                                                          
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
        default_value: string (1),                                                                            
      recend,                                                                                                 
      type11: record                                                                                          
        header: clt$type_specification_header,                                                                
      recend,                                                                                                 
    recend := [                                                                                               
    [1,                                                                                                       
    [92, 1, 22, 11, 39, 31, 112],                                                                             
    clc$command, 21, 11, 1, 0, 0, 0, 11, ''], [                                                               
    ['A                              ',clc$abbreviation_entry, 2],                                            
    ['ADDRESS                        ',clc$nominal_entry, 2],                                                 
    ['DISPLAY_OPTION                 ',clc$nominal_entry, 5],                                                 
    ['DISPLAY_RELOCATION_REGISTER    ',clc$nominal_entry, 7],                                                 
    ['DO                             ',clc$abbreviation_entry, 5],                                            
    ['DRR                            ',clc$abbreviation_entry, 7],                                            
    ['I                              ',clc$abbreviation_entry, 10],                                           
    ['IOU                            ',clc$nominal_entry, 10],                                                
    ['O                              ',clc$abbreviation_entry, 9],                                            
    ['OUTPUT                         ',clc$nominal_entry, 9],                                                 
    ['PN                             ',clc$abbreviation_entry, 1],                                            
    ['PP_NUMBER                      ',clc$nominal_entry, 1],                                                 
    ['PP_TYPE                        ',clc$nominal_entry, 4],                                                 
    ['PT                             ',clc$abbreviation_entry, 4],                                            
    ['R                              ',clc$abbreviation_entry, 6],                                            
    ['RADIX                          ',clc$nominal_entry, 6],                                                 
    ['STATUS                         ',clc$nominal_entry, 11],                                                
    ['T                              ',clc$abbreviation_entry, 8],                                            
    ['TITLE                          ',clc$nominal_entry, 8],                                                 
    ['W                              ',clc$abbreviation_entry, 3],                                            
    ['WORDS                          ',clc$nominal_entry, 3]],                                                
    [                                                                                                         
{ PARAMETER 1                                                                                                 
    [12, clc$normal_usage_entry, clc$non_secure_parameter,                                                    
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],                               
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$required_parameter, 
  0, 0],                                                                                                      
{ PARAMETER 2                                                                                                 
    [2, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],                               
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20,                         
  clc$optional_default_parameter, 0, 1],                                                                      
{ PARAMETER 3                                                                                                 
    [21, clc$normal_usage_entry, clc$non_secure_parameter,                                                    
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],                               
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20,                         
  clc$optional_default_parameter, 0, 5],                                                                      
{ PARAMETER 4                                                                                                 
    [13, clc$normal_usage_entry, clc$non_secure_parameter,                                                    
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],                               
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 192,                        
  clc$optional_default_parameter, 0, 23],                                                                     
{ PARAMETER 5                                                                                                 
    [3, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],                               
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 245,                        
  clc$optional_default_parameter, 0, 15],                                                                     
{ PARAMETER 6                                                                                                 
    [16, clc$normal_usage_entry, clc$non_secure_parameter,                                                    
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],                               
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20,                         
  clc$optional_default_parameter, 0, 1],                                                                      
{ PARAMETER 7                                                                                                 
    [4, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],                               
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$optional_parameter, 0
  , 0],                                                                                                       
{ PARAMETER 8                                                                                                 
    [19, clc$normal_usage_entry, clc$non_secure_parameter,                                                    
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],                               
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 8, clc$optional_parameter, 0
  , 0],                                                                                                       
{ PARAMETER 9                                                                                                 
    [10, clc$normal_usage_entry, clc$non_secure_parameter,                                                    
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],                               
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$optional_parameter, 0
  , 0],                                                                                                       
{ PARAMETER 10                                                                                                
    [8, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],                               
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20,                         
  clc$optional_default_parameter, 0, 1],                                                                      
{ PARAMETER 11                                                                                                
    [17, clc$normal_usage_entry, clc$non_secure_parameter,                                                    
    $clt$parameter_spec_methods[clc$specify_by_name],                                                         
    clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,                      
  clc$optional_parameter, 0, 0]],                                                                             
{ PARAMETER 1                                                                                                 
    [[1, 0, clc$integer_type], [0, 25, 10]],                                                                  
{ PARAMETER 2                                                                                                 
    [[1, 0, clc$integer_type], [0, 16383, 10],                                                                
    '0'],                                                                                                     
{ PARAMETER 3                                                                                                 
    [[1, 0, clc$integer_type], [0, 16384, 10],                                                                
    '16384'],                                                                                                 
{ PARAMETER 4                                                                                                 
    [[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 5                                                                                                 
    [[1, 0, clc$list_type], [229, 1, 2, 0, FALSE, FALSE],                                                     
      [[1, 0, clc$keyword_type], [6], [                                                                       
      ['A                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],                 
      ['ASCII                          ', clc$nominal_entry, clc$normal_usage_entry, 2],                      
      ['DC                             ', clc$abbreviation_entry, clc$normal_usage_entry, 3],                 
      ['DISPLAY_CODE                   ', clc$nominal_entry, clc$normal_usage_entry, 3],                      
      ['N                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],                 
      ['NUMERIC                        ', clc$nominal_entry, clc$normal_usage_entry, 1]]                      
      ]                                                                                                       
    ,                                                                                                         
    '(numeric ascii)'],                                                                                       
{ PARAMETER 6                                                                                                 
    [[1, 0, clc$integer_type], [8, 16, 10],                                                                   
    '8'],                                                                                                     
{ PARAMETER 7                                                                                                 
    [[1, 0, clc$boolean_type]],                                                                               
{ PARAMETER 8                                                                                                 
    [[1, 0, clc$string_type], [1, 31, FALSE]],                                                                
{ PARAMETER 9                                                                                                 
    [[1, 0, clc$file_type]],                                                                                  
{ PARAMETER 10                                                                                                
    [[1, 0, clc$integer_type], [0, 1, 10],                                                                    
    '0'],                                                                                                     
{ PARAMETER 11                                                                                                
    [[1, 0, clc$status_type]]];                                                                               
?? FMT (FORMAT := ON) ??                                                                                      
?? POP ??                                                                                                     
                                                                                                              
    CONST                                                                                                     
      p$pp_number = 1,                                                                                        
      p$address = 2,                                                                                          
      p$words = 3,                                                                                            
      p$pp_type = 4,                                                                                          
      p$display_option = 5,                                                                                   
      p$radix = 6,                                                                                            
      p$display_relocation_register = 7,                                                                      
      p$title = 8,                                                                                            
      p$output = 9,                                                                                           
      p$iou = 10,                                                                                             
      p$status = 11;                                                                                          
                                                                                                              
    VAR                                                                                                       
      pvt: array [1 .. 11] of clt$parameter_value;                                                            
                                                                                                              
    VAR                                                                                                       
      address: 0 .. 16383,                                                                                    
      cell_p: ^cell,                                                                                          
      default_list: ARRAY [1 .. 2] OF dut$default_change_list_entry,                                          
      display_control: clt$display_control,                                                                   
      display_r_register: boolean,                                                                            
      display_string: string (osc$max_string_size),                                                           
      dump_information: dut$dump_information,                                                                 
      end_of_input_file: boolean,                                                                             
      ignore_status: ost$status,                                                                              
      integer_string: ost$string,                                                                             
      iou_number: 0 .. duc$de_maximum_ious,                                                                   
      output_display_opened: boolean,                                                                         
      pp_number: 0 .. duc$de_max_pp_memories,                                                                 
      radix: 8 .. 16,                                                                                         
      restart_file_seq_p: ^SEQ ( * ),                                                                         
      ring_attributes: amt$ring_attributes,                                                                   
      skip_pp_data_p: ^SEQ ( * ),                                                                             
      string_length: integer,                                                                                 
      words: 0 .. 16384;                                                                                      
                                                                                                              
*copy dup$abort_handler                                                                                       
?? NEWTITLE := 'clean_up', EJECT ??                                                                           
                                                                                                              
{ PURPOSE:                                                                                                    
{   This procedure is called from the abort handler to close the file.                                        
                                                                                                              
    PROCEDURE [INLINE] clean_up;                                                                              
                                                                                                              
      VAR                                                                                                     
        ignore_status: ost$status;                                                                            
                                                                                                              
      IF output_display_opened THEN                                                                           
        clp$close_display (display_control, ignore_status);                                                   
      IFEND;                                                                                                  
                                                                                                              
    PROCEND clean_up;                                                                                         
?? OLDTITLE, EJECT ??                                                                                         
                                                                                                              
    status.normal := TRUE;                                                                                    
                                                                                                              
    { 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;                                                                                                    
                                                                                                              
    { Check the availability of the pp memory.                                                                
                                                                                                              
    pp_number := pvt [p$pp_number].value^.integer_value.value;                                                
    iou_number := pvt [p$iou].value^.integer_value.value;                                                     
                                                                                                              
  /determine_pp_availability/                                                                                 
    BEGIN                                                                                                     
      IF pvt [p$pp_type].value^.keyword_value = 'NORMAL' THEN                                                 
        IF duv$dump_environment_p^.iou_memory [iou_number].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_number].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/;                                                                          
                                                                                                              
    { Determine how many words to display.                                                                    
                                                                                                              
    address := pvt [p$address].value^.integer_value.value;                                                    
    words := pvt [p$words].value^.integer_value.value;                                                        
    dup$determine_dump_information (dump_information);                                                        
    IF address >= dump_information.iou [iou_number].pp_word_size THEN                                         
      words := 0;                                                                                             
    ELSEIF (address + words) > dump_information.iou [iou_number].pp_word_size THEN                            
      words := dump_information.iou [iou_number].pp_word_size - address;                                      
    IFEND;                                                                                                    
                                                                                                              
    output_display_opened := FALSE;                                                                           
    osp$establish_block_exit_hndlr (^abort_handler);                                                          
                                                                                                              
   /display_opened/                                                                                           
    BEGIN                                                                                                     
                                                                                                              
    { Prepare the output display file.                                                                        
                                                                                                              
      IF pvt [p$output].specified THEN                                                                        
        ring_attributes.r1 := #RING (^ring_attributes);                                                       
        ring_attributes.r2 := #RING (^ring_attributes);                                                       
        ring_attributes.r3 := #RING (^ring_attributes);                                                       
        clp$open_display_reference (pvt [p$output].value^.file_value^, ^dup$new_page_procedure, fsc$list,     
              ring_attributes, display_control, status);                                                      
        IF NOT status.normal THEN                                                                             
          EXIT /display_opened/;  {---->                                                                      
        IFEND;                                                                                                
        output_display_opened := TRUE;                                                                        
      ELSE                                                                                                    
        display_control := duv$execution_environment.output_file.display_control;                             
        display_control.line_number := display_control.page_length + 1;                                       
      IFEND;                                                                                                  
                                                                                                              
      duv$title_data.build_title := TRUE;                                                                     
      IF pvt [p$title].specified THEN                                                                         
        duv$title_data.command_name := pvt [p$title].value^.string_value^;                                    
      ELSE                                                                                                    
        duv$title_data.command_name := 'display_pp_memory pp_number=';                                        
        clp$convert_integer_to_string (pp_number, 10, FALSE, integer_string, ignore_status);                  
        duv$title_data.command_name (29, integer_string.size) :=                                              
              integer_string.value (1, integer_string.size);                                                  
      IFEND;                                                                                                  
                                                                                                              
      { Display the relocation register if desired.                                                           
                                                                                                              
      IF pvt [p$display_relocation_register].specified THEN                                                   
        display_r_register := pvt [p$display_relocation_register].value^.boolean_value.value;                 
      ELSE                                                                                                    
        display_r_register := (words = dump_information.iou [iou_number].pp_word_size);                       
      IFEND;                                                                                                  
      radix := pvt [p$radix].value^.integer_value.value;                                                      
      IF display_r_register THEN                                                                              
        display_r_register_value (dump_information, iou_number, pp_number, radix,                             
              (pvt [p$pp_type].value^.keyword_value = 'NORMAL'), display_control);                            
      IFEND;                                                                                                  
                                                                                                              
      { Return if there are no words to display.                                                              
                                                                                                              
      IF words = 0 THEN                                                                                       
        EXIT /display_opened/;  {---->                                                                        
      IFEND;                                                                                                  
                                                                                                              
      { Retrieve a sequence pointer to the pp memory data on the restart file.                                
                                                                                                              
      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_number].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_number].cio_pp [pp_number].first_byte);                 
      IFEND;                                                                                                  
      RESET restart_file_seq_p TO cell_p;                                                                     
                                                                                                              
      { Skip to the desired addess in the pp memory data.                                                     
                                                                                                              
      IF address <> 0 THEN                                                                                    
        NEXT skip_pp_data_p: [[REP (address * 2) OF CELL]] IN restart_file_seq_p;                             
        IF skip_pp_data_p = NIL THEN                                                                          
          osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);                        
          EXIT /display_opened/;  {---->                                                                      
        IFEND;                                                                                                
      IFEND;                                                                                                  
                                                                                                              
      { Display the data.                                                                                     
                                                                                                              
      dup$display_data (pvt [p$display_option].value, FALSE, radix, address, words, display_control,          
            restart_file_seq_p, end_of_input_file, status);                                                   
                                                                                                              
    END /display_opened/;                                                                                     
                                                                                                              
    IF output_display_opened THEN                                                                             
      clp$close_display (display_control, ignore_status);                                                     
    IFEND;                                                                                                    
    osp$disestablish_cond_handler;                                                                            
                                                                                                              
  PROCEND dup$display_pp_memory_command;                                                                      
MODEND dum$display_pp_memory_command;                                                                         
