?? RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE Dump Analyzer : Display MRT Data Command' ??
MODULE dum$display_mrt_data_command;

{ PURPOSE:
{   This module contains the code for the display_mrt_data command.

?? NEWTITLE := 'Global Declarations Referenced by This Module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc dst$mrt_entry
*copyc due$exception_condition_codes
?? POP ??
*copyc clp$close_display
*copyc clp$convert_integer_to_rjstring
*copyc clp$evaluate_parameters
*copyc clp$open_display_reference
*copyc clp$put_display
*copyc dup$new_page_procedure
*copyc dup$retrieve_cip_program
*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_clock_data', EJECT ??

{ PURPOSE:
{   This procedure displays the clock data from the MRT in detail.

  PROCEDURE display_clock_data
    (VAR display_control: clt$display_control;
     VAR restart_file_seq_p: ^SEQ ( * );
     VAR status: ost$status);

    VAR
      clock_p: ^dst$mrt_clock_data_info,
      display_string: string (osc$max_string_size),
      ignore_status: ost$status,
      integer_data: 0 .. 0ff(16),
      string_2: string (2),
      string_7: string (7),
      string_length: integer;

    status.normal := TRUE;
    clp$put_display (display_control, '   DETAIL:', clc$trim, ignore_status);
    NEXT clock_p IN restart_file_seq_p;
    IF clock_p = NIL THEN
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);
      RETURN;  {---->
    IFEND;

    integer_data := (clock_p^.years.tens * 10(16)) + clock_p^.years.units;
    clp$convert_integer_to_rjstring (integer_data, 16, FALSE, '0', string_2, ignore_status);
    STRINGREP (display_string, string_length, '     Years = ', string_2);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    integer_data := (clock_p^.months.tens * 10(16)) + clock_p^.months.units;
    clp$convert_integer_to_rjstring (integer_data, 16, FALSE, '0', string_2, ignore_status);
    STRINGREP (display_string, string_length, '     Months = ', string_2);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    integer_data := (clock_p^.days.tens * 10(16)) + clock_p^.days.units;
    clp$convert_integer_to_rjstring (integer_data, 16, FALSE, '0', string_2, ignore_status);
    STRINGREP (display_string, string_length, '     Days = ', string_2);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    integer_data := (clock_p^.hours.tens * 10(16)) + clock_p^.hours.units;
    clp$convert_integer_to_rjstring (integer_data, 16, FALSE, '0', string_2, ignore_status);
    STRINGREP (display_string, string_length, '     Hours = ', string_2);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    integer_data := (clock_p^.minutes.tens * 10(16)) + clock_p^.minutes.units;
    clp$convert_integer_to_rjstring (integer_data, 16, FALSE, '0', string_2, ignore_status);
    STRINGREP (display_string, string_length, '     Minutes = ', string_2);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    integer_data := (clock_p^.seconds.tens * 10(16)) + clock_p^.seconds.units;
    clp$convert_integer_to_rjstring (integer_data, 16, FALSE, '0', string_2, ignore_status);
    STRINGREP (display_string, string_length, '     Seconds = ', string_2);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (clock_p^.frc_bits_4_15.frc_bits, 16, TRUE, '0', string_7,
          ignore_status);
    STRINGREP (display_string, string_length, '     FRC bits 04-15 = ', string_7);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (clock_p^.frc_bits_16_27.frc_bits, 16, TRUE, '0', string_7,
          ignore_status);
    STRINGREP (display_string, string_length, '     FRC bits 16-27 = ', string_7);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (clock_p^.frc_bits_28_39.frc_bits, 16, TRUE, '0', string_7,
          ignore_status);
    STRINGREP (display_string, string_length, '     FRC bits 28-39 = ', string_7);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (clock_p^.frc_bits_40_51.frc_bits, 16, TRUE, '0', string_7,
          ignore_status);
    STRINGREP (display_string, string_length, '     FRC bits 40-51 = ', string_7);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (clock_p^.frc_bits_52_63.frc_bits, 16, TRUE, '0', string_7,
          ignore_status);
    STRINGREP (display_string, string_length, '     FRC bits 52-63 = ', string_7);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

  PROCEND display_clock_data;
?? OLDTITLE ??
?? NEWTITLE := 'display_console_data', EJECT ??

{ PURPOSE:
{   This procedure displays the console data from the MRT in detail.

  PROCEDURE display_console_data
    (VAR display_control: clt$display_control;
     VAR restart_file_seq_p: ^SEQ ( * );
     VAR status: ost$status);

    VAR
      console_p: ^dst$mrt_display_console_info,
      display_string: string (osc$max_string_size),
      ignore_status: ost$status,
      string_4: string (4),
      string_length: integer;

    status.normal := TRUE;
    clp$put_display (display_control, '   DETAIL:', clc$trim, ignore_status);
    NEXT console_p IN restart_file_seq_p;
    IF console_p = NIL THEN
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);
      RETURN;  {---->
    IFEND;

    IF console_p^.display_type = 0 THEN
      clp$put_display (display_control, '     Console type = CC545', clc$trim, ignore_status);
    ELSEIF console_p^.display_type = 1 THEN
      clp$put_display (display_control, '     Console type = VIKING X', clc$trim, ignore_status);
    ELSEIF console_p^.display_type = 2 THEN
      clp$put_display (display_control, '     Console type = PC', clc$trim, ignore_status);
    ELSE
      clp$put_display (display_control, '     Console type = unknown', clc$trim, ignore_status);
    IFEND;

    IF console_p^.port_flags = 1000(8) THEN
      clp$put_display (display_control, '     CC545 on channel 10', clc$trim, ignore_status);
    ELSEIF console_p^.port_flags = 1500(8) THEN
      clp$put_display (display_control, '     Viking-X on Port 0 of the TPM', clc$trim, ignore_status);
    ELSEIF console_p^.port_flags = 1501(8) THEN
      clp$put_display (display_control, '     Viking-X on Port 1 of the TPM', clc$trim, ignore_status);
    ELSEIF console_p^.port_flags = 1510(8) THEN
      clp$put_display (display_control, '     TTY type on Port 0 of the TPM', clc$trim, ignore_status);
    ELSEIF console_p^.port_flags = 1511(8) THEN
      clp$put_display (display_control, '     TTY type on Port 1 of the TPM', clc$trim, ignore_status);
    ELSEIF console_p^.port_flags = 1520(8) THEN
      clp$put_display (display_control, '     PC type on Port 0 of the TPM', clc$trim, ignore_status);
    ELSEIF console_p^.port_flags = 1521(8) THEN
       clp$put_display (display_control, '    PC type on Port 1 of the TPM', clc$trim, ignore_status);
    IFEND;

    IF (console_p^.mdd_pp = 0) AND (console_p^.scd_pp = 0) THEN
      clp$put_display (display_control, '     Neither MDD nor SCD is loaded', clc$trim, ignore_status);
    ELSEIF console_p^.mdd_pp <> 0 THEN
      clp$convert_integer_to_rjstring (console_p^.mdd_pp, 8, TRUE, '0', string_4, ignore_status);
      STRINGREP (display_string, string_length, '     MDD PP = ', string_4);
      clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);
    ELSEIF console_p^.scd_pp <> 0 THEN
      clp$convert_integer_to_rjstring (console_p^.scd_pp, 8, TRUE, '0', string_4, ignore_status);
      STRINGREP (display_string, string_length, '     SCD PP = ', string_4);
      clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);
    IFEND;

    IF console_p^.mdd_to_be_loaded THEN
      clp$put_display (display_control, '     MDD is to be loaded', clc$trim, ignore_status);
    IFEND;

    clp$convert_integer_to_rjstring (console_p^.mdd_port_number, 8, TRUE, '0', string_4, ignore_status);
    STRINGREP (display_string, string_length, '     MDD Port Number = ', string_4);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

  PROCEND display_console_data;
?? OLDTITLE ??
?? NEWTITLE := 'display_cpu_data', EJECT ??

{ PURPOSE:
{   This procedure displays the cpu data from the MRT in detail.

  PROCEDURE display_cpu_data
    (VAR display_control: clt$display_control;
     VAR restart_file_seq_p: ^SEQ ( * );
     VAR status: ost$status);

    TYPE
      t$cpu = PACKED RECORD
        descriptor_id: dst$mrt_descriptor_id,
        element_id: dst$mrt_element_id,
        maintenance_channel_id: dst$mrt_maintenance_channel_id,
        unused_1: 0 .. 0f(16),
        page_map: PACKED ARRAY [0 .. 3] OF boolean,
        segment_map: PACKED ARRAY [0 .. 1] OF boolean,
        unused_2: boolean,
        physical_16k_cache_installed: boolean,
        cache_set: PACKED ARRAY [0 .. 3] OF boolean,
        unused_3: 0 .. 17777(8),
        memory_port: 0 .. 7(8),
        unused_4: 0 .. 0f(16),
        cpu_downed_by: 0 .. 3,
        up_down_status: 0 .. 1,
        ibs_degrade_bits: 0 .. 0f(16),
        vector_option_installed: 0 .. 1,
        pmf_present: 0 .. 1,
        processor_supports_180_state: 0 .. 1,
        processor_supports_170_state: 0 .. 1,
        on_off_status: 0 .. 1,
        unused_5: 0 .. 0f(16),
        div_net_result_select: 0 .. 3,
        div_net_sel_for_compare: 0 .. 3,
        enable_maintenance_mode: 0 .. 1,
        unused_6: 0 .. 3,
        cpu0_instruction_stack: 0 .. 1,
        cmu_capability: 0 .. 1,
        cej_mej_capability: 0 .. 1,
        cpu1_not_available: 0 .. 1,
        cpu0_not_available: 0 .. 1,
        unused_7: 0 .. 07fff(16),
        microcode_loaded_flag: 0 .. 1,
        microcode_1_2: 0 .. 0ffff(16),
        microcode_3_4: 0 .. 0ffff(16),
        microcode_5_6: 0 .. 0ffff(16),
        microcode_7: 0 .. 0ffff(16),
        unused_8: 0 .. 0ffff(16),
        microcode_date_1_2: 0 .. 0ffff(16),
        microcode_date_3_4: 0 .. 0ffff(16),
        microcode_date_5_6: 0 .. 0ffff(16),
        theta_standard_option: 0 .. 0ffff(16),
        unused_9: 0 .. 1fff(16),
        pip3_fast_slow_clock_frequency: 0 .. 3,
        pip3_init_clock_sys_flag: 0 .. 1,
        cpu_mps_rma_bits: PACKED ARRAY [1 .. 3] OF t$rma_bits,
      RECEND,

      t$rma_bits = PACKED RECORD
        unused_1: 0 .. 0f(16),
        bits: 0 .. 0fff(16),
      RECEND;

    VAR
      cell_p: ^cell,
      cpu_p: ^t$cpu,
      descriptor_p: ^0 .. 0ffff(16),
      display_string: string (osc$max_string_size),
      ignore_status: ost$status,
      index: 0 .. 0f(16),
      integer_data: 0 .. 0fffffffff(16),
      string_5: string (5),
      string_7: string (7),
      string_8: string (8),
      string_13: string (13),
      string_length: integer;

    status.normal := TRUE;
    clp$put_display (display_control, '   DETAIL:', clc$trim, ignore_status);
    NEXT cell_p IN restart_file_seq_p;
    IF cell_p = NIL THEN
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);
      RETURN;  {---->
    IFEND;
    RESET restart_file_seq_p TO cell_p;
    NEXT descriptor_p IN restart_file_seq_p;
    IF descriptor_p = NIL THEN
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);
      RETURN;  {---->
    IFEND;
    display_element_id (display_control, restart_file_seq_p, status);
    IF NOT status.normal THEN
      RETURN;  {---->
    IFEND;
    RESET restart_file_seq_p TO cell_p;
    NEXT cpu_p IN restart_file_seq_p;
    IF cpu_p = NIL THEN
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);
      RETURN;  {---->
    IFEND;

    clp$convert_integer_to_rjstring (cpu_p^.maintenance_channel_id.port, 16, TRUE, '0', string_5,
          ignore_status);
    STRINGREP (display_string, string_length, '     Maintenance Channel Port = ', string_5);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (cpu_p^.maintenance_channel_id.type_code, 16, TRUE, '0', string_5,
          ignore_status);
    STRINGREP (display_string, string_length, '     Maintenance Channel Type Code = ', string_5);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    FOR index := 0 TO 3 DO
      IF cpu_p^.page_map [index] THEN
        STRINGREP (display_string, string_length, '     Page Map ', index, ' is disabled');
      ELSE
        STRINGREP (display_string, string_length, '     Page Map ', index, ' is enabled');
      IFEND;
      clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);
    FOREND;

    FOR index := 0 TO 1 DO
      IF cpu_p^.segment_map [index] THEN
        STRINGREP (display_string, string_length, '     Segment Map ', index, ' is disabled');
      ELSE
        STRINGREP (display_string, string_length, '     Segment Map ', index, ' is enabled');
      IFEND;
      clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);
    FOREND;

    IF cpu_p^.physical_16k_cache_installed THEN
      clp$put_display (display_control, '     16k Physical Cache Installed', clc$trim, ignore_status);
    ELSE
      clp$put_display (display_control, '     32k Physical Cache Installed', clc$trim, ignore_status);
    IFEND;

    FOR index := 0 TO 3 DO
      IF cpu_p^.cache_set [index] THEN
        STRINGREP (display_string, string_length, '     Cache ', index, ' is disabled');
      ELSE
        STRINGREP (display_string, string_length, '     Cache ', index, ' is enabled');
      IFEND;
      clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);
    FOREND;

    clp$convert_integer_to_rjstring (cpu_p^.memory_port, 16, TRUE, '0', string_5, ignore_status);
    STRINGREP (display_string, string_length, '     Memory Port = ', string_5);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    IF cpu_p^.cpu_downed_by = 1 THEN
      clp$put_display (display_control, '     CPU downed by DFT', clc$trim, ignore_status);
    ELSEIF cpu_p^.cpu_downed_by = 2 THEN
      clp$put_display (display_control, '     CPU downed by SYSTEM', clc$trim, ignore_status);
    ELSEIF cpu_p^.cpu_downed_by = 3 THEN
      clp$put_display (display_control, '     CPU downed by OPERATOR', clc$trim, ignore_status);
    IFEND;

    IF cpu_p^.up_down_status = 0 THEN
      clp$put_display (display_control, '     CPU is up', clc$trim, ignore_status);
    ELSE
      clp$put_display (display_control, '     CPU is down', clc$trim, ignore_status);
    IFEND;

    clp$convert_integer_to_rjstring (cpu_p^.ibs_degrade_bits, 16, TRUE, '0', string_5, ignore_status);
    STRINGREP (display_string, string_length, '     IBS Degrade Bits = ', string_5);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    IF cpu_p^.vector_option_installed = 0 THEN
      clp$put_display (display_control, '     Vector Option Installed', clc$trim, ignore_status);
    IFEND;

    IF cpu_p^.pmf_present = 0 THEN
      clp$put_display (display_control, '     PMF Present', clc$trim, ignore_status);
    IFEND;

    IF cpu_p^.processor_supports_180_state = 0 THEN
      clp$put_display (display_control, '     Processor Supports 180 State', clc$trim, ignore_status);
    IFEND;

    IF cpu_p^.processor_supports_170_state = 0 THEN
      clp$put_display (display_control, '     Processor Supports 170 State', clc$trim, ignore_status);
    IFEND;

    IF cpu_p^.on_off_status = 0 THEN
      clp$put_display (display_control, '     CPU is on', clc$trim, ignore_status);
    ELSE
      clp$put_display (display_control, '     CPU is logically off', clc$trim, ignore_status);
    IFEND;

    clp$convert_integer_to_rjstring (cpu_p^.div_net_result_select, 16, TRUE, '0', string_5, ignore_status);
    STRINGREP (display_string, string_length, '     DIV net result select = ', string_5);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (cpu_p^.div_net_sel_for_compare, 16, TRUE, '0', string_5, ignore_status);
    STRINGREP (display_string, string_length, '     DIV net sel for compare = ', string_5);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (cpu_p^.enable_maintenance_mode, 16, TRUE, '0', string_5, ignore_status);
    STRINGREP (display_string, string_length, '     Enable Maintenance Mode = ', string_5);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    IF cpu_p^.cpu0_instruction_stack = 1 THEN
      clp$put_display (display_control, '     No CPU-0 instruction stack', clc$trim, ignore_status);
    IFEND;

    IF cpu_p^.cmu_capability = 1 THEN
      clp$put_display (display_control, '     No CMU capability', clc$trim, ignore_status);
    IFEND;

    IF cpu_p^.cej_mej_capability = 1 THEN
      clp$put_display (display_control, '     No CEJ/MEJ capability', clc$trim, ignore_status);
    IFEND;

    IF cpu_p^.cpu1_not_available = 1 THEN
      clp$put_display (display_control, '     CPU-1 not available', clc$trim, ignore_status);
    IFEND;

    IF cpu_p^.cpu0_not_available = 1 THEN
      clp$put_display (display_control, '     CPU-0 not available', clc$trim, ignore_status);
    IFEND;

    clp$convert_integer_to_rjstring (cpu_p^.microcode_1_2, 8, TRUE, '0', string_7, ignore_status);
    STRINGREP (display_string, string_length, '     Characters 1 and 2 of microcode name = ', string_7);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (cpu_p^.microcode_3_4, 8, TRUE, '0', string_7, ignore_status);
    STRINGREP (display_string, string_length, '     Characters 3 and 4 of microcode name = ', string_7);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (cpu_p^.microcode_5_6, 8, TRUE, '0', string_7, ignore_status);
    STRINGREP (display_string, string_length, '     Characters 5 and 6 of microcode name = ', string_7);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (cpu_p^.microcode_7, 8, TRUE, '0', string_7, ignore_status);
    STRINGREP (display_string, string_length, '     Characters 7 of microcode name = ', string_7);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (cpu_p^.microcode_date_1_2, 8, TRUE, '0', string_7, ignore_status);
    STRINGREP (display_string, string_length, '     Characters 1 and 2 of microcode date (yy) = ', string_7);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (cpu_p^.microcode_date_3_4, 8, TRUE, '0', string_7, ignore_status);
    STRINGREP (display_string, string_length, '     Characters 3 and 4 of microcode date (mm) = ', string_7);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (cpu_p^.microcode_date_5_6, 8, TRUE, '0', string_7, ignore_status);
    STRINGREP (display_string, string_length, '     Characters 5 and 6 of microcode date (dd) = ', string_7);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (cpu_p^.theta_standard_option, 16, TRUE, '0', string_8, ignore_status);
    STRINGREP (display_string, string_length, '     Theta Standard Option = ', string_8);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (cpu_p^.pip3_fast_slow_clock_frequency, 16, TRUE, '0', string_5,
          ignore_status);
    STRINGREP (display_string, string_length, '     PIP3 fast/slow clock frequency = ', string_5);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (cpu_p^.pip3_init_clock_sys_flag, 16, TRUE, '0', string_5, ignore_status);
    STRINGREP (display_string, string_length, '     PIP3 initialize clock system flag = ', string_5);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    integer_data := (((cpu_p^.cpu_mps_rma_bits [1].bits * 1000(16)) + cpu_p^.cpu_mps_rma_bits [2].bits) *
          1000(16)) + cpu_p^.cpu_mps_rma_bits [3].bits;
    clp$convert_integer_to_rjstring (integer_data, 16, TRUE, '0', string_13, ignore_status);
    STRINGREP (display_string, string_length, '     CPU MPS RMA = ', string_13);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

  PROCEND display_cpu_data;
?? OLDTITLE ??
?? NEWTITLE := 'display_data_raw', EJECT ??

{ PURPOSE:
{   This procedure displays the MRT data raw.

  PROCEDURE display_data_raw
    (    descriptor_length: 0 .. 077(8);
     VAR restart_file_seq_p: ^SEQ ( * );
     VAR display_control: clt$display_control;
     VAR status: ost$status);

    TYPE
      t$data_line = RECORD
        CASE boolean OF
        = TRUE =
          line: string (50),
        = FALSE =
          unused_1: string (3),
          word_part: ARRAY [1 .. 4] OF t$word_part,
        CASEND,
      RECEND,

      t$word_part = RECORD
        data: string (4),
        unsed: string (2),
      RECEND;

    VAR
      data_line: t$data_line,
      ignore_status: ost$status,
      index: 0 .. 0ff(16),
      string_4: string (4),
      word_index: 0 .. 0ff(16),
      word_p: ^0 .. 0ffff(16);

    status.normal := TRUE;

    word_index := 1;
    data_line.line := ' ';
    FOR index := 1 TO descriptor_length DO
      NEXT word_p IN restart_file_seq_p;
      IF word_p = NIL THEN
        osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);
        RETURN;  {---->
      IFEND;
      clp$convert_integer_to_rjstring (word_p^, 16, FALSE, '0', string_4, ignore_status);
      data_line.word_part [word_index].data := string_4;
      IF word_index = 4 THEN
        clp$put_display (display_control, data_line.line, clc$trim, ignore_status);
        word_index := 1;
        data_line.line := ' ';
      ELSE
        word_index := word_index + 1;
      IFEND;
    FOREND;
    IF word_index > 1 THEN
      clp$put_display (display_control, data_line.line, clc$trim, ignore_status);
    IFEND;

  PROCEND display_data_raw;
?? OLDTITLE ??
?? NEWTITLE := 'display_dft_data', EJECT ??

{ PURPOSE:
{   This procedure displays the DFT data from the MRT in detail.

  PROCEDURE display_dft_data
    (VAR display_control: clt$display_control;
     VAR restart_file_seq_p: ^SEQ ( * );
     VAR status: ost$status);

    TYPE
      t$dft = PACKED RECORD
        descriptor_id: dst$mrt_descriptor_id,
        unused_1: 0 .. 0fff(16),
        upper_size: 0 .. 0f(16),
        unused_2: 0 .. 0f(16),
        lower_size: 0 .. 0fff(16),
        unused_3: 0 .. 0f(16),
        version_level: 0 .. 03f(16),
        unused_4: 0 .. 01f(16),
        dft_version_flag: 0 .. 1,
        unused_5: 0 .. 0ffff(16),
      RECEND;

    VAR
      dft_p: ^t$dft,
      display_string: string (osc$max_string_size),
      ignore_status: ost$status,
      string_5: string (5),
      string_8: string (8),
      string_length: integer,
      total_size: 0 .. 0ffff(16);

    status.normal := TRUE;
    clp$put_display (display_control, '   DETAIL:', clc$trim, ignore_status);
    NEXT dft_p IN restart_file_seq_p;
    IF dft_p = NIL THEN
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);
      RETURN;  {---->
    IFEND;

    total_size := (dft_p^.upper_size * 1000(16)) + dft_p^.lower_size;
    clp$convert_integer_to_rjstring (total_size, 16, TRUE, '0', string_8, ignore_status);
    STRINGREP (display_string, string_length,
          '     Total size in CM words to be allocated for the DFT/OS buffer = ', string_8);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (dft_p^.version_level, 8, TRUE, '0', string_5, ignore_status);
    STRINGREP (display_string, string_length, '     Most recent DFT/OS Buffer version level = ', string_5);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);
    clp$put_display (display_control, '        (77(8) means OS boot is not installed)', clc$trim,
          ignore_status);

    IF dft_p^.dft_version_flag = 0 THEN
      clp$put_display (display_control, '     DFT Version Flag = 0', clc$trim, ignore_status);
    ELSE
      clp$put_display (display_control, '     DFT Version Flag = 1', clc$trim, ignore_status);
    IFEND;

  PROCEND display_dft_data;
?? OLDTITLE ??
?? NEWTITLE := 'display_element_id', EJECT ??

{ PURPOSE:
{   This procedure displays the element id information.

  PROCEDURE display_element_id
    (VAR display_control: clt$display_control;
     VAR restart_file_seq_p: ^SEQ ( * );
     VAR status: ost$status);

    TYPE
      t$element_data = RECORD
        CASE boolean OF
        = TRUE =
          line: string (50),
        = FALSE =
          space_1: string (5),
          element_name: string (8),
          element: string (2),
          space_2: string (2),
          model_name: string (6),
          model: string (2),
          space_3: string (2),
          serial_name: string (7),
          serial_1: string (1),
          serial_2: string (3),
        CASEND,
      RECEND,

      t$element_id = PACKED RECORD
        unused_1: 0 .. 0ff(16),
        element: 0 .. 0ff(16),
        unused_2: 0 .. 0f(16),
        model: 0 .. 0ff(16),
        serial_1: 0 .. 0f(16),
        unused_3: 0 .. 0f(16),
        serial_2: 0 .. 0fff(16),
      RECEND;

    VAR
      element_data: t$element_data,
      element_id_p: ^t$element_id,
      ignore_status: ost$status;

    status.normal := TRUE;
    NEXT element_id_p IN restart_file_seq_p;
    IF element_id_p = NIL THEN
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);
      RETURN;  {---->
    IFEND;
    element_data.line := ' ';
    element_data.element_name := 'ELEMENT=';
    clp$convert_integer_to_rjstring (element_id_p^.element, 16, FALSE, '0', element_data.element,
          ignore_status);
    element_data.model_name := 'MODEL=';
    clp$convert_integer_to_rjstring (element_id_p^.model, 16, FALSE, '0', element_data.model,
          ignore_status);
    element_data.serial_name := 'SERIAL=';
    clp$convert_integer_to_rjstring (element_id_p^.serial_1, 16, FALSE, '0', element_data.serial_1,
          ignore_status);
    clp$convert_integer_to_rjstring (element_id_p^.serial_2, 16, FALSE, '0', element_data.serial_2,
          ignore_status);
    clp$put_display (display_control, element_data.line, clc$trim, ignore_status);

  PROCEND display_element_id;
?? OLDTITLE ??
?? NEWTITLE := 'display_global_processor_data', EJECT ??

{ PURPOSE:
{   This procedure displays the global processor data from the MRT in detail.

  PROCEDURE display_global_processor_data
    (VAR display_control: clt$display_control;
     VAR restart_file_seq_p: ^SEQ ( * );
     VAR status: ost$status);

    VAR
      global_processor_p: ^dst$mrt_global_processor_info,
      display_string: string (osc$max_string_size),
      ignore_status: ost$status,
      string_4: string (4),
      string_5: string (5),
      string_6: string (6),
      string_7: string (7),
      string_8: string (8),
      string_length: integer;

    status.normal := TRUE;
    clp$put_display (display_control, '   DETAIL:', clc$trim, ignore_status);
    NEXT global_processor_p IN restart_file_seq_p;
    IF global_processor_p = NIL THEN
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);
      RETURN;  {---->
    IFEND;

    clp$convert_integer_to_rjstring (global_processor_p^.micro_long_init, 16, TRUE, '0', string_8,
          ignore_status);
    STRINGREP (display_string, string_length, '     Microcode Long Init address = ', string_8);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (global_processor_p^.micro_idle_short_init, 16, TRUE, '0', string_8,
          ignore_status);
    STRINGREP (display_string, string_length, '     Microcode Idle or Short Init address = ', string_8);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (global_processor_p^.micro_mps_heo, 16, TRUE, '0', string_8,
          ignore_status);
    STRINGREP (display_string, string_length, '     Microcode MPS Half Exchange Out address = ', string_8);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (global_processor_p^.micro_jps_heo, 16, TRUE, '0', string_8,
          ignore_status);
    STRINGREP (display_string, string_length, '     Microcode JPS Half Exchange Out address = ', string_8);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (global_processor_p^.micro_mps_hei, 16, TRUE, '0', string_8,
          ignore_status);
    STRINGREP (display_string, string_length, '     Microcode MPS Half Exchange In address = ', string_8);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (global_processor_p^.micro_jps_hei, 16, TRUE, '0', string_8,
          ignore_status);
    STRINGREP (display_string, string_length, '     Microcode JPS Half Exchange In address = ', string_8);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (global_processor_p^.pte, 8, TRUE, '0', string_4, ignore_status);
    STRINGREP (display_string, string_length, '     # of page table entries per page of real memory = ',
          string_4);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (global_processor_p^.ptl, 16, TRUE, '0', string_7, ignore_status);
    STRINGREP (display_string, string_length, '     Page Table length = ', string_7);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (global_processor_p^.page_size, 16, TRUE, '0', string_8, ignore_status);
    STRINGREP (display_string, string_length, '     Page size in K bytes = ', string_8);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    IF global_processor_p^.secure_analysis THEN
      clp$put_display (display_control, '     Secure mode bit is set', clc$trim, ignore_status);
    ELSE
      clp$put_display (display_control, '     Secure mode bit is not set', clc$trim, ignore_status);
    IFEND;

    IF global_processor_p^.state_flag THEN
      clp$put_display (display_control, '     State Flag = C180', clc$trim, ignore_status);
    ELSE
      clp$put_display (display_control, '     State Flag = C170', clc$trim, ignore_status);
    IFEND;

    IF global_processor_p^.carriage_return THEN
      clp$put_display (display_control,
            '     Operator entered "CR" from the initial CTI display or the *O* display', clc$trim,
            ignore_status);
    IFEND;

    IF global_processor_p^.disk_deadstart THEN
      clp$put_display (display_control, '     Operator entered "D" from CTI *O* display', clc$trim,
            ignore_status);
    IFEND;

    IF global_processor_p^.tape_deadstart THEN
      clp$put_display (display_control, '     Operator entered "T" from CTI *O* display', clc$trim,
            ignore_status);
    IFEND;

    clp$convert_integer_to_rjstring (global_processor_p^.cip_channel, 8, TRUE, '0', string_5, ignore_status);
    STRINGREP (display_string, string_length, '     CIP Channel = ', string_5);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (global_processor_p^.cip_disk_type, 8, TRUE, '0', string_6,
          ignore_status);
    STRINGREP (display_string, string_length, '     CIP Disk Type = ', string_6);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (global_processor_p^.cip_disk_unit, 8, TRUE, '0', string_6,
          ignore_status);
    STRINGREP (display_string, string_length, '     CIP Disk Unit = ', string_6);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (global_processor_p^.reserved_2, 16, TRUE, '0', string_8,
          ignore_status);
    STRINGREP (display_string, string_length,
          '     CM size from previous power on initialization deadstart = ', string_8);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (global_processor_p^.reserved_3, 16, TRUE, '0', string_8,
          ignore_status);
    STRINGREP (display_string, string_length,
          '     EI MPS offset from previous power on initialization deadstart = ', string_8);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (global_processor_p^.reserved_4, 16, TRUE, '0', string_8,
          ignore_status);
    STRINGREP (display_string, string_length, '     PTL value for larger memory sizes = ', string_8);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

  PROCEND display_global_processor_data;
?? OLDTITLE ??
?? NEWTITLE := 'display_iou_data', EJECT ??

{ PURPOSE:
{   This procedure displays the iou data from the MRT in detail.

  PROCEDURE display_iou_data
    (VAR display_control: clt$display_control;
     VAR restart_file_seq_p: ^SEQ ( * );
     VAR status: ost$status);

    TYPE
      t$iou = PACKED RECORD
        descriptor_id: dst$mrt_descriptor_id,
        element_id: dst$mrt_element_id,
        maintenance_channel_id: dst$mrt_maintenance_channel_id,
        pps_physically_missing: 0 .. 0ffffffff(16),
        pps_logically_missing: 0 .. 0ffffffff(16),
        pad_1: 0 .. 17777(8),
        pp_speed: 0 .. 7(8),
        channels_missing: 0 .. 0ffffffff(16),
        physically_present_cio_pps: 0 .. 0ffff(16),
        logically_present_cio_pps: 0 .. 0ffff(16),
        physically_present_cio_channels: 0 .. 0ffff(16),
        pps_0_11b_up_down_status: 0 .. 0ffff(16),
        pps_20b_31b_up_down_status: 0 .. 0ffff(16),
        i4_cio_pps_up_down_status: 0 .. 0ffff(16),
        channels: ARRAY [1 .. 12] OF 0 .. 0ffff(16),
        cio_channels: ARRAY [1 .. 5] OF 0 .. 0ffff(16),
        pad_2: 0 .. 77777(8),
        iou_logically_off: boolean,
      RECEND;

    VAR
      cell_p: ^cell,
      descriptor_p: ^0 .. 0ffff(16),
      display_string: string (osc$max_string_size),
      ignore_status: ost$status,
      index: 0 .. 0f(16),
      integer_data: 0 .. 0fffffffff(16),
      iou_p: ^t$iou,
      string_5: string (5),
      string_8: string (8),
      string_12: string (12),
      string_length: integer;

    status.normal := TRUE;
    clp$put_display (display_control, '   DETAIL:', clc$trim, ignore_status);
    NEXT cell_p IN restart_file_seq_p;
    IF cell_p = NIL THEN
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);
      RETURN;  {---->
    IFEND;
    RESET restart_file_seq_p TO cell_p;
    NEXT descriptor_p IN restart_file_seq_p;
    IF descriptor_p = NIL THEN
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);
      RETURN;  {---->
    IFEND;
    display_element_id (display_control, restart_file_seq_p, status);
    IF NOT status.normal THEN
      RETURN;  {---->
    IFEND;
    RESET restart_file_seq_p TO cell_p;
    NEXT iou_p IN restart_file_seq_p;
    IF iou_p = NIL THEN
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);
      RETURN;  {---->
    IFEND;

    clp$convert_integer_to_rjstring (iou_p^.maintenance_channel_id.port, 16, TRUE, '0', string_5,
          ignore_status);
    STRINGREP (display_string, string_length, '     Maintenance Channel Port = ', string_5);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (iou_p^.maintenance_channel_id.type_code, 16, TRUE, '0', string_5,
          ignore_status);
    STRINGREP (display_string, string_length, '     Maintenance Channel Type Code = ', string_5);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (iou_p^.pps_physically_missing, 16, TRUE, '0', string_12, ignore_status);
    STRINGREP (display_string, string_length, '     PPs Physically Missing = ', string_12);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (iou_p^.pps_logically_missing, 16, TRUE, '0', string_12, ignore_status);
    STRINGREP (display_string, string_length, '     PPs Logically Missing = ', string_12);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (iou_p^.pp_speed, 16, TRUE, '0', string_5, ignore_status);
    STRINGREP (display_string, string_length, '     PP Speed = ', string_5);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (iou_p^.channels_missing, 16, TRUE, '0', string_12, ignore_status);
    STRINGREP (display_string, string_length, '     Channels Missing = ', string_12);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (iou_p^.physically_present_cio_pps, 16, TRUE, '0', string_8,
          ignore_status);
    STRINGREP (display_string, string_length, '     Physically present CIO PPs = ', string_8);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (iou_p^.logically_present_cio_pps, 16, TRUE, '0', string_8,
          ignore_status);
    STRINGREP (display_string, string_length, '     Logically present CIO PPs = ', string_8);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (iou_p^.physically_present_cio_channels, 16, TRUE, '0', string_8,
          ignore_status);
    STRINGREP (display_string, string_length, '     Physically present CIO Channels = ', string_8);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (iou_p^.pps_0_11b_up_down_status, 16, TRUE, '0', string_8, ignore_status);
    STRINGREP (display_string, string_length, '     PPs 0-11(8) UP/DOWN Status = ', string_8);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (iou_p^.pps_20b_31b_up_down_status, 16, TRUE, '0', string_8,
          ignore_status);
    STRINGREP (display_string, string_length, '     PPs 20(8)-31(8) UP/DOWN Status = ', string_8);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (iou_p^.i4_cio_pps_up_down_status, 16, TRUE, '0', string_8,
          ignore_status);
    STRINGREP (display_string, string_length, '     I4 CIO PPs UP/DOWN Status = ', string_8);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    FOR index := 1 TO 12 DO
      clp$convert_integer_to_rjstring (iou_p^.channels [index], 16, TRUE, '0', string_8, ignore_status);
      STRINGREP (display_string, string_length, '     Channels UP/DOWN Status = ', string_8);
      clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);
    FOREND;

    FOR index := 1 TO 5 DO
      clp$convert_integer_to_rjstring (iou_p^.cio_channels [index], 16, TRUE, '0', string_8, ignore_status);
      STRINGREP (display_string, string_length, '     CIO Channels UP/DOWN Status = ', string_8);
      clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);
    FOREND;

    IF iou_p^.iou_logically_off THEN
      clp$put_display (display_control, '     IOU is logically OFF', clc$trim, ignore_status);
    IFEND;

  PROCEND display_iou_data;
?? OLDTITLE ??
?? NEWTITLE := 'display_mainframe_data', EJECT ??

{ PURPOSE:
{   This procedure displays the mainframe data from the MRT in detail.

  PROCEDURE display_mainframe_data
    (VAR display_control: clt$display_control;
     VAR restart_file_seq_p: ^SEQ ( * );
     VAR status: ost$status);

    VAR
      display_string: string (osc$max_string_size),
      ignore_status: ost$status,
      mainframe_p: ^dst$mrt_mainframe_info,
      string_7: string (7),
      string_length: integer;

    status.normal := TRUE;
    clp$put_display (display_control, '   DETAIL:', clc$trim, ignore_status);
    NEXT mainframe_p IN restart_file_seq_p;
    IF mainframe_p = NIL THEN
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);
      RETURN;  {---->
    IFEND;

    IF NOT mainframe_p^.r_register_not_available THEN
      clp$put_display (display_control, '     0 = R register available', clc$trim, ignore_status);
    IFEND;

    IF NOT mainframe_p^.not_c176 THEN
      clp$put_display (display_control, '     0 = C176', clc$trim, ignore_status);
    IFEND;

    IF NOT mainframe_p^.not_c170_700 THEN
      clp$put_display (display_control, '     0 = C170-700 (Model D)', clc$trim, ignore_status);
    IFEND;

    IF NOT mainframe_p^.interlock_register_not_present THEN
      clp$put_display (display_control, '     0 = interlock register present', clc$trim, ignore_status);
    IFEND;

    IF NOT mainframe_p^.scr_not_present THEN
      clp$put_display (display_control, '     0 = SCR or 865/875 Maintenance register present', clc$trim,
            ignore_status);
    IFEND;

    IF NOT mainframe_p^.no_cem_pem THEN
      clp$put_display (display_control, '     0 = CEM/PEM', clc$trim, ignore_status);
    IFEND;

    clp$convert_integer_to_rjstring (mainframe_p^.physical_processors_present, 8, TRUE, '0', string_7,
          ignore_status);
    STRINGREP (display_string, string_length, '     Physical Processors Present = ', string_7);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (mainframe_p^.char_1_2_ei_date, 8, TRUE, '0', string_7, ignore_status);
    STRINGREP (display_string, string_length, '     EI Date (yy) = ', string_7);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (mainframe_p^.char_3_4_ei_date, 8, TRUE, '0', string_7, ignore_status);
    STRINGREP (display_string, string_length, '     EI Date (mm) = ', string_7);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (mainframe_p^.char_5_6_ei_date, 8, TRUE, '0', string_7, ignore_status);
    STRINGREP (display_string, string_length, '     EI Date (dd) = ', string_7);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (mainframe_p^.ei_level, 8, TRUE, '0', string_7, ignore_status);
    STRINGREP (display_string, string_length, '     EI Level = ', string_7);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

  PROCEND display_mainframe_data;
?? OLDTITLE ??
?? NEWTITLE := 'display_memory_data', EJECT ??

{ PURPOSE:
{   This procedure displays the memory data from the MRT in detail.

  PROCEDURE display_memory_data
    (VAR display_control: clt$display_control;
     VAR restart_file_seq_p: ^SEQ ( * );
     VAR status: ost$status);

    TYPE
      t$cm_address = PACKED RECORD
        unused_1: 0 .. 0f(16),
        upper: 0 .. 0fff(16),
        unused_2: 0 .. 0f(16),
        lower: 0 .. 0fff(16),
      RECEND,

      t$memory = PACKED RECORD
        descriptor_id: dst$mrt_descriptor_id,
        element_id: dst$mrt_element_id,
        maintenance_channel_id: dst$mrt_maintenance_channel_id,
        physical_cm: t$cm_address,
        available_cm: t$cm_address,
        physical_cm_in_octal: 0 .. 0ffff(16),
        cip_directory: t$r_register,
        operator_entered_cm: t$cm_address,
        unused_4: 0 .. 0f(16),
        nos_or_nbe_page_table: 0 .. 0fff(16),
        ei: t$r_register,
      RECEND,

      t$r_register = PACKED RECORD
        unused_1: 0 .. 3f(16),
        msb_10_bits: 0 .. 3ff(16),
        unused_2: 0 .. 0f(16),
        lsb_12_bits: 0 .. 0fff(16),
        unused_3: 0 .. 3ff(16),
        lsb_6_bits: 0 .. 03f(16),
      RECEND;

    VAR
      cell_p: ^cell,
      descriptor_p: ^0 .. 0ffff(16),
      display_string: string (osc$max_string_size),
      ignore_status: ost$status,
      integer_data_6: 0 .. 0ffffff(16),
      integer_data_octal: 0 .. 1777777777(8),
      memory_p: ^t$memory,
      string_5: string (5),
      string_7: string (7),
      string_10: string (10),
      string_11: string (11),
      string_length: integer;

    status.normal := TRUE;
    clp$put_display (display_control, '   DETAIL:', clc$trim, ignore_status);
    NEXT cell_p IN restart_file_seq_p;
    IF cell_p = NIL THEN
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);
      RETURN;  {---->
    IFEND;
    RESET restart_file_seq_p TO cell_p;
    NEXT descriptor_p IN restart_file_seq_p;
    IF descriptor_p = NIL THEN
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);
      RETURN;  {---->
    IFEND;
    display_element_id (display_control, restart_file_seq_p, status);
    IF NOT status.normal THEN
      RETURN;  {---->
    IFEND;
    RESET restart_file_seq_p TO cell_p;
    NEXT memory_p IN restart_file_seq_p;
    IF memory_p = NIL THEN
      osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);
      RETURN;  {---->
    IFEND;

    clp$convert_integer_to_rjstring (memory_p^.maintenance_channel_id.port, 16, TRUE, '0', string_5,
          ignore_status);
    STRINGREP (display_string, string_length, '     Maintenance Channel Port = ', string_5);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (memory_p^.maintenance_channel_id.type_code, 16, TRUE, '0', string_5,
          ignore_status);
    STRINGREP (display_string, string_length, '     Maintenance Channel Type Code = ', string_5);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    integer_data_6 := (memory_p^.physical_cm.upper * 1000(16)) + memory_p^.physical_cm.lower;
    clp$convert_integer_to_rjstring (integer_data_6, 16, TRUE, '0', string_10, ignore_status);
    STRINGREP (display_string, string_length, '     Physical CM Size/100(8) (in words) = ', string_10);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    integer_data_6 := (memory_p^.available_cm.upper * 1000(16)) + memory_p^.available_cm.lower;
    clp$convert_integer_to_rjstring (integer_data_6, 16, TRUE, '0', string_10, ignore_status);
    STRINGREP (display_string, string_length, '     Available CM Size/100(8) (in words) = ', string_10);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (memory_p^.physical_cm_in_octal, 8, TRUE, '0', string_7, ignore_status);
    STRINGREP (display_string, string_length, '     Physical CM size in octal MB = ', string_7);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    integer_data_octal := (((memory_p^.cip_directory.msb_10_bits * 10000(8)) +
          memory_p^.cip_directory.lsb_12_bits) * 100(8)) + memory_p^.cip_directory.lsb_6_bits;
    clp$convert_integer_to_rjstring (integer_data_octal, 16, TRUE, '0', string_11, ignore_status);
    STRINGREP (display_string, string_length,
          '     R register value of the FWA of the CIP directory in CM = ', string_11);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    integer_data_6 := (memory_p^.operator_entered_cm.upper * 1000(16)) + memory_p^.operator_entered_cm.lower;
    clp$convert_integer_to_rjstring (integer_data_6, 16, TRUE, '0', string_10, ignore_status);
    STRINGREP (display_string, string_length, '     Operator Entered CM Size/100(8) (in words) = ',
          string_10);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$convert_integer_to_rjstring (memory_p^.nos_or_nbe_page_table, 16, TRUE, '0', string_7, ignore_status);
    STRINGREP (display_string, string_length, '     NOS or NBE Page Table Length = ', string_7);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    integer_data_octal := (((memory_p^.ei.msb_10_bits * 10000(8)) + memory_p^.ei.lsb_12_bits) * 100(8)) +
          memory_p^.ei.lsb_6_bits;
    clp$convert_integer_to_rjstring (integer_data_octal, 16, TRUE, '0', string_11, ignore_status);
    STRINGREP (display_string, string_length,
          '     Most significant 10 bits of R reg of EI request word = ', string_11);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

  PROCEND display_memory_data;
?? OLDTITLE ??
?? NEWTITLE := 'dup$display_mrt_data_command', EJECT ??

{ PURPOSE:
{   This procedure displays the MRT data from the EIC record.

  PROCEDURE [XDCL] dup$display_mrt_data_command
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{ PROCEDURE display_mrt_data, dismd (
{   output, o: file = $optional
{   title, t: string 1..31 = 'display_mrt_data'
{   status)

?? PUSH (LISTEXT := ON) ??
?? FMT (FORMAT := OFF) ??
  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 5] of clt$pdt_parameter_name,
      parameters: array [1 .. 3] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
      recend,
      type2: record
        header: clt$type_specification_header,
        qualifier: clt$string_type_qualifier,
        default_value: string (18),
      recend,
      type3: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [90, 4, 20, 9, 39, 13, 361],
    clc$command, 5, 3, 0, 0, 0, 0, 3, ''], [
    ['O                              ',clc$abbreviation_entry, 1],
    ['OUTPUT                         ',clc$nominal_entry, 1],
    ['STATUS                         ',clc$nominal_entry, 3],
    ['T                              ',clc$abbreviation_entry, 2],
    ['TITLE                          ',clc$nominal_entry, 2]],
    [
{ PARAMETER 1
    [2, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$optional_parameter, 0
  , 0],
{ PARAMETER 2
    [5, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 8,
  clc$optional_default_parameter, 0, 18],
{ PARAMETER 3
    [3, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$file_type]],
{ PARAMETER 2
    [[1, 0, clc$string_type], [1, 31, FALSE],
    '''display_mrt_data'''],
{ PARAMETER 3
    [[1, 0, clc$status_type]]];
?? FMT (FORMAT := ON) ??
?? POP ??

    CONST
      p$output = 1,
      p$title = 2,
      p$status = 3;

    VAR
      pvt: array [1 .. 3] of clt$parameter_value;

    TYPE
      t$descriptor = PACKED RECORD
        CASE boolean OF
        = TRUE =
          header: 0 .. 0ffff(16),
        = FALSE =
          unused: 0 .. 0f(16),
          length: 0 .. 077(8),
          id: 0 .. 077(8),
        CASEND,
      RECEND;

    VAR
      cell_p: ^cell,
      cell_2_p: ^cell,
      cip_program_available: boolean,
      cip_program_cell_p: ^cell,
      descriptor_p: ^t$descriptor,
      display_control: clt$display_control,
      display_string: string (osc$max_string_size),
      ignore_status: ost$status,
      level_address_size: integer,
      output_display_opened: boolean,
      restart_file_seq_p: ^SEQ ( * ),
      ring_attributes: amt$ring_attributes,
      skip_integer_p: ^integer,
      skip_p: ^SEQ ( * ),
      size_p: ^0 .. 0ffff(16),
      string_length: integer;

*copy dup$abort_handler
?? NEWTITLE := 'clean_up', EJECT ??

{ PURPOSE:
{   This procedure is called from the abort handler to close the file.

    PROCEDURE [INLINE] clean_up;

      VAR
        ignore_status: ost$status;

      IF output_display_opened THEN
        clp$close_display (display_control, ignore_status);
      IFEND;

    PROCEND clean_up;

?? OLDTITLE, EJECT ??

    status.normal := TRUE;
    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN;  {---->
    IFEND;

    IF duv$dump_environment_p = NIL THEN
      osp$set_status_abnormal (duc$dump_analyzer_id, due$no_restart_file, '', status);
      RETURN;  {---->
    IFEND;

    output_display_opened := FALSE;
    osp$establish_block_exit_hndlr (^abort_handler);

   /display_opened/
    BEGIN

      { Prepare the output display file.

      IF pvt [p$output].specified THEN
        ring_attributes.r1 := #RING (^ring_attributes);
        ring_attributes.r2 := #RING (^ring_attributes);
        ring_attributes.r3 := #RING (^ring_attributes);
        clp$open_display_reference (pvt [p$output].value^.file_value^, ^dup$new_page_procedure, fsc$list,
              ring_attributes, display_control, status);
        IF NOT status.normal THEN
          EXIT /display_opened/;  {---->
        IFEND;
        output_display_opened := TRUE;
      ELSE
        display_control := duv$execution_environment.output_file.display_control;
        display_control.line_number := display_control.page_length + 1;
      IFEND;

      duv$title_data.build_title := TRUE;
      duv$title_data.command_name := pvt [p$title].value^.string_value^;

      restart_file_seq_p := duv$execution_environment.data_file_p^.segment_pointer.sequence_pointer;
      dup$retrieve_cip_program ('2AP ', cip_program_available, cip_program_cell_p);
      IF NOT cip_program_available THEN
        clp$put_display (display_control, ' ERROR - Cannot retrieve the 2AP CIP program.', clc$trim,
              ignore_status);
        EXIT /display_opened/;  {---->
      IFEND;
      RESET restart_file_seq_p TO cip_program_cell_p;
      NEXT skip_integer_p IN restart_file_seq_p;
      IF skip_integer_p = NIL THEN
        osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);
        EXIT /display_opened/;  {---->
      IFEND;
      NEXT size_p IN restart_file_seq_p;
      IF size_p = NIL THEN
        osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);
        EXIT /display_opened/;  {---->
      IFEND;
      level_address_size := (size_p^ * 2) + 8;
      RESET restart_file_seq_p TO cip_program_cell_p;
      NEXT skip_p: [[REP level_address_size OF cell]] IN restart_file_seq_p;
      IF skip_p = NIL THEN
        osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);
        EXIT /display_opened/;  {---->
      IFEND;

      WHILE TRUE DO
        NEXT cell_p IN restart_file_seq_p;
        IF cell_p = NIL THEN
          osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);
          EXIT /display_opened/;  {---->
        IFEND;
        RESET restart_file_seq_p TO cell_p;
        NEXT descriptor_p IN restart_file_seq_p;
        IF descriptor_p = NIL THEN
          osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);
          EXIT /display_opened/;  {---->
        IFEND;
        IF descriptor_p^.header = 0 THEN
          EXIT /display_opened/;
        IFEND;
        clp$put_display (display_control, '*******************************************************',
              clc$trim, ignore_status);

        IF descriptor_p^.id = 0 THEN
          STRINGREP (display_string, string_length, ' IOU (length=', descriptor_p^.length, ')');
        ELSEIF descriptor_p^.id = 1 THEN
          STRINGREP (display_string, string_length, ' MEMORY (length=', descriptor_p^.length, ')');
        ELSEIF descriptor_p^.id = 2 THEN
          STRINGREP (display_string, string_length, ' CPU (length=', descriptor_p^.length, ')');
        ELSEIF descriptor_p^.id = 3 THEN
          STRINGREP (display_string, string_length, ' MAINFRAME (length=', descriptor_p^.length, ')');
        ELSEIF descriptor_p^.id = 4 THEN
          STRINGREP (display_string, string_length, ' FLPP (length=', descriptor_p^.length, ')');
        ELSEIF descriptor_p^.id = 5 THEN
          STRINGREP (display_string, string_length, ' CONSOLE (length=', descriptor_p^.length, ')');
        ELSEIF descriptor_p^.id = 6 THEN
          STRINGREP (display_string, string_length, ' GLOBAL PROCESSOR (length=', descriptor_p^.length, ')');
        ELSEIF descriptor_p^.id = 8 THEN
          STRINGREP (display_string, string_length, ' DATE/TIME/FRC (length=', descriptor_p^.length, ')');
        ELSEIF descriptor_p^.id = 9 THEN
          STRINGREP (display_string, string_length, ' S0 DATA (length=', descriptor_p^.length, ')');
        ELSEIF descriptor_p^.id = 10 THEN
          STRINGREP (display_string, string_length, ' PAGE MAP (length=', descriptor_p^.length, ')');
        ELSEIF descriptor_p^.id = 11 THEN
          STRINGREP (display_string, string_length, ' DFT/OS (length=', descriptor_p^.length, ')');
        ELSE
          STRINGREP (display_string, string_length, ' UNKNOWN (length=', descriptor_p^.length, ')');
        IFEND;
        clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

        RESET restart_file_seq_p TO cell_p;
        display_data_raw (descriptor_p^.length, restart_file_seq_p, display_control, status);
        IF NOT status.normal THEN
          EXIT /display_opened/;  {---->
        IFEND;

        NEXT cell_2_p IN restart_file_seq_p;
        IF cell_2_p = NIL THEN
          osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);
          EXIT /display_opened/;  {---->
        IFEND;
        RESET restart_file_seq_p TO cell_p;

        IF descriptor_p^.id = 0 THEN
          display_iou_data (display_control, restart_file_seq_p, status);
        ELSEIF descriptor_p^.id = 1 THEN
          display_memory_data (display_control, restart_file_seq_p, status);
        ELSEIF descriptor_p^.id = 2 THEN
          display_cpu_data (display_control, restart_file_seq_p, status);
        ELSEIF descriptor_p^.id = 3 THEN
          display_mainframe_data (display_control, restart_file_seq_p, status);
        ELSEIF descriptor_p^.id = 4 THEN
        ELSEIF descriptor_p^.id = 5 THEN
          display_console_data (display_control, restart_file_seq_p, status);
        ELSEIF descriptor_p^.id = 6 THEN
          display_global_processor_data (display_control, restart_file_seq_p, status);
        ELSEIF descriptor_p^.id = 8 THEN
          display_clock_data (display_control, restart_file_seq_p, status);
        ELSEIF descriptor_p^.id = 9 THEN
        ELSEIF descriptor_p^.id = 10 THEN
        ELSEIF descriptor_p^.id = 11 THEN
          display_dft_data (display_control, restart_file_seq_p, status);
        ELSE
        IFEND;
        IF NOT status.normal THEN
          EXIT /display_opened/;  {---->
        IFEND;

        RESET restart_file_seq_p TO cell_2_p;

      WHILEND;
    END /display_opened/;

    IF output_display_opened THEN
      clp$close_display (display_control, ignore_status);
    IFEND;
    osp$disestablish_cond_handler;

  PROCEND dup$display_mrt_data_command;
MODEND dum$display_mrt_data_command;
