?? RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE Dump Analyzer : Process DFT Buffer Command' ??
MODULE dum$process_dft_buffer_command;

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

?? NEWTITLE := 'Global Declarations Referenced by This Module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc dst$dft_analysis_code_constants
*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$determine_dump_information
*copyc dup$new_page_procedure
*copyc osp$disestablish_cond_handler
*copyc osp$establish_block_exit_hndlr
*copyc dup$retrieve_dft_pointers
*copyc dup$retrieve_register
*copyc osp$set_status_abnormal
?? EJECT ??
*copyc duv$dump_environment_p
*copyc duv$execution_environment
*copyc duv$title_data
?? OLDTITLE ??
?? NEWTITLE := 'Global Declarations Declared by This Module', EJECT ??

  CONST
    c$message_size = 62,
    c$number_of_iou = 0D(16),
    c$number_of_memory = 09(16),
    c$number_of_cpu = 32(16),
    c$number_of_page_map = 02(16),
    c$number_of_bad_requests = 09(16),
    c$number_of_packet = 07(16),
    c$number_of_software = 2C(16),
    c$number_of_non = 0A(16),
    c$number_of_dft_messages = c$number_of_iou + c$number_of_memory + c$number_of_cpu +
          c$number_of_page_map + c$number_of_bad_requests + c$number_of_packet + c$number_of_software +
          c$number_of_non,

    c$number_of_os_actions = 1d(16),
    c$number_of_priorities = 6;

  TYPE
    t$date_time = RECORD
      CASE boolean OF
      = TRUE =
        skip: 0 .. 0ff(16),
        year: 0 .. 0ff(16),
        month: 0 .. 0ff(16),
        day: 0 .. 0ff(16),
        hour: 0 .. 0ff(16),
        minute: 0 .. 0ff(16),
        second: 0 .. 0ff(16),
        rfu: 0 .. 0ff(16),
      = FALSE =
        data: integer,
      CASEND,
    RECEND,

    t$date_time_string = RECORD
      CASE boolean OF
      = TRUE =
        month: string (2),
        slash_1: string (1),
        day: string (2),
        slash_2: string (1),
        year: string (2),
        spaces: string (2),
        hour: string (2),
        period_1: string (1),
        minute: string (2),
        period_2: string (1),
        second: string (2),
      = FALSE =
        data: string (20),
      CASEND,
    RECEND,

    t$descriptor_line = RECORD
      CASE boolean OF
      = TRUE =
        register_string: string (19),
        spaces: string (3),
        description: string (38),
      = FALSE =
        data: string (60),
      CASEND,
    RECEND,

    t$dft_message = RECORD
      dft_analysis_code: dst$dftb_dft_analysis_code,
      value: string (c$message_size),
    RECEND,

    t$fault_symptom_code = RECORD
      rfu: 0 .. 0ffffffff(16),
      CASE boolean OF
      = TRUE =
        code: string (12),
      = FALSE =
        code_array: ARRAY [1 .. 12] OF 0 .. 0ff(16),
      CASEND,
    RECEND,

    t$mdb_control_word = PACKED RECORD
      rfu_1: 0 .. 0f(16),
      long_term_interlock_flag: 0 .. 0f(16),
      control_word_offset: 0 .. 0ff(16),
      priority: 0 .. 0f(16),
      sequence_number: 0 .. 0ff(16),
      rfu_2: 0 .. 0fffff(16),
      length_to_log: 0 .. 0ffff(16),
    RECEND,

    t$sorted = RECORD
      sequence: dst$dftb_sequence_number,
      index: dst$dftb_element_size,
    RECEND;
?? EJECT ??

  VAR
    v$dash: string (76) := '   -------------------------------------------------------------------------',
    v$data: dut$dft_data := [0, 0, 0, 0, [REP (duc$dft_max_known_pointer_words + 1) OF [NIL, 0, FALSE]],
          [REP duc$dft_max_mdb_buffers OF [NIL, 0, FALSE]]],
    v$display_capture_buffer: boolean,
    v$display_control: clt$display_control,
    v$nil_error: string (49) := ' -- ERROR -- Encountered an internal NIL pointer.',
    v$restart_file_seq_p: ^SEQ ( * ),
    v$star: string (76) := ' ***************************************************************************';
?? EJECT ??

  VAR
    { This variable contains the constant log messages for the messages created from the dft errors and from
    { system detected errors that have a dft analysis code described in dst$dft_analysis_code_constants.  IF
    { new error codes are added three decks must be changed.  This deck and CTI$DFT_ANALYSIS_CODES and
    { DST$DFT_ANALYSIS_CODE_CONSTANTS and DSM$LOG_SYSTEM_MESSAGES.

    v$dft_message: [READ] ARRAY [1 .. c$number_of_dft_messages] OF t$dft_message :=
      { IOU }
          [[dsc$dftb_dac_iou_001, '*DEADSTART ERROR LOG IOU ERROR'],
           [dsc$dftb_dac_iou_002, '*EXPRESS DEADSTART DUMP IOU ERROR'],
           [dsc$dftb_dac_iou_003, '*CORRECTED IOU ERROR'],
           [dsc$dftb_dac_iou_004, '*UNCORRECTED IOU ERROR (PP HALT)'],
           [dsc$dftb_dac_iou_005, '*12/16 IOU CONVERSION ERROR'],
           [dsc$dftb_dac_iou_006, '*FATAL IOU ERROR (NOT PP HALT)'],
           [dsc$dftb_dac_iou_007, '*IOU CHANNEL ERROR'],
           [dsc$dftb_dac_iou_008, '*FATAL IOU ERROR (NOT PP HALT)'],
           [dsc$dftb_dac_iou_009, '*UNCORRECTED IOU ERROR (PP HALT)'],
           [dsc$dftb_dac_iou_00A, '*12/16 IOU CONVERSION ERROR'],
           [dsc$dftb_dac_iou_00B, '*IOU CHANNEL ERROR'],
           [dsc$dftb_dac_iou_00C, '*IOU SS BIT 57 CONDITION'],
           [dsc$dftb_dac_iou_0FF, '*HARDWARE ERROR'],
      { MEMORY }
           [dsc$dftb_dac_mem_101, '*DEADSTART ERROR LOG MEMORY ERROR'],
           [dsc$dftb_dac_mem_102, '*EXPRESS DEADSTART DUMP MEMORY ERROR'],
           [dsc$dftb_dac_mem_103, '*CORRECTED MEMORY ERROR'],
           [dsc$dftb_dac_mem_104, '*UNCORRECTED MEMORY ERROR'],
           [dsc$dftb_dac_mem_105, '*FATAL CM ERROR (MULTIPLE ODD BIT ERROR)'],
           [dsc$dftb_dac_mem_106, '*FATAL CM ERROR (PARTIAL WRITE PARITY ERROR)'],
           [dsc$dftb_dac_mem_107, '*RESERVED FOR FUTURE USE'],
           [dsc$dftb_dac_mem_108, '*UNCORRECTED MEMORY BOARD LEVEL ERROR'],
           [dsc$dftb_dac_mem_109, '*UNCORRECTED MEMORY INTERFACE ERROR'],
      { CPU }
           [dsc$dftb_dac_cpu_201, '*DEADSTART ERROR LOG PROCESSOR ERROR'],
           [dsc$dftb_dac_cpu_202, '*EXPRESS DEADSTART DUMP PROCESSOR ERROR'],
           [dsc$dftb_dac_cpu_203, '*CORRECTED PROCESSOR ERROR'],
           [dsc$dftb_dac_cpu_204, '*UNCORRECTED PROCESSOR ERROR'],
           [dsc$dftb_dac_cpu_205, '*RETRY IN PROGRESS'],
           [dsc$dftb_dac_cpu_206, '*SOFT CONTROL MEMORY RELOAD'],
           [dsc$dftb_dac_cpu_207, '*UNSUCCESSFUL SOFT CONTROL MEMORY RELOAD'],
           [dsc$dftb_dac_cpu_208, '*FATAL CPU HALT CLASS 1'],
           [dsc$dftb_dac_cpu_209, '*CPU ERROR EXIT MODE 20'],
           [dsc$dftb_dac_cpu_20A, '*CPU ERROR EXIT MODE 67'],
           [dsc$dftb_dac_cpu_20B, '*FATAL CPU RECOVERY ERROR'],
           [dsc$dftb_dac_cpu_20C, '*CORRECTED PROCESSOR ERROR WITH CACHE RELOAD'],
           [dsc$dftb_dac_cpu_20D, '*FATAL CPU UNCORRECTED ERROR'],
           [dsc$dftb_dac_cpu_20E, '*FATAL CPU ERROR (DUE THRESHOLD EXCEEDED)'],
           [dsc$dftb_dac_cpu_20F, '*FATAL C170 STATE DUE'],
           [dsc$dftb_dac_cpu_210, '*FATAL C170 STATE EXIT MODE HALT'],
           [dsc$dftb_dac_cpu_211, '*FATAL MONITOR DUE'],
           [dsc$dftb_dac_cpu_212, '*FATAL MONITOR ERROR'],
           [dsc$dftb_dac_cpu_213, '*FATAL MONITOR MCR'],
           [dsc$dftb_dac_cpu_214, '*FATAL EI DUE'],
           [dsc$dftb_dac_cpu_215, '*FATAL MCH ERROR'],
           [dsc$dftb_dac_cpu_216, '*FATAL JOB ERROR'],
           [dsc$dftb_dac_cpu_217, '*FATAL JOB MCR'],
           [dsc$dftb_dac_cpu_218, '*FATAL CPU N ERROR'],
           [dsc$dftb_dac_cpu_219, '*FORCED UNCORRECTED ERROR'],
           [dsc$dftb_dac_cpu_21A, '*FATAL CPU HALT CLASS 2'],
           [dsc$dftb_dac_cpu_21B, '*RETRY CONVERTED TO UNCORRECTED ERROR'],
           [dsc$dftb_dac_cpu_21C, '*RETRY EXHAUSTED'],
           [dsc$dftb_dac_cpu_21D, '*HOURLY RETRY THRESHOLD EXCEEDED'],
           [dsc$dftb_dac_cpu_21E, '*PARTIAL WRITE ADDRESS PARITY ERROR'],
           [dsc$dftb_dac_cpu_21F, '*FATAL CPU ERROR (UNABLE TO EXCHANGE OR TRAP)'],
           [dsc$dftb_dac_cpu_220, '*FATAL CPU ERROR (PROCESS DAMAGED IN MTR MODE)'],
           [dsc$dftb_dac_cpu_221, '*FATAL CPU ERROR (DUE WITH MICROCODE HALT)'],
           [dsc$dftb_dac_cpu_222, '*FATAL CPU ERROR (NO ERROR BITS PRESENT IN STATUS SUMMARY)'],
           [dsc$dftb_dac_cpu_223, '*FATAL CPU ERROR (CONTROL STORE RELOAD FAILED)'],
           [dsc$dftb_dac_cpu_224, '*FATAL CPU ERROR (RETRIES EXHAUSTED)'],
           [dsc$dftb_dac_cpu_225, '*FATAL CPU ERROR (HALT TIMEOUT)'],
           [dsc$dftb_dac_cpu_226, '*FATAL CPU ERROR (UNEXPECTED MICROCODE HALT ADDRESS)'],
           [dsc$dftb_dac_cpu_227, '*UNCORRECTED CPU ERROR (EXCHANGE VECTOR)'],
           [dsc$dftb_dac_cpu_228, '*UNCORRECTED CPU ERROR (TRAP VECTOR)'],
           [dsc$dftb_dac_cpu_229, '*UNCORRECTED CPU ERROR (HALT VECTOR)'],
           [dsc$dftb_dac_cpu_22A, '*CLOCK ERROR'],
           [dsc$dftb_dac_cpu_22B, '*FATAL CONTROL STORE ERROR (JOB MODE)'],
           [dsc$dftb_dac_cpu_22C, '*FATAL CONTROL STORE ERROR (MONITOR MODE)'],
           [dsc$dftb_dac_cpu_22D, '*CORRECTED CPU ERROR (RETRY SUCCESSFUL)'],
           [dsc$dftb_dac_cpu_22E, '*FATAL CPU MICROCODE PARITY ERROR'],
           [dsc$dftb_dac_cpu_22F, '*NEGATIVE SIT CONDITION'],
           [dsc$dftb_dac_cpu_230, '*CPU MAC HANG'],
           [dsc$dftb_dac_cpu_231, '*CPU/MEM DEADMAN TIMEOUT'],
           [dsc$dftb_dac_cpu_232, '*CPU VECTOR DEGRADE'],
      { PAGE MAP }
           [dsc$dftb_dac_map_301, '*CORRECTED PAGE MAP ERROR'],
           [dsc$dftb_dac_map_302, '*UNCORRECTED PAGE MAP ERROR'],
      { BAD REQUESTS TO DFT }
           [dsc$dftb_dac_req_401, '*BAD RESPONSE TO AN OS REQUEST'],
           [dsc$dftb_dac_req_402, '*DFT LOGGED PROCESSOR FAILURE MESSAGE'],
           [dsc$dftb_dac_req_403, '*ERROR UPDATING THE ECR RECORD'],
           [dsc$dftb_dac_req_404, '*ERRONEOUS BIT 59 SET AND NO ERROR DETECTED'],
           [dsc$dftb_dac_req_405, '*TRANSIENT BIT 59 CONDITION'],
           [dsc$dftb_dac_req_406, '*ERROR PROCESSING THE ECR RECORD IN AN ERROR CONDITION'],
           [dsc$dftb_dac_req_407, '*EPM BOARD ERROR DATA'],
           [dsc$dftb_dac_req_408, '*EPM SYSTEM ERROR DATA'],
           [dsc$dftb_dac_req_40A, '*NEGATIVE SIT CONDITION'],
      { PACKET COMMUNICATION }
           [dsc$dftb_dac_pac_501, '*BAD PACKET RESPONSE'],
           [dsc$dftb_dac_pac_502, '*PACKET SEQUENCE NUMBER MISMATCH'],
           [dsc$dftb_dac_pac_503, '*BAD PACKET PHASE IN DFT'],
           [dsc$dftb_dac_pac_504, '*DFT/2AP INTERFACE ERROR'],
           [dsc$dftb_dac_pac_505, '*PACKET TIMEOUT CONDITION'],
           [dsc$dftb_dac_pac_507, '*PACKET REQUEST QUEUE FULL REQUEST IGNORED'],
           [dsc$dftb_dac_pac_5FF, '*SERVICE PROCESSOR INTERNAL ERROR'],
      { SOFTWARE }
           [dsc$dftb_dac_sof_601, '*SCI NOT RESPONDING'],
           [dsc$dftb_dac_sof_602, '*DFT NOT RESPONDING'],
           [dsc$dftb_dac_sof_603, '*CHANNEL 17 PARITY ERROR'],
           [dsc$dftb_dac_sof_604, '*CHANNEL 17 INTERLOCK ERROR'],
           [dsc$dftb_dac_sof_605, '*CHANNEL 17 ACTIVE'],
           [dsc$dftb_dac_sof_606, '*RESERVED'],
           [dsc$dftb_dac_sof_607, '*DFT REGISTER NUMBER NOT IN THE MRB'],
           [dsc$dftb_dac_sof_608, '*DFT MAINFRAME IDENTIFICATION ERROR'],
           [dsc$dftb_dac_sof_609, '*DFT PROCESSOR TYPE ERROR'],
           [dsc$dftb_dac_sof_60A, '*DFT FATAL STACK'],
           [dsc$dftb_dac_sof_60B, '*DFT BUILD REGISTER LIST SIZE ERROR'],
           [dsc$dftb_dac_sof_60C, '*PP LOAD ERROR'],
           [dsc$dftb_dac_sof_60D, '*170 MTR MCR FAULT - DETECTED BY EI'],
           [dsc$dftb_dac_sof_60E, '*BAD SYSTEM REQUEST - DETECTED BY EI'],
           [dsc$dftb_dac_sof_60F, '*CHANNEL 17 INACTIVE'],
           [dsc$dftb_dac_sof_610, '*SCI PRESET FAILURE'],
           [dsc$dftb_dac_sof_611, '*SCI LOADED IN PP 0'],
           [dsc$dftb_dac_sof_612, '*DFT ELEMENT DESCRIPTOR NOT IN MRT'],
           [dsc$dftb_dac_sof_613, '*DFT COMM FAILURE'],
           [dsc$dftb_dac_sof_614, '*DFT INCOMPATIBLE VERSION'],
           [dsc$dftb_dac_sof_615, '*SCI TABLE SIZE TOO SMALL'],
           [dsc$dftb_dac_sof_616, '*WALL CLOCK CHIP READ ERROR'],
           [dsc$dftb_dac_sof_617, '*NOS/VE MONITOR NOT RESPONDING'],
           [dsc$dftb_dac_sof_618, '*NO PP AVAILABLE FOR DFT'],
           [dsc$dftb_dac_sof_619, '*REGISTER LIST LENGTH GREATER THEN POINTER VALUE'],
           [dsc$dftb_dac_sof_61A, '*DFT IOU FIELD PROCESSING ERROR'],
           [dsc$dftb_dac_sof_61B, '*DFT NOT FOUND IN CIP DIRECTORY'],
           [dsc$dftb_dac_sof_61C, '*DFT SECONDARY BUFFER ERROR'],
           [dsc$dftb_dac_sof_61D, '*PRIMARY BUFFER ALLOCATION ERROR'],
           [dsc$dftb_dac_sof_61E, '*DFT INTERNAL ERROR'],
           [dsc$dftb_dac_sof_61F, '*DFT CANNOT FIND COUNTER VALUE'],
           [dsc$dftb_dac_sof_620, '*DFT CANNOT FIND THRESHOLD VALUE'],
           [dsc$dftb_dac_sof_621, '*DFT DISK STATUS LENGTH EXCEEDED'],
           [dsc$dftb_dac_sof_622, '*SCI DETECTED DFT ERROR WHILE LOADING SSR'],
           [dsc$dftb_dac_sof_623, '*SCI DETECTED DFT ERROR WHILE LOADING VCB'],
           [dsc$dftb_dac_sof_624, '*SCI DETECTED DFT ERROR WHILE HALTING 170 PROCESSOR'],
           [dsc$dftb_dac_sof_625, '*SCI DETECTED DFT ERROR WHILE STARTING VIRTUAL CPU'],
           [dsc$dftb_dac_sof_626, '*SCI DETECTED DFT ERROR WHILE IDLING SECONDARY IOU'],
           [dsc$dftb_dac_sof_627, '*SCI DETECTED DFT ERROR WHILE HALTING VIRTUAL CPU'],
           [dsc$dftb_dac_sof_628, '*SCI DETECTED DFT ERROR WHILE STARTING 170 CPU'],
           [dsc$dftb_dac_sof_629, '*SCI DETECTED DFT ERROR WHILE GETTING ELEMENT DESCR'],
           [dsc$dftb_dac_sof_62A, '*SCI DETECTED DFT NEVER SET VERIFIED FLAG'],
           [dsc$dftb_dac_sof_62B, '*SCI DETECTED DFT SET BUFFER REJECT FLAG'],
           [dsc$dftb_dac_sof_6FF, '*SERVICE PROCESSOR EXECUTIVE ERROR'],
      { OTHER }
           [dsc$dftb_dac_non_701, '*ENVIRONMENT WARNING'],
           [dsc$dftb_dac_non_702, '*LONG POWER WARNING'],
           [dsc$dftb_dac_non_703, '*SHORT POWER WARNING'],
           [dsc$dftb_dac_non_704, '*ENVIRONMENT WARNING CLEAR'],
           [dsc$dftb_dac_non_705, '*LONG POWER WARNING CLEAR'],
           [dsc$dftb_dac_non_706, '*SHORT POWER WARNING CLEAR'],
           [dsc$dftb_dac_non_707, '*TOP OF HOUR MAINFRAME ELEMENT COUNTERS BUFFER'],
           [dsc$dftb_dac_non_708, '*TOP OF HOUR SECDED ID TABLE'],
           [dsc$dftb_dac_non_709, '*LONG POWER WARNING'],
           [dsc$dftb_dac_non_70A, '*LONG POWER WARNING CLEAR']],

    v$os_action_message: [READ] ARRAY [0 .. c$number_of_os_actions] OF string (c$message_size) :=
          ['*NULL - No OS Action Required',
           '*Environment Warning',
           '*Long Power Warning',
           '*Short Power Warning',
           '*Warning Clear',
           '*Fatal IOU Error',
           '*NOS/VE IOU Error',
           '*Uncorrected CM Error',
           '*Uncorrectable CM Parity Error',
           '*Uncorrected Processor Error',
           '*C170 State OS IOU Error',
           '*System Idle/Checkpoint',
           '*System Resume (Restart)',
           '*C170 State Idle (Checkpoint)',
           '*C170 State Resume (Restart)',
           '*C180 State Idle',
           '*C180 State Resume',
           '*System Step',
           '*System Unstep',
           '*C170 State Step',
           '*C170 State Unstep',
           '*C180 State Step',
           '*C180 State Unstep',
           '*Reconfigure Mainframe Elements',
           '*Vector Degrade',
           '*Element Degrade',
           '*Flaw CM Page',
           '*Handle PP Hang',
           '*Undefined',
           '*Handle Bit 57'],

    v$priority_message: [READ] ARRAY [0 .. c$number_of_priorities] OF string (c$message_size) :=
          ['*Retry in Progress Errors',
           '*Top of Hour Logging',
           '*Corrected Errors',
           '*Uncorrected Errors',
           '*Central Processor Catastrophic Error',
           '*Environment/Long Power Warnings',
           '*Short Power Warning'];

?? OLDTITLE ??
?? NEWTITLE := 'display_data_type', EJECT ??

{ PURPOSE:
{   This procedure displays the data type.

  PROCEDURE display_data_type
    (    data_type: dst$dftb_structure_length);

    VAR
      data_string: string (osc$max_string_size),
      ignore_status: ost$status;

    CASE data_type OF
    = dsc$dftb_sbt_mrb =
      data_string := '   Data Type = Maintenance Register Buffer Data';
    = dsc$dftb_sbt_ssb =
      data_string := '   Data Type = Supportive Status Buffer Data';
    = dsc$dftb_sbt_mdb =
      data_string := '   Data Type = Model Dependent Buffer Data';
    = dsc$dftb_sbt_mec =
      data_string := '   Data Type = Mainframe Element Counter Data';
    = dsc$dftb_sbt_sit =
      data_string := '   Data Type = SECDED ID Table Data';
    = dsc$dftb_sbt_nrb =
      data_string := '   Data Type = Non Register Status Buffer Data';
    ELSE
      data_string := '   Data Type = Unknown data type';
    CASEND;
    clp$put_display (v$display_control, data_string, clc$trim, ignore_status);

  PROCEND display_data_type;
?? OLDTITLE ??
?? NEWTITLE := 'display_date_time', EJECT ??

{ PURPOSE:
{   This procedure displays the date and time.

  PROCEDURE display_date_time
    (    date_time: t$date_time);

    VAR
      date_time_string: t$date_time_string,
      display_string: string (osc$max_string_size),
      ignore_status: ost$status,
      string_length: integer;

    date_time_string.data := ' ';
    IF date_time.data = 0 THEN
      date_time_string.data := 'No date or time in entry';
    ELSE
      date_time_string.month (2) := CHR ((date_time.month MOD 16) + ORD ('0'));
      date_time_string.month (1) := CHR (((date_time.month DIV 16) MOD 16) + ORD ('0'));
      date_time_string.slash_1 := '/';
      date_time_string.day (2) := CHR ((date_time.day MOD 16) + ORD ('0'));
      date_time_string.day (1) := CHR (((date_time.day DIV 16) MOD 16) + ORD ('0'));
      date_time_string.slash_2 := '/';
      date_time_string.year (2) := CHR ((date_time.year MOD 16) + ORD ('0'));
      date_time_string.year (1) := CHR (((date_time.year DIV 16) MOD 16) + ORD ('0'));
      date_time_string.spaces := ' ';
      date_time_string.hour (2) := CHR ((date_time.hour MOD 16) + ORD ('0'));
      date_time_string.hour (1) := CHR (((date_time.hour DIV 16) MOD 16) + ORD ('0'));
      date_time_string.period_1 := './';
      date_time_string.minute (2) := CHR ((date_time.minute MOD 16) + ORD ('0'));
      date_time_string.minute (1) := CHR (((date_time.minute DIV 16) MOD 16) + ORD ('0'));
      date_time_string.period_2 := './';
      date_time_string.second (2) := CHR ((date_time.second MOD 16) + ORD ('0'));
      date_time_string.second (1) := CHR (((date_time.second DIV 16) MOD 16) + ORD ('0'));
    IFEND;
    STRINGREP (display_string, string_length, '   Date/Time = ', date_time_string.data);
    clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);

  PROCEND display_date_time;
?? OLDTITLE ??
?? NEWTITLE := 'display_dec_data', EJECT ??

{ PURPOSE:
{   This procedure displays information from the DFT Error Control Record.

  PROCEDURE display_dec_data;

    TYPE
      t$dec_cw = RECORD
        rfu: 0 .. 0ffffffff(16),
        entry_size: dst$dftb_element_size,
        number_of_elements: dst$dftb_element_size,
      RECEND,

      t$dec_data = RECORD
        rfu_1: dst$dftb_structure_length,
        element_id: dst$dftb_structure_length,
        action: dst$dftb_element_size,
        r1: dst$dftb_element_size,
        r2: dst$dftb_element_size,
        rfu_2: 0 .. 0ffffffff(16),
        corrected_threshold: dst$dftb_element_size,
        uncorrected_threshold: dst$dftb_element_size,
        m1_bit: integer,
        r1_bits: integer,
        m2_bit: integer,
        r2_bits: integer,
      RECEND;

    VAR
      action: [STATIC] ARRAY [0 .. 12(16)] OF string (c$message_size) :=
            ['Process all errors',
             'Ignore errors',
             'Freeze on any error',
             'Freeze on corrected error',
             'Freeze on uncorrected error',
             'Freeze on (R1) bit range',
             'Freeze on (R1) specific bits',
             'Freeze on (R1) bit range and (R2) bit range',
             'Freeze on (R1) bit range and (R2) specific',
             'Freeze on (R1) specific and (R2) bit range',
             'Freeze on (R1) specific and (R2) specific',
             'Ignore corrected error',
             'Ignore uncorrected error',
             'Ignore (R1) bit range',
             'Ignore (R1) specific',
             'Ignore on (R1) bit range and (R2) bit range',
             'Ignore on (R1) bit range and (R2) specific',
             'Ignore on (R1) specific and (R2) bit range',
             'Ignore on (R1) specific and (R2) specific'],
      dec_cw_p: ^t$dec_cw,
      dec_data_p: ^t$dec_data,
      display_string: string (osc$max_string_size),
      ignore_status: ost$status,
      index: dst$dftb_element_size,
      leftover: dst$dftb_element_size,
      register_string: string (19),
      skip_p: ^SEQ ( * ),
      string_length: integer;

    display_header (TRUE, ' DFT ERROR CONTROL RECORD:');
    RESET v$restart_file_seq_p TO v$data.buffer [dsc$dftb_rpw_dft_control_info].cell_p;
    NEXT dec_cw_p IN v$restart_file_seq_p;
    IF dec_cw_p = NIL THEN
      clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
      RETURN;  {---->
    IFEND;

    FOR index := 1 TO dec_cw_p^.number_of_elements DO
      NEXT dec_data_p IN v$restart_file_seq_p;
      IF dec_data_p = NIL THEN
        clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
        RETURN;  {---->
      IFEND;
      clp$put_display (v$display_control, v$dash, clc$trim, ignore_status);

      display_element_type (dec_data_p^.element_id);
      IF (dec_data_p^.action >= LOWERBOUND (action)) AND (dec_data_p^.action <= UPPERBOUND (action)) THEN
        STRINGREP (display_string, string_length, '   Action = ', action [dec_data_p^.action]);
      ELSE
        STRINGREP (display_string, string_length, '   Action = ', dec_data_p^.action);
      IFEND;
      clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);

      STRINGREP (display_string, string_length,
            '   Maintenance register number associated with (R1) bit mask = ', dec_data_p^.r1);
      clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);
      STRINGREP (display_string, string_length,
            '   Maintenance register number associated with (R2) bit mask = ', dec_data_p^.r2);
      clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);

      STRINGREP (display_string, string_length, '   Corrected Threshold = ', dec_data_p^.corrected_threshold);
      clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);
      STRINGREP (display_string, string_length, '   Uncorrected Threshold = ',
            dec_data_p^.uncorrected_threshold);
      clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);

      retrieve_register_string (dec_data_p^.m1_bit, register_string);
      STRINGREP (display_string, string_length, '   M1 Bit Mask Field = ', register_string);
      clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);
      retrieve_register_string (dec_data_p^.r1_bits, register_string);
      STRINGREP (display_string, string_length, '   R1 Bits To Select = ', register_string);
      clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);
      retrieve_register_string (dec_data_p^.m2_bit, register_string);
      STRINGREP (display_string, string_length, '   M2 Bit Mask Field = ', register_string);
      clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);
      retrieve_register_string (dec_data_p^.r2_bits, register_string);
      STRINGREP (display_string, string_length, '   R2 Bits To Select = ', register_string);
      clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);

      IF (#SIZE (dec_data_p^) * 8) < dec_cw_p^.entry_size THEN
        leftover := dec_cw_p^.entry_size - (#SIZE (dec_data_p^) * 8);
        NEXT skip_p: [[REP leftover OF integer]] IN v$restart_file_seq_p;
        IF skip_p = NIL THEN
          clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
          RETURN;  {---->
        IFEND;
      IFEND;
    FOREND;

  PROCEND display_dec_data;
?? OLDTITLE ??
?? NEWTITLE := 'display_dft_control_word', EJECT ??

{ PURPOSE:
{   This procedure will display information in the DFT buffer control word.

  PROCEDURE display_dft_control_word
    (    secondary_dft: boolean);

    VAR
      dftb_cw_p: ^dst$dftb_control_word,
      display_string: string (osc$max_string_size),
      ignore_status: ost$status,
      string_length: integer;

    IF NOT secondary_dft THEN
      RESET v$restart_file_seq_p TO v$data.buffer [duc$dft_cw].cell_p;
      display_header (TRUE, ' DFT BUFFER CONTROL WORD:');
    IFEND;

    NEXT dftb_cw_p IN v$restart_file_seq_p;
    IF dftb_cw_p = NIL THEN
      clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
      RETURN;  {---->
    IFEND;

    STRINGREP (display_string, string_length, '   Number of Pointer Words = ', dftb_cw_p^.pointer_words,
          '(10)');
    clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);
    STRINGREP (display_string, string_length, '   Next sequence number = ',
          dftb_cw_p^.sequence_number: #(16), '(16)');
    clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);
    STRINGREP (display_string, string_length, '   Interface Revision Level = ',
          dftb_cw_p^.revision_level: #(16), '(16)');
    clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);
    STRINGREP (display_string, string_length, '   DFT Hardware Logical PP Number = ',
          dftb_cw_p^.dft_pp_number, '(10)');
    clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);
    STRINGREP (display_string, string_length, '   Length of each Maintenance Register Buffer = ',
          dftb_cw_p^.mrb_length, '(10) cm words');
    clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);
    STRINGREP (display_string, string_length, '   Number of Maintenance Register Buffers = ',
          dftb_cw_p^.number_of_mrbs, '(10) (including scratch buffer)');
    clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);

    clp$put_display (v$display_control, '   Flags Indicate:', clc$trim, ignore_status);
    IF dftb_cw_p^.c170_error THEN
      clp$put_display (v$display_control, '     C170 Errors exist in buffers to be processed (E7)',
            clc$trim, ignore_status);
    IFEND;
    IF dftb_cw_p^.c180_error THEN
      clp$put_display (v$display_control, '     C180 Errors exist in buffers to be processed (E8)',
            clc$trim, ignore_status);
    IFEND;
    IF dftb_cw_p^.non_dedicated_mode THEN
      clp$put_display (v$display_control,
            '     DFT was running in Non-Dedicated Mode when dump was taken (D)', clc$trim, ignore_status);
    ELSE
      clp$put_display (v$display_control, '     DFT was running in Dedicated Mode when dump was taken (D)',
            clc$trim, ignore_status);
    IFEND;
    IF dftb_cw_p^.nos_logging_errors THEN
      clp$put_display (v$display_control, '     NOS or NOS/BE logging mainframe errors at time of dump (L)',
            clc$trim, ignore_status);
    ELSE
      clp$put_display (v$display_control, '     NOS/VE logging mainframe errors at time of dump (L)',
            clc$trim, ignore_status);
    IFEND;
    IF dftb_cw_p^.c170_dedicated THEN
      clp$put_display (v$display_control,
            '     DFT should run in non dedicated mode when NOS/VE is not running (C)',
            clc$trim, ignore_status);
    ELSE
      clp$put_display (v$display_control,
            '     DFT should run in dedicated mode when NOS/VE is not running (C)', clc$trim, ignore_status);
    IFEND;
    IF dftb_cw_p^.zero_counters_and_secded THEN
      clp$put_display (v$display_control, '     Set counters and SECDED ID Table to zero (Z)',
            clc$trim, ignore_status);
    IFEND;
    IF dftb_cw_p^.dft_reject THEN
      clp$put_display (v$display_control, '     DFT does not recognize the version level set (R)',
            clc$trim, ignore_status);
    IFEND;
    IF dftb_cw_p^.dft_verification THEN
      clp$put_display (v$display_control, '     DFT has verified the interface version level (V)',
            clc$trim, ignore_status);
    ELSE
      clp$put_display (v$display_control, '     DFT has NOT verified the interface version level (V)',
            clc$trim, ignore_status);
    IFEND;
    IF dftb_cw_p^.uncorrected_error_freeze THEN
      clp$put_display (v$display_control, '     Freeze System on Uncorrected Error (FU)',
            clc$trim, ignore_status);
    IFEND;
    IF dftb_cw_p^.corrected_error_freeze THEN
      clp$put_display (v$display_control, '     Freeze System on Corrected Error (FC)',
            clc$trim, ignore_status);
    IFEND;
    IF dftb_cw_p^.idle_dft THEN
      clp$put_display (v$display_control, '     Idle DFT Flag set (T)', clc$trim, ignore_status);
    IFEND;
    IF dftb_cw_p^.logging_transaction THEN
      clp$put_display (v$display_control, '     Logging Transaction Flag set (LT)', clc$trim, ignore_status);
    IFEND;
    IF NOT secondary_dft THEN
      display_trailer;
    IFEND;

  PROCEND display_dft_control_word;
?? OLDTITLE ??
?? NEWTITLE := 'display_element_type', EJECT ??

{ PURPOSE:
{   This procedure displays the element type.

  PROCEDURE display_element_type
    (    element_number: dst$dftb_structure_length);

    VAR
      element_string: string (osc$max_string_size),
      ignore_status: ost$status;

    CASE element_number OF
    = dsc$dftb_eid_cpu0_element =
      element_string := '   Element ID = CPU 0';
    = dsc$dftb_eid_cpu1_element =
      element_string := '   Element ID = CPU 1';
    = dsc$dftb_eid_memory_element =
      element_string := '   Element ID = CENTRAL MEMORY';
    = dsc$dftb_eid_iou0_element =
      element_string := '   Element ID = IOU 0';
    = dsc$dftb_eid_iou1_element =
      element_string := '   Element ID = IOU 1';
    = dsc$dftb_eid_page_map_element =
      element_string := '   Element ID = PAGE MAP';
    = dsc$dftb_eid_no_known_element =
      element_string := '   Element ID = DFT INTERNAL';
    ELSE
      element_string := '   Element ID = UNKNOWN ELEMENT';
    CASEND;
    clp$put_display (v$display_control, element_string, clc$trim, ignore_status);

  PROCEND display_element_type;
?? OLDTITLE ??
?? NEWTITLE := 'display_fault_symptom_code', EJECT ??

{ PURPOSE:
{   This procedure displays the fault symptom code.

  PROCEDURE display_fault_symptom_code
    (    fault_symptom_code: t$fault_symptom_code);

    VAR
      display_string: string (osc$max_string_size),
      ignore_status: ost$status,
      index: 1 .. 12,
      local_fault_symptom_code: t$fault_symptom_code,
      string_length: integer;

    local_fault_symptom_code := fault_symptom_code;
    FOR index := 1 TO 12 DO
      IF local_fault_symptom_code.code_array [index] = 0 THEN
        local_fault_symptom_code.code (index) := ' ';
      IFEND;
    FOREND;
    STRINGREP (display_string, string_length, '   Fault Symptom Code = ', local_fault_symptom_code.code);
    clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);

  PROCEND display_fault_symptom_code;
?? OLDTITLE ??
?? NEWTITLE := 'display_header', EJECT ??

{ PURPOSE:
{   This procedure displays a header on the output file.

  PROCEDURE display_header
    (    small_header: boolean;
         title: string ( * ));

    VAR
      ignore_status: ost$status;

    IF small_header THEN
      clp$put_display (v$display_control, ' ', clc$trim, ignore_status);
      clp$put_display (v$display_control, v$star, clc$trim, ignore_status);
      clp$put_display (v$display_control, title, clc$trim, ignore_status);
    ELSE
      clp$put_display (v$display_control, ' ', clc$trim, ignore_status);
      clp$put_display (v$display_control, v$star, clc$trim, ignore_status);
      clp$put_display (v$display_control, title, clc$trim, ignore_status);
      clp$put_display (v$display_control, v$star, clc$trim, ignore_status);
      clp$put_display (v$display_control, ' ', clc$trim, ignore_status);
    IFEND;

  PROCEND display_header;
?? OLDTITLE ??
?? NEWTITLE := 'display_mdb_data', EJECT ??

{ PURPOSE:
{   This procedure displays the information for one of the Model Dependent Buffers.

  PROCEDURE display_mdb_data
    (    index: 0 .. duc$dft_max_mdb_buffers);

    TYPE
      t$mdb_sub_header = RECORD
        length_of_data: 0 .. 0ffff(16),
        rfu: 0 .. 0ffff(16),
        pfs_error_id: 0 .. 0ffff(16),
        data_header_id: 0 .. 0ffff(16),
      RECEND;

    VAR
      data_size: dst$dftb_element_size,
      display_string: string (osc$max_string_size),
      ignore_status: ost$status,
      index_2: dst$dftb_element_size,
      integer_p: ^integer,
      mdb_cw_p: ^t$mdb_control_word,
      mdb_shw_p: ^t$mdb_sub_header,
      register_string: string (19),
      skip_p: ^SEQ ( * ),
      string_length: integer,
      sub_area_size: dst$dftb_element_size,
      titles: [STATIC] ARRAY [1 .. 0a(16)] OF string (80) :=
            ['     Sub Header ID = 01 = Soft Control Memory (SCM) Parity Error Data',
             '     Sub Header ID = 02 = CPU Capture Buffer',
             '     Sub Header ID = 03 = History File',
             '     Sub Header ID = 04 = Exchange Package',
             '     Sub Header ID = 05 = Current P address and surrounding instructions',
             '     Sub Header ID = 06 = Executing words of soft control memory',
             '     Sub Header ID = 07 = Retry Information',
             '     Sub Header ID = 08 = Soft Registers',
             '     Sub Header ID = 09 = Register File',
             '     Sub Header ID = 0A = Error During MDB Logging'];

    RESET v$restart_file_seq_p TO v$data.mdb [index].cell_p;
    NEXT mdb_cw_p IN v$restart_file_seq_p;
    IF mdb_cw_p = NIL THEN
      clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
      RETURN;  {---->
    IFEND;

    STRINGREP (display_string, string_length, ' MODEL DEPENDENT BUFFER  (buffer # =',
          (index - 1), '(10)):');
    clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);

    STRINGREP (display_string, string_length, '   SEQUENCE NUMBER = ', mdb_cw_p^.sequence_number: #(16),
          '(16)');
    clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);

    IF mdb_cw_p^.long_term_interlock_flag = 1 THEN
      STRINGREP (display_string, string_length, '   Long Term Interlock Flag = 1(10) (first error)');
    ELSEIF mdb_cw_p^.long_term_interlock_flag = 9 THEN
      STRINGREP (display_string, string_length, '   Long Term Interlock Flag = 9(10) (overwritten)');
    ELSE
      STRINGREP (display_string, string_length, '   Long Term Interlock Flag = ',
            mdb_cw_p^.long_term_interlock_flag, '(10)');
    IFEND;
    clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);

    STRINGREP (display_string, string_length, '   MRB Control Word Index = ',
          mdb_cw_p^.control_word_offset, '(10)');
    clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);

    IF mdb_cw_p^.priority = 1 THEN
      STRINGREP (display_string, string_length, '   Priority = 1 = Retry in Progress (lowest priority)');
    ELSEIF mdb_cw_p^.priority = 2 THEN
      STRINGREP (display_string, string_length, '   Priority = 2 = Other Uncorrected Errors');
    ELSEIF mdb_cw_p^.priority = 3 THEN
      STRINGREP (display_string, string_length, '   Priority = 3 = Issue Timeout (highest priority)');
    ELSE
      STRINGREP (display_string, string_length, '   Priority = ', mdb_cw_p^.priority);
    IFEND;
    clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);

    data_size := mdb_cw_p^.length_to_log;
    STRINGREP (display_string, string_length, '   Total Length to Log = ', data_size, '(10) cm words');
    clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);

    IF data_size > 0 THEN
      data_size := data_size - 1;
    IFEND;

   /display_sub_area/
    WHILE data_size > 0 DO
      NEXT mdb_shw_p IN v$restart_file_seq_p;
      IF mdb_shw_p = NIL THEN
        clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
        RETURN;  {---->
      IFEND;
      data_size := data_size - 1;
      clp$put_display (v$display_control, v$dash, clc$trim, ignore_status);
      clp$put_display (v$display_control, '   MDB SUB HEADER WORD:', clc$trim, ignore_status);

      sub_area_size := mdb_shw_p^.length_of_data - 1;
      data_size := data_size - sub_area_size;
      STRINGREP (display_string, string_length, '     Sub Area Length = ', mdb_shw_p^.length_of_data,
            '(10) cm words');
      clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);

      STRINGREP (display_string, string_length, '     PFS Error ID = ', mdb_shw_p^.pfs_error_id: #(16),
            '(16)');
      clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);

      IF (mdb_shw_p^.data_header_id = 2) AND NOT v$display_capture_buffer THEN
        NEXT skip_p: [[REP sub_area_size OF integer]] IN v$restart_file_seq_p;
        IF skip_p = NIL THEN
          clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
          RETURN;  {---->
        IFEND;
        CYCLE /display_sub_area/;  {---->
      IFEND;

      IF (mdb_shw_p^.data_header_id >= LOWERBOUND (titles)) AND
            (mdb_shw_p^.data_header_id <= UPPERBOUND (titles)) THEN
        clp$put_display (v$display_control, titles [mdb_shw_p^.data_header_id], clc$trim, ignore_status);
      ELSE
        clp$put_display (v$display_control, '     Sub Header ID = ?? = Unknown Header Id', clc$trim,
              ignore_status);
      IFEND;
      clp$put_display (v$display_control, '     Sub Buffer Data:', clc$trim, ignore_status);

      CASE mdb_shw_p^.data_header_id OF
      = 5 =
        display_mdb_p_address (sub_area_size);
      = 6 =
        display_mdb_scm_executing_words (sub_area_size);
      = 7, 9 =
        FOR index_2 := 1 TO sub_area_size DO
          NEXT integer_p IN v$restart_file_seq_p;
          IF integer_p = NIL THEN
            clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
            RETURN;  {---->
          IFEND;
          retrieve_register_string (integer_p^, register_string);
          STRINGREP (display_string, string_length, '       ', register_string);
          clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);
        FOREND;
      = 8 =
        display_mdb_soft_registers (sub_area_size);
      ELSE
        print_raw_data (sub_area_size);
      CASEND;
    WHILEND;

  PROCEND display_mdb_data;
?? OLDTITLE ??
?? NEWTITLE := 'display_mdb_p_address', EJECT ??

{ PURPOSE:
{   This procedure displays the P address information from the Model Dependent Buffer.

  PROCEDURE display_mdb_p_address
    (    buffer_size: dst$dftb_element_size);

    VAR
      display_string: string (osc$max_string_size),
      ignore_status: ost$status,
      index: dst$dftb_element_size,
      integer_p: ^integer,
      line: t$descriptor_line,
      string_length: integer,
      titles: [STATIC] ARRAY [1 .. 14] OF string (38) :=
            ['Segment Table Entry',
             'Page Table Entry',
             'Second Page Table Entry',
             '5 Instructions Before P',
             ' ',
             ' ',
             ' ',
             ' ',
             'Instruction at P',
             '5 Instructions After P',
             ' ',
             ' ',
             ' ',
             ' '];

    FOR index := 1 TO buffer_size DO
      line.data := ' ';
      NEXT integer_p IN v$restart_file_seq_p;
      IF integer_p = NIL THEN
        clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
        RETURN;  {---->
      IFEND;
      retrieve_register_string (integer_p^, line.register_string);
      line.description := titles [index];
      STRINGREP (display_string, string_length, '       ', line.data);
      clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);
    FOREND;

  PROCEND display_mdb_p_address;
?? OLDTITLE ??
?? NEWTITLE := 'display_mdb_scm_executing_words', EJECT ??

{ PURPOSE:
{   This procedure displays the Executing Words of the Soft Control Memories from the Model Dependent Buffer.

  PROCEDURE display_mdb_scm_executing_words
    (    buffer_size: dst$dftb_element_size);

    VAR
      display_string: string (osc$max_string_size),
      ignore_status: ost$status,
      index: dst$dftb_element_size,
      integer_p: ^integer,
      line: t$descriptor_line,
      string_length: integer,
      titles: [STATIC] ARRAY [1 .. 23] OF string (38) :=
            ['Current Instruction Register',
             ' ',
             ' ',
             ' ',
             'ACU.M2',
             'ACU.M3',
             'ACU.M4',
             'BDP',
             ' ',
             'EPN',
             'EPN Error Information Table',
             'Control Store',
             ' ',
             ' ',
             ' ',
             'Control Word',
             ' ',
             ' ',
             ' ',
             'Instruction Map',
             'Instruction Buffer Stack',
             'LSU',
             'SVA.BN'];

    FOR index := 1 TO buffer_size DO
      line.data := ' ';
      NEXT integer_p IN v$restart_file_seq_p;
      IF integer_p = NIL THEN
        clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
        RETURN;  {---->
      IFEND;
      retrieve_register_string (integer_p^, line.register_string);
      line.description := titles [index];
      STRINGREP (display_string, string_length, '       ', line.data);
      clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);
    FOREND;

  PROCEND display_mdb_scm_executing_words;
?? OLDTITLE ??
?? NEWTITLE := 'display_mdb_soft_registers', EJECT ??

{ PURPOSE:
{   This procedure displays the Soft Register information from the Model Dependent Buffer.

  PROCEDURE display_mdb_soft_registers
    (    buffer_size: dst$dftb_element_size);

    VAR
      display_string: string (osc$max_string_size),
      ignore_status: ost$status,
      index: dst$dftb_element_size,
      integer_p: ^integer,
      line: t$descriptor_line,
      string_length: integer,
      titles: [STATIC] ARRAY [1 .. 27] OF string (38) :=
            ['Virtual Machine Capability',
             'Program Address',
             'MPS Pointer',
             'MCR',
             'UCR',
             'UTP',
             'STL',
             'STA',
             'Base Constant',
             'PTA',
             'PTL',
             'PSM',
             'Model Dependent Flags',
             'MM',
             'JPS Pointer',
             'SIT',
             'Kypt Buffer Pointer',
             'TE',
             'Trap Pointer',
             'Debug List Pointer',
             'Kypt Mask',
             'PIT',
             'CFF',
             'OCF',
             'Debug Index',
             'Debug Mask',
             'UM'];

    FOR index := 1 TO buffer_size DO
      line.data := ' ';
      NEXT integer_p IN v$restart_file_seq_p;
      IF integer_p = NIL THEN
        clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
        RETURN;  {---->
      IFEND;
      retrieve_register_string (integer_p^, line.register_string);
      line.description := titles [index];
      STRINGREP (display_string, string_length, '       ', line.data);
      clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);
    FOREND;

  PROCEND display_mdb_soft_registers;
?? OLDTITLE ??
?? NEWTITLE := 'display_mec_data', EJECT ??

{ PURPOSE:
{   This procedure displays the Mainframe Element Counter Buffer information.

  PROCEDURE display_mec_data
    (    full_display: boolean);

    TYPE
      t$line = RECORD
        CASE boolean OF
        = TRUE =
          spaces: string (2),
          element_id: string (19),
          uet: string (13),
          cet: string (11),
          ulec: string (10),
          cec: string (11),
          uec: string (11),
        = FALSE =
          data: string (77),
        CASEND,
      RECEND;

    VAR
      element_id: string (2),
      ignore_status: ost$status,
      index: dst$dftb_element_size,
      integer_p: ^integer,
      line: t$line,
      register_string: string (19);

    IF full_display THEN
      display_header (TRUE, ' CURRENT MAINFRAME ELEMENT COUNTER BUFFER:');
      RESET v$restart_file_seq_p TO v$data.buffer [dsc$dftb_rpw_mec].cell_p;
    IFEND;
    line.data := ' ';
    line.element_id := 'Element ID';
    line.uet := 'Uncorrected';
    line.cet := 'Corrected';
    line.ulec := 'Unlogged';
    line.cec := 'Corrected';
    line.uec := 'Uncorrected';
    clp$put_display (v$display_control, line.data, clc$trim, ignore_status);
    line.data := ' ';
    line.uet := 'Error';
    line.cet := 'Error';
    line.ulec := 'Error';
    line.cec := 'Error';
    line.uec := 'Error';
    clp$put_display (v$display_control, line.data, clc$trim, ignore_status);
    line.data := ' ';
    line.uet := 'Threshold';
    line.cet := 'Threshold';
    line.ulec := 'Counter';
    line.cec := 'Counter';
    line.uec := 'Counter';
    clp$put_display (v$display_control, line.data, clc$trim, ignore_status);

    FOR index := 1 TO v$data.buffer [dsc$dftb_rpw_mec].size DO
      line.data := ' ';
      NEXT integer_p IN v$restart_file_seq_p;
      IF integer_p = NIL THEN
        clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
        RETURN;  {---->
      IFEND;
      retrieve_register_string (integer_p^, register_string);
      IF full_display THEN
        element_id := register_string (1, 2);
      ELSE
        element_id := register_string (3, 2);
      IFEND;
      IF element_id = '00' THEN
        line.element_id := '00=CPU 0';
      ELSEIF element_id = '10' THEN
        line.element_id := '10=CPU 1';
      ELSEIF element_id = '01' THEN
        line.element_id := '01=CENTRAL MEMORY';
      ELSEIF element_id = '02' THEN
        line.element_id := '02=IOU 0';
      ELSEIF element_id = '12' THEN
        line.element_id := '12=IOU 1';
      ELSEIF element_id = '03' THEN
        line.element_id := '03=PAGE MAP';
      ELSEIF element_id = '04' THEN
        line.element_id := '04=DFT INTERNAL';
      ELSE
        line.element_id (1, 2) := element_id;
        line.element_id (3, *) := '=UNKNOWN';
      IFEND;
      IF full_display THEN
        line.uet (6) := register_string (3);
        line.cet (5) := register_string (4);
      ELSE
        line.uet (5, 3) := 'N/A';
        line.cet (4, 3) := 'N/A';
      IFEND;
      line.ulec (3, 4) := register_string (6, 4);
      line.cec (3, 4) := register_string (11, 4);
      line.uec (4, 4) := register_string (16, 4);
      clp$put_display (v$display_control, line.data, clc$trim, ignore_status);
    FOREND;

    IF full_display THEN
      display_trailer;
    IFEND;

  PROCEND display_mec_data;
?? OLDTITLE ??
?? NEWTITLE := 'display_memory_size', EJECT ??

{ PURPOSE:
{   This procedure displays the memory size from the options installed register.

  PROCEDURE display_memory_size;

    TYPE
      t$bit_or_byte = PACKED RECORD
        CASE boolean OF
        = TRUE =
          byte_part: ARRAY [1 .. 2] OF 0 .. 0ff(16),
        = FALSE =
          bit_part: PACKED ARRAY [0 .. 15] OF boolean,
        CASEND,
      RECEND;

    VAR
      bit_or_byte: t$bit_or_byte,
      dump_information: dut$dump_information,
      register: dut$de_maintenance_register;

    dup$determine_dump_information (dump_information);
    IF dump_information.iou [0].model = duc$di_im_i0_5x THEN
      dup$retrieve_register (duc$de_iou, 0, 12(16), register);
      IF register.available THEN
        IF register.value [3] = 80(16) THEN
          display_header (TRUE, ' Physical Memory Size:  8 MB');
        ELSEIF register.value [3] = 84(16) THEN
          display_header (TRUE, ' Physical Memory Size:  16 MB');
        ELSEIF register.value [3] = 0c4(16) THEN
          display_header (TRUE, ' Physical Memory Size:  32 MB');
        ELSEIF register.value [3] = 0e4(16) THEN
          display_header (TRUE, ' Physical Memory Size:  48 MB');
        ELSEIF (register.value [3] = 0f4(16)) OR (register.value [3] = 8c(16)) THEN
          display_header (TRUE, ' Physical Memory Size:  64 MB');
        ELSEIF register.value [3] = 0cc(16) THEN
          display_header (TRUE, ' Physical Memory Size:  128 MB');
        ELSE
          display_header (TRUE, ' Physical Memory Size:  Unknown');
        IFEND;
      ELSE
        display_header (TRUE, ' Physical Memory Size:  Unknown');
      IFEND;
      display_trailer;
      RETURN;  {---->
    IFEND;

    dup$retrieve_register (duc$de_memory, 0, 12(16), register);
    IF register.available THEN
      bit_or_byte.byte_part [1] := register.value [1];
      bit_or_byte.byte_part [2] := register.value [2];
      IF bit_or_byte.bit_part [12] THEN
        IF bit_or_byte.bit_part [0] THEN
          display_header (TRUE, ' Physical Memory Size:  2048 MB');
        ELSEIF bit_or_byte.bit_part [1] THEN
          display_header (TRUE, ' Physical Memory Size:  1024 MB');
        ELSEIF bit_or_byte.bit_part [2] THEN
          display_header (TRUE, ' Physical Memory Size:  512 MB');
        ELSEIF bit_or_byte.bit_part [3] THEN
          display_header (TRUE, ' Physical Memory Size:  256 MB');
        ELSEIF bit_or_byte.bit_part [4] THEN
          display_header (TRUE, ' Physical Memory Size:  128 MB');
        ELSEIF bit_or_byte.bit_part [5] THEN
          display_header (TRUE, ' Physical Memory Size:  64 MB');
        ELSEIF bit_or_byte.bit_part [6] THEN
          display_header (TRUE, ' Physical Memory Size:  32 MB');
        ELSEIF bit_or_byte.bit_part [7] THEN
          display_header (TRUE, ' Physical Memory Size:  16 MB');
        ELSEIF bit_or_byte.bit_part [8] THEN
          display_header (TRUE, ' Physical Memory Size:  8 MB');
        ELSEIF bit_or_byte.bit_part [9] THEN
          display_header (TRUE, ' Physical Memory Size:  4 MB');
        ELSEIF bit_or_byte.bit_part [10] THEN
          display_header (TRUE, ' Physical Memory Size:  2 MB');
        ELSEIF bit_or_byte.bit_part [11] THEN
          display_header (TRUE, ' Physical Memory Size:  1 MB');
        ELSE
          display_header (TRUE, ' Physical Memory Size:  Unknown');
        IFEND;
      ELSE
        IF bit_or_byte.bit_part [0] THEN
          display_header (TRUE, ' Physical Memory Size:  1 MB');
        ELSEIF bit_or_byte.bit_part [1] THEN
          display_header (TRUE, ' Physical Memory Size:  2 MB');
        ELSEIF bit_or_byte.bit_part [2] THEN
          display_header (TRUE, ' Physical Memory Size:  3 MB');
        ELSEIF bit_or_byte.bit_part [3] THEN
          display_header (TRUE, ' Physical Memory Size:  4 MB');
        ELSEIF bit_or_byte.bit_part [4] THEN
          display_header (TRUE, ' Physical Memory Size:  5 MB');
        ELSEIF bit_or_byte.bit_part [5] THEN
          display_header (TRUE, ' Physical Memory Size:  6 MB');
        ELSEIF bit_or_byte.bit_part [6] THEN
          display_header (TRUE, ' Physical Memory Size:  7 MB');
        ELSEIF bit_or_byte.bit_part [7] THEN
          display_header (TRUE, ' Physical Memory Size:  8 MB');
        ELSEIF bit_or_byte.bit_part [8] THEN
          display_header (TRUE, ' Physical Memory Size:  10 MB');
        ELSEIF bit_or_byte.bit_part [9] THEN
          display_header (TRUE, ' Physical Memory Size:  12 MB');
        ELSEIF bit_or_byte.bit_part [10] THEN
          display_header (TRUE, ' Physical Memory Size:  14 MB');
        ELSEIF bit_or_byte.bit_part [11] THEN
          display_header (TRUE, ' Physical Memory Size:  16 MB');
        ELSE
          display_header (TRUE, ' Physical Memory Size:  Unknown');
        IFEND;
      IFEND;
      display_trailer;
    ELSE
      display_header (TRUE, ' Physical Memory Size:  Unknown');
      display_trailer;
    IFEND;

  PROCEND display_memory_size;
?? OLDTITLE ??
?? NEWTITLE := 'display_mrb_data', EJECT ??

{ PURPOSE:
{   This procedure displays the information from the Mainframe Element Buffers.

  PROCEDURE display_mrb_data;

    VAR
      date_time_p: ^t$date_time,
      display_first_header: boolean,
      display_string: string (osc$max_string_size),
      fault_symptom_code_p: ^t$fault_symptom_code,
      first_time: boolean,
      ignore_status: ost$status,
      index: dst$dftb_element_size,
      index_2: dst$dftb_element_size,
      index_3: dst$dftb_element_size,
      line: t$descriptor_line,
      mdb_cw_p: ^t$mdb_control_word,
      mrb_cw_p: ^ARRAY [0 .. *] OF dst$dftb_buffer_control_word,
      mrb_p: ^ARRAY [1 .. *] OF dst$dftb_maintenance_registers,
      register_string: string (19),
      save_sorted: t$sorted,
      skip_p: ^SEQ ( * ),
      sorted_p: ^ARRAY [1 .. *] OF t$sorted,
      sorted_size: dst$dftb_element_size,
      ssb_hw_p: ^dst$dftb_buffer_header_word,
      ssb_integer_p: ^integer,
      ssb_iw_p: ^dst$dftb_ssb_information_word,
      string_2: string (2),
      string_length: integer,
      titles: [STATIC] ARRAY [1 .. 3] OF string (38) :=
            ['Control Store Address Before DFT Halt',
             'Control Store Address After DFT Halt',
             'Status Summary Register'];

    display_header (TRUE, ' MRB and SSB Scratch Buffer:');
    clp$put_display (v$display_control, ' Scratch Maintenance Register Buffer Control Word:', clc$trim,
          ignore_status);
    RESET v$restart_file_seq_p TO v$data.buffer [dsc$dftb_rpw_mrb_cw].cell_p;
    print_raw_data (1);
    clp$put_display (v$display_control, v$dash, clc$trim, ignore_status);
    clp$put_display (v$display_control, ' Scratch Maintenance Register Buffer:', clc$trim, ignore_status);
    RESET v$restart_file_seq_p TO v$data.buffer [dsc$dftb_rpw_mrb].cell_p;
    print_raw_data (v$data.mrb_length);
    clp$put_display (v$display_control, v$dash, clc$trim, ignore_status);
    clp$put_display (v$display_control, ' Scratch Supportive Status Buffer:', clc$trim, ignore_status);
    RESET v$restart_file_seq_p TO v$data.buffer [dsc$dftb_rpw_ssb].cell_p;
    NEXT ssb_hw_p IN v$restart_file_seq_p;
    IF ssb_hw_p = NIL THEN
      clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
      RETURN;  {---->
    IFEND;
    print_raw_data (ssb_hw_p^.buffer_size);

    RESET v$restart_file_seq_p TO v$data.buffer [dsc$dftb_rpw_mrb_cw].cell_p;
    NEXT mrb_cw_p: [0 .. v$data.buffer [dsc$dftb_rpw_mrb_cw].size] IN v$restart_file_seq_p;
    IF mrb_cw_p = NIL THEN
      clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
      RETURN;  {---->
    IFEND;
    sorted_size := v$data.buffer [dsc$dftb_rpw_mrb_cw].size - 1;
    PUSH sorted_p: [1 .. sorted_size];

    { Sort the control words into descending order by sequence number.  The scratch buffer is skipped.

    FOR index := 1 TO sorted_size DO
      sorted_p^ [index].sequence := mrb_cw_p^ [index].sequence_number;
      sorted_p^ [index].index := index;
    FOREND;
    FOR index := 1 TO (sorted_size - 1) DO
      FOR index_2 := (index + 1) TO sorted_size DO
        IF sorted_p^ [index].sequence < sorted_p^ [index_2].sequence THEN
          save_sorted := sorted_p^ [index];
          sorted_p^ [index] := sorted_p^ [index_2];
          sorted_p^ [index_2] := save_sorted;
        IFEND;
      FOREND;
    FOREND;

    FOR index := 1 TO duc$dft_max_mdb_buffers DO
      v$data.mdb [index].used := FALSE;
    FOREND;

    { Display the data.

    display_first_header := TRUE;
    FOR index := 1 TO sorted_size DO
      IF sorted_p^ [index].sequence <> 0 THEN
        IF display_first_header THEN
          display_header (TRUE, ' MRB/SSB/MDB Data; listed in descending sequence number order.');
          display_first_header := FALSE;
        IFEND;

        STRINGREP (display_string, string_length, ' MAINTENANCE REGISTER BUFFER CONTROL WORD  (buffer # =',
              sorted_p^ [index].index, '(10)):');
        display_header (TRUE, display_string (1, string_length));

        display_mrb_nrb_control_word (mrb_cw_p^ [sorted_p^ [index].index]);

        STRINGREP (display_string, string_length,
              '   Offset of the associated Maintenance Register Buffer = ',
              mrb_cw_p^ [sorted_p^ [index].index].offset: #(16), '(16)');
        clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);

        clp$put_display (v$display_control, ' MAINTENANCE REGISTER BUFFER:', clc$trim, ignore_status);

        RESET v$restart_file_seq_p TO v$data.buffer [dsc$dftb_rpw_mrb].cell_p;
        NEXT skip_p: [[REP (sorted_p^ [index].index * v$data.mrb_length) OF integer]] IN
              v$restart_file_seq_p;
        IF skip_p = NIL THEN
          clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
          RETURN;  {---->
        IFEND;
        NEXT mrb_p: [1 .. (v$data.mrb_length DIV dsc$dftb_mr_group_size)] IN v$restart_file_seq_p;
        IF mrb_p = NIL THEN
          clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
          RETURN;  {---->
        IFEND;
        first_time := TRUE;

       /display_registers/
        FOR index_2 := 1 TO (v$data.mrb_length DIV dsc$dftb_mr_group_size) DO
          FOR index_3 := 1 TO dsc$dftb_mr_number_of_registers DO
            IF mrb_p^ [index_2].register_header [index_3].register_number = 0 THEN
              IF NOT first_time THEN
                EXIT /display_registers/;  {---->
              ELSE
                first_time := FALSE;
              IFEND;
            IFEND;
            string_2 := 'XX';
            clp$convert_integer_to_rjstring (mrb_p^ [index_2].register_header [index_3].register_number,
                  16, FALSE, '0', string_2, ignore_status);
            retrieve_register_string (mrb_p^ [index_2].register_list [index_3], register_string);
            STRINGREP (display_string, string_length, '   ', string_2, '  ', register_string);
            clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);
          FOREND;
        FOREND /display_registers/;

        clp$put_display (v$display_control, ' SUPPORTIVE STATUS BUFFER:', clc$trim, ignore_status);

        RESET v$restart_file_seq_p TO v$data.buffer [dsc$dftb_rpw_ssb].cell_p;
        NEXT ssb_hw_p IN v$restart_file_seq_p;
        IF ssb_hw_p = NIL THEN
          clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
          RETURN;  {---->
        IFEND;
        NEXT skip_p: [[REP (sorted_p^ [index].index * ssb_hw_p^.buffer_size) OF integer]] IN
              v$restart_file_seq_p;
        IF skip_p = NIL THEN
          clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
          RETURN;  {---->
        IFEND;
        NEXT ssb_iw_p IN v$restart_file_seq_p;
        IF ssb_iw_p = NIL THEN
          clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
          RETURN;  {---->
        IFEND;

        display_element_type (ssb_iw_p^.element_number);

        display_data_type (ssb_iw_p^.mrb_type);

        STRINGREP (display_string, string_length, '   SSB Data Length to Log = ',
              ssb_iw_p^.data_length_to_log, '(10) cm words');
        clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);

        IF ssb_iw_p^.unlogged = 1 THEN
          clp$put_display (v$display_control,
                '   Unlogged MDB condition - An MDB buffer could not be obtained', clc$trim, ignore_status);
        ELSEIF ssb_iw_p^.unlogged = 2 THEN
          clp$put_display (v$display_control,
                '   Unlogged MDB condition - The MDB buffer was overwritten by a higher priority error',
                clc$trim, ignore_status);
        IFEND;

        IF mrb_cw_p^ [sorted_p^ [index].index].flags.valid_mdb_data THEN
          STRINGREP (display_string, string_length, '   Ordinal of Associated MDB Buffer = ',
                ssb_iw_p^.mdb_ordinal);
          clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);
        IFEND;

        STRINGREP (display_string, string_length, '   Logged MRB Size = ', ssb_iw_p^.logged_mrb_size,
              '(10) cm words');
        clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);

        NEXT date_time_p IN v$restart_file_seq_p;
        IF date_time_p = NIL THEN
          clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
          RETURN;  {---->
        IFEND;
        display_date_time (date_time_p^);

        NEXT fault_symptom_code_p IN v$restart_file_seq_p;
        IF fault_symptom_code_p = NIL THEN
          clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
          RETURN;  {---->
        IFEND;
        display_fault_symptom_code (fault_symptom_code_p^);

        clp$put_display (v$display_control, '   Mainframe Element Status:', clc$trim, ignore_status);
        IF (ssb_iw_p^.data_length_to_log - 3) < 1 THEN
          clp$put_display (v$display_control, '     No element status', clc$trim, ignore_status);
        ELSE
          FOR index_2 := 1 TO (ssb_iw_p^.data_length_to_log - 3) DO
            line.data := ' ';
            NEXT ssb_integer_p IN v$restart_file_seq_p;
            IF ssb_integer_p = NIL THEN
              clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
              RETURN;  {---->
            IFEND;
            retrieve_register_string (ssb_integer_p^, line.register_string);
            line.description := titles [index_2];
            STRINGREP (display_string, string_length, '     ', line.data);
            clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);
          FOREND;
        IFEND;

        { Determine and display a matching MDB.

       /find_mdb_match/
        FOR index_2 := 1 TO duc$dft_max_mdb_buffers DO
          IF v$data.mdb [index_2].cell_p <> NIL THEN
            RESET v$restart_file_seq_p TO v$data.mdb [index_2].cell_p;
            NEXT mdb_cw_p IN v$restart_file_seq_p;
            IF mdb_cw_p = NIL THEN
              clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
              RETURN;  {---->
            IFEND;
            IF mdb_cw_p^.sequence_number = mrb_cw_p^ [sorted_p^ [index].index].sequence_number THEN
              v$data.mdb [index_2].used := TRUE;
              display_mdb_data (index_2);
              EXIT /find_mdb_match/;  {---->
            IFEND;
          IFEND;
        FOREND /find_mdb_match/;
        display_trailer;

      IFEND;
    FOREND;

    FOR index := 1 TO duc$dft_max_mdb_buffers DO
      IF NOT v$data.mdb [index].used THEN
        IF v$data.mdb [index].cell_p <> NIL THEN
          RESET v$restart_file_seq_p TO v$data.mdb [index].cell_p;
          NEXT mdb_cw_p IN v$restart_file_seq_p;
          IF mdb_cw_p = NIL THEN
            clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
            RETURN;  {---->
          IFEND;
          IF mdb_cw_p^.sequence_number <> 0 THEN
            display_header (TRUE, ' MODEL DEPENDENT BUFFER (not associated with an existing MRB).');
            display_mdb_data (index);
            display_trailer;
          IFEND;
        IFEND;
      IFEND;
    FOREND;

  PROCEND display_mrb_data;
?? OLDTITLE ??
?? NEWTITLE := 'display_mrb_nrb_control_word', EJECT ??

{ PURPOSE:
{   This procedure displays the information in the MRB or the NRB control word.

  PROCEDURE display_mrb_nrb_control_word
    (    control_word: dst$dftb_buffer_control_word);

    VAR
      dft_analysis_code: dst$dftb_dft_analysis_code,
      dft_analysis_code_message: string (c$message_size),
      dft_analysis_code_string: string (3),
      display_string: string (osc$max_string_size),
      flag_set: boolean,
      ignore_status: ost$status,
      index: dst$dftb_element_size,
      multiple_error: boolean,
      string_length: integer;

    IF (control_word.dft_analysis_code DIV 100(16)) > dsc$dftb_mrb_non THEN
      dft_analysis_code := control_word.dft_analysis_code - 800(16);
      multiple_error := TRUE;
    ELSE
      dft_analysis_code := control_word.dft_analysis_code;
      multiple_error := FALSE;
    IFEND;
    dft_analysis_code_message := '*UNKNOWN DFT ANALYSIS CODE*';

   /retrieve_dft_message/
    FOR index := 1 TO c$number_of_dft_messages DO
      IF v$dft_message [index].dft_analysis_code = dft_analysis_code THEN
        dft_analysis_code_message := v$dft_message [index].value;
        EXIT /retrieve_dft_message/;  {---->
      IFEND;
    FOREND /retrieve_dft_message/;

    STRINGREP (display_string, string_length, '   SEQUENCE NUMBER = ',
          control_word.sequence_number: #(16), '(16)');
    clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);

    IF (control_word.os_action_code >= LOWERBOUND (v$os_action_message)) AND
          (control_word.os_action_code <= UPPERBOUND (v$os_action_message)) THEN
      STRINGREP (display_string, string_length, '   OS Action Code = ',
            control_word.os_action_code: #(16), '(16)', ' ',
            v$os_action_message [control_word.os_action_code]);
    ELSE
      STRINGREP (display_string, string_length, '   OS Action Code = ',
            control_word.os_action_code: #(16), '(16)', ' *UNKNOWN OS ACTION CODE');
    IFEND;
    clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);

    IF (control_word.priority >= LOWERBOUND (v$priority_message)) AND
          (control_word.priority <= UPPERBOUND (v$priority_message)) THEN
      STRINGREP (display_string, string_length, '   Priority = ',  control_word.priority: #(16), '(16)',
            ' ', v$priority_message [control_word.priority]);
    ELSE
      STRINGREP (display_string, string_length, '   Priority = ',  control_word.priority: #(16), '(16)',
            ' *UNKNOWN PRIORITY');
    IFEND;
    clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);

    dft_analysis_code_string := 'XXX';
    clp$convert_integer_to_rjstring (dft_analysis_code, 16, FALSE, '0', dft_analysis_code_string,
          ignore_status);
    STRINGREP (display_string, string_length, '   DFT Analysis Code = ',
          dft_analysis_code_string, '(16)', dft_analysis_code_message);
    clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);
    IF multiple_error THEN
      STRINGREP (display_string, string_length, '   *Multiple Occurrence*');
      clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);
    IFEND;

    STRINGREP (display_string, string_length, '   Flags Indicate:');
    clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);
    flag_set := FALSE;
    IF control_word.flags.unused THEN
      flag_set := TRUE;
      clp$put_display (v$display_control, '     Reserved - future use', clc$trim, ignore_status);
    IFEND;
    IF control_word.flags.valid_mdb_data THEN
      flag_set := TRUE;
      clp$put_display (v$display_control,
            '     Additional status available in a Model Dependent Buffer (MDB)', clc$trim, ignore_status);
    IFEND;
    IF control_word.flags.logging_to_console THEN
      flag_set := TRUE;
      clp$put_display (v$display_control, '     Logging to console flag set (LC)', clc$trim, ignore_status);
    IFEND;
    IF control_word.flags.threshold_exceeded THEN
      flag_set := TRUE;
      clp$put_display (v$display_control,
            '     The error associated with this entry has caused a threshold to be exceeded (T)',
            clc$trim, ignore_status);
    IFEND;
    IF control_word.flags.logging_action THEN
      flag_set := TRUE;
      clp$put_display (v$display_control,
            '     The error being reported has not yet been logged by the OS (L)', clc$trim, ignore_status);
    IFEND;
    IF control_word.flags.interlock THEN
      flag_set := TRUE;
      clp$put_display (v$display_control, '     The Buffer is Interlocked (I)', clc$trim, ignore_status);
    IFEND;
    IF control_word.flags.c180_valid_data THEN
      flag_set := TRUE;
      clp$put_display (v$display_control, '     Error not yet processed by the 180 side (V8)', clc$trim,
            ignore_status);
    IFEND;
    IF control_word.flags.c170_valid_data THEN
      flag_set := TRUE;
      clp$put_display (v$display_control, '     Error not yet processed by the 170 side (V7)', clc$trim,
            ignore_status);
    IFEND;
    IF NOT flag_set THEN
      clp$put_display (v$display_control, '     No flags set', clc$trim, ignore_status);
    IFEND;

  PROCEND display_mrb_nrb_control_word;
?? OLDTITLE ??
?? NEWTITLE := 'display_nrb_data', EJECT ??

{ PURPOSE:
{   This procedure displays the information from the Non Status Register Buffers.

  PROCEDURE display_nrb_data;

    VAR
      date_time_p: ^t$date_time,
      display_first_header: boolean,
      display_string: string (osc$max_string_size),
      fault_symptom_code_p: ^t$fault_symptom_code,
      ignore_status: ost$status,
      index: dst$dftb_element_size,
      index_2: dst$dftb_element_size,
      nrb_cw_p: ^dst$dftb_buffer_control_word,
      nrb_hw_p: ^dst$dftb_buffer_header_word,
      nrb_integer_p: ^integer,
      nrb_iw_p: ^dst$dftb_nrb_information_word,
      register_string: string (19),
      save_sorted: t$sorted,
      skip_nrb_hw_p: ^dst$dftb_buffer_header_word,
      skip_p: ^SEQ ( * ),
      sorted_p: ^ARRAY [1 .. *] OF t$sorted,
      sorted_size: dst$dftb_element_size,
      string_length: integer;

    display_header (TRUE, ' NON REGISTER STATUS BUFFER (scratch buffer):');
    RESET v$restart_file_seq_p TO v$data.buffer [dsc$dftb_rpw_nrb].cell_p;
    NEXT nrb_hw_p IN v$restart_file_seq_p;
    IF nrb_hw_p = NIL THEN
      clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
      RETURN;  {---->
    IFEND;
    print_raw_data (nrb_hw_p^.buffer_size);

    RESET v$restart_file_seq_p TO v$data.buffer [dsc$dftb_rpw_nrb].cell_p;
    NEXT nrb_hw_p IN v$restart_file_seq_p;
    IF nrb_hw_p = NIL THEN
      clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
      RETURN;  {---->
    IFEND;
    sorted_size := nrb_hw_p^.number_of_buffers - 1;
    PUSH sorted_p: [1 .. sorted_size];

    { Sort the control words into descending order by sequence number.  The scratch buffer is skipped.

    FOR index := 1 TO sorted_size DO
      RESET v$restart_file_seq_p TO v$data.buffer [dsc$dftb_rpw_nrb].cell_p;
      NEXT skip_nrb_hw_p IN v$restart_file_seq_p;
      IF skip_nrb_hw_p = NIL THEN
        clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
        RETURN;  {---->
      IFEND;
      NEXT skip_p: [[REP (index * nrb_hw_p^.buffer_size) OF integer]] IN v$restart_file_seq_p;
      IF skip_p = NIL THEN
        clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
        RETURN;  {---->
      IFEND;
      NEXT nrb_cw_p IN v$restart_file_seq_p;
      IF nrb_cw_p = NIL THEN
        clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
        RETURN;  {---->
      IFEND;
      sorted_p^ [index].sequence := nrb_cw_p^.sequence_number;
      sorted_p^ [index].index := index;
    FOREND;
    FOR index := 1 TO (sorted_size - 1) DO
      FOR index_2 := (index + 1) TO sorted_size DO
        IF sorted_p^ [index].sequence < sorted_p^ [index_2].sequence THEN
          save_sorted := sorted_p^ [index];
          sorted_p^ [index] := sorted_p^ [index_2];
          sorted_p^ [index_2] := save_sorted;
        IFEND;
      FOREND;
    FOREND;

    { Display the data.

    display_first_header := TRUE;
    FOR index := 1 TO sorted_size DO
      IF sorted_p^ [index].sequence <> 0 THEN
        IF display_first_header THEN
          display_header (TRUE, ' NRSB Data; listed in descending sequence number order.');
          display_first_header := FALSE;
        IFEND;

        STRINGREP (display_string, string_length, ' NON REGISTER STATUS BUFFER (index=',
              sorted_p^ [index].index, '(10)):');
        display_header (TRUE, display_string (1, string_length));

        RESET v$restart_file_seq_p TO v$data.buffer [dsc$dftb_rpw_nrb].cell_p;
        NEXT skip_nrb_hw_p IN v$restart_file_seq_p;
        IF skip_nrb_hw_p = NIL THEN
          clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
          RETURN;  {---->
        IFEND;
        NEXT skip_p: [[REP (sorted_p^ [index].index * nrb_hw_p^.buffer_size) OF integer]] IN
              v$restart_file_seq_p;
        IF skip_p = NIL THEN
          clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
          RETURN;  {---->
        IFEND;
        NEXT nrb_cw_p IN v$restart_file_seq_p;
        IF nrb_cw_p = NIL THEN
          clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
          RETURN;  {---->
        IFEND;

        display_mrb_nrb_control_word (nrb_cw_p^);

        NEXT nrb_iw_p IN v$restart_file_seq_p;
        IF nrb_iw_p = NIL THEN
          clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
          RETURN;  {---->
        IFEND;
        display_element_type (nrb_iw_p^.element_number);
        display_data_type (nrb_iw_p^.mrb_type);

        STRINGREP (display_string, string_length, '   NRSB Data Length to Log = ',
              nrb_iw_p^.data_length_to_log, '(10) cm words');
        clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);

        NEXT date_time_p IN v$restart_file_seq_p;
        IF date_time_p = NIL THEN
          clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
          RETURN;  {---->
        IFEND;
        display_date_time (date_time_p^);

        NEXT fault_symptom_code_p IN v$restart_file_seq_p;
        IF fault_symptom_code_p = NIL THEN
          clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
          RETURN;  {---->
        IFEND;
        display_fault_symptom_code (fault_symptom_code_p^);

        clp$put_display (v$display_control, '   Error Dependent Data:', clc$trim, ignore_status);
        IF (nrb_iw_p^.data_length_to_log - 4) < 1 THEN
          clp$put_display (v$display_control, '     No dependent data', clc$trim, ignore_status);
        ELSE
          IF nrb_cw_p^.dft_analysis_code = 707(16) THEN
            display_mec_data (FALSE);
          ELSEIF nrb_cw_p^.dft_analysis_code = 708(16) THEN
            NEXT nrb_integer_p IN v$restart_file_seq_p;
            IF nrb_integer_p = NIL THEN
              clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
              RETURN;  {---->
            IFEND;
            retrieve_register_string (nrb_integer_p^, register_string);
            STRINGREP (display_string, string_length, '     Options Installed = ', register_string);
            clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);
            NEXT nrb_integer_p IN v$restart_file_seq_p;
            IF nrb_integer_p = NIL THEN
              clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
              RETURN;  {---->
            IFEND;
            retrieve_register_string (nrb_integer_p^, register_string);
            STRINGREP (display_string, string_length, '     Element id register = ', register_string);
            clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);
            display_secded_id_data (FALSE);
          ELSE
            FOR index_2 := 1 TO (nrb_iw_p^.data_length_to_log - 4) DO
              NEXT nrb_integer_p IN v$restart_file_seq_p;
              IF nrb_integer_p = NIL THEN
                clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
                RETURN;  {---->
              IFEND;
              retrieve_register_string (nrb_integer_p^, register_string);
              STRINGREP (display_string, string_length, '     ', register_string);
              clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);
            FOREND;
          IFEND;
        IFEND;
      IFEND;
    FOREND;

  PROCEND display_nrb_data;
?? OLDTITLE ??
?? NEWTITLE := 'display_os_buffer_data', EJECT ??

{ PURPOSE:
{   This procedure displays the information in the NOS/VE Buffer or the C170 OS Buffer.

  PROCEDURE display_os_buffer_data
    (    display_nosve_buffer: boolean);

    TYPE
      t$integer_or_r_pointer = RECORD
        CASE boolean OF
        = TRUE =
          integer_part: integer,
        = FALSE =
          r_pointer_part: dst$r_pointer,
        CASEND,
      RECEND,

      t$line = RECORD
        CASE boolean OF
        = TRUE =
          spaces: string (3),
          title: string (26),
          r_pointer: string (19),
          rma_title: string (10),
        = FALSE =
          data: string (60),
        CASEND,
      RECEND;

    VAR
      display_string: string (osc$max_string_size),
      ignore_status: ost$status,
      index: dst$dftb_element_size,
      integer_or_r_pointer_p: ^t$integer_or_r_pointer,
      line: t$line,
      rma: integer,
      size: dst$dftb_element_size,
      string_length: integer,
      titles: [STATIC] ARRAY [1 .. 4] OF string (26) :=
            ['SCI/VPB Request Pointer = ',
             '    SDA Request Pointer = ',
             ' NOS/VE Request Pointer = ',
             ' Unused Request Pointer = '];

    IF display_nosve_buffer THEN
      display_header (TRUE, ' NOS/VE BUFFER:');
      RESET v$restart_file_seq_p TO v$data.buffer [dsc$dftb_rpw_nosve_buffer].cell_p;
      size := v$data.buffer [dsc$dftb_rpw_nosve_buffer].size;
    ELSE
      display_header (TRUE, ' C170 OS BUFFER:');
      RESET v$restart_file_seq_p TO v$data.buffer [dsc$dftb_rpw_c170_os_buffer].cell_p;
      size := v$data.buffer [dsc$dftb_rpw_c170_os_buffer].size;
    IFEND;

    FOR index := 1 TO size DO
      line.data := ' ';
      IF display_nosve_buffer THEN
        line.title := titles [index];
      ELSE
        line.title := '  C170 OS Request Pointer = ';
      IFEND;
      NEXT integer_or_r_pointer_p IN v$restart_file_seq_p;
      IF integer_or_r_pointer_p = NIL THEN
        clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
        RETURN;  {---->
      IFEND;
      retrieve_register_string (integer_or_r_pointer_p^.integer_part, line.r_pointer);
      line.rma_title := '    RMA = ';
      rma := integer_or_r_pointer_p^.r_pointer_part.rupper * 10000000(8) +
            integer_or_r_pointer_p^.r_pointer_part.rlower * 1000(8) +
            integer_or_r_pointer_p^.r_pointer_part.offset * 10(8);
      STRINGREP (display_string, string_length, line.data, rma: #(16), '(16)');
      clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);
    FOREND;
    display_trailer;

  PROCEND display_os_buffer_data;
?? OLDTITLE ??
?? NEWTITLE := 'display_pp_reg_save_area_data', EJECT ??

{ PURPOSE:
{   This procedure displays the contents of the PP register save area buffer.

  PROCEDURE display_pp_reg_save_area_data;

    TYPE
      t$dft_apqk = RECORD
        p: t$dft_pp_register,
        q: t$dft_pp_register,
        k: t$dft_pp_register,
        a: t$dft_pp_register,
        p2: t$dft_pp_register,
        q2: t$dft_pp_register,
        k2: t$dft_pp_register,
        a2: t$dft_pp_register,
      RECEND,

      t$line = RECORD
        CASE boolean OF
        = TRUE =
          spaces: string (3),
          first_register_name: string (12),
          first_register: string (15),
          second_register_name: string (13),
          second_register: string (11),
        = FALSE =
          data: string (54),
        CASEND,
      RECEND,

      t$offset = RECORD
        rfu: 0 .. 0ffffffff(16),
        offset: 0 .. 0ffffffff(16),
      RECEND,

      t$pp_id_line = RECORD
        CASE boolean OF
        = TRUE =
          line: string (15),
        = FALSE =
          space_1: string (3),
          iou_word: string (3),
          iou_number: string (1),
          space_2: string (2),
          cio_id: string (1),
          pp_word: string (2),
          pp_number: string (2),
          colon: string (1),
        CASEND,
      RECEND,

      t$dft_pp_register = 0 .. 0ffffffff(16),

      t$pp_type = (c$nio_0_11, c$nio_20_31, c$cio_0_11);

    VAR
      apqk_p: ^t$dft_apqk,
      data_size: integer,
      display_string: string (osc$max_string_size),
      dump_information: dut$dump_information,
      ignore_status: ost$status,
      iou_number: 0 .. duc$de_maximum_ious,
      line: t$line,
      offset_p: ^t$offset,
      pp_id_line: t$pp_id_line,
      pp_number: 0 .. 31(8),
      pp_register_string: string (11),
      pp_type: t$pp_type,
      string_length: integer;

    display_header (TRUE, ' PP REGISTER SAVE AREA:');
    RESET v$restart_file_seq_p TO v$data.buffer [dsc$dftb_rpw_pp_reg_save_area].cell_p;
    data_size := v$data.buffer [dsc$dftb_rpw_pp_reg_save_area].size * 8;
    NEXT offset_p IN v$restart_file_seq_p;
    IF offset_p = NIL THEN
      clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
      RETURN;  {---->
    IFEND;
    data_size := data_size - #SIZE (t$offset);
    STRINGREP (display_string, string_length, '   Offset to Secondary IOU PP register save area = ',
          offset_p^.offset);
    clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);
    iou_number := 0;
    pp_number := 0;
    pp_type := c$nio_0_11;
    dup$determine_dump_information (dump_information);

    WHILE data_size > #SIZE (t$dft_apqk) DO

     /display_pp_reg_data/
      BEGIN
        NEXT apqk_p IN v$restart_file_seq_p;
        IF apqk_p = NIL THEN
          clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
          RETURN;  {---->
        IFEND;
        data_size := data_size - #SIZE (t$dft_apqk);
        IF (apqk_p^.p = 0) AND (apqk_p^.q = 0) AND (apqk_p^.k = 0) AND (apqk_p^.a = 0) AND
              (apqk_p^.p2 = 0) AND (apqk_p^.q2 = 0) AND (apqk_p^.k2 = 0) AND (apqk_p^.a2 = 0) THEN
          EXIT /display_pp_reg_data/;  {---->
        IFEND;

        clp$put_display (v$display_control, v$dash, clc$trim, ignore_status);
        pp_id_line.line := ' ';
        pp_id_line.iou_word := 'IOU';
        clp$convert_integer_to_rjstring (iou_number, 8, FALSE, '0', pp_id_line.iou_number, ignore_status);
        IF (pp_type = c$cio_0_11) OR (dump_information.iou [iou_number].model = duc$di_im_i4_43) OR
              (dump_information.iou [iou_number].model = duc$di_im_i4_44) OR
              (dump_information.iou [iou_number].model = duc$di_im_i4_46) THEN
          pp_id_line.cio_id := 'C';
        IFEND;
        pp_id_line.pp_word := 'PP';
        clp$convert_integer_to_rjstring (pp_number, 8, FALSE, '0', pp_id_line.pp_number, ignore_status);
        pp_id_line.colon := ':';
        clp$put_display (v$display_control, pp_id_line.line, clc$trim, ignore_status);

        line.data := ' ';
        line.first_register_name := 'P Register';
        clp$convert_integer_to_rjstring (apqk_p^.p, 8, FALSE, '0', pp_register_string, ignore_status);
        line.first_register := pp_register_string;
        line.second_register_name := 'P'' Register';
        clp$convert_integer_to_rjstring (apqk_p^.p2, 8, FALSE, '0', pp_register_string, ignore_status);
        line.second_register := pp_register_string;
        clp$put_display (v$display_control, line.data, clc$trim, ignore_status);

        line.data := ' ';
        IF dump_information.iou [iou_number].model = duc$di_im_i0_5x THEN
          line.first_register_name := 'D Register';
        ELSE
          line.first_register_name := 'Q Register';
        IFEND;
        clp$convert_integer_to_rjstring (apqk_p^.q, 8, FALSE, '0', pp_register_string, ignore_status);
        line.first_register := pp_register_string;
        IF dump_information.iou [iou_number].model = duc$di_im_i0_5x THEN
          line.second_register_name := 'D'' Register';
        ELSE
          line.second_register_name := 'Q'' Register';
        IFEND;
        clp$convert_integer_to_rjstring (apqk_p^.q2, 8, FALSE, '0', pp_register_string, ignore_status);
        line.second_register := pp_register_string;
        clp$put_display (v$display_control, line.data, clc$trim, ignore_status);

        line.data := ' ';
        line.first_register_name := 'K Register';
        clp$convert_integer_to_rjstring (apqk_p^.k, 8, FALSE, '0', pp_register_string, ignore_status);
        line.first_register := pp_register_string;
        line.second_register_name := 'K'' Register';
        clp$convert_integer_to_rjstring (apqk_p^.k2, 8, FALSE, '0', pp_register_string, ignore_status);
        line.second_register := pp_register_string;
        clp$put_display (v$display_control, line.data, clc$trim, ignore_status);

        line.data := ' ';
        line.first_register_name := 'A Register';
        clp$convert_integer_to_rjstring (apqk_p^.a, 8, FALSE, '0', pp_register_string, ignore_status);
        line.first_register := pp_register_string;
        line.second_register_name := 'A'' Register';
        clp$convert_integer_to_rjstring (apqk_p^.a2, 8, FALSE, '0', pp_register_string, ignore_status);
        line.second_register := pp_register_string;
        clp$put_display (v$display_control, line.data, clc$trim, ignore_status);

      END /display_pp_reg_data/;

      IF pp_number = 11(8) THEN
        IF pp_type = c$nio_0_11 THEN
          pp_number := 20(8);
          pp_type := c$nio_20_31;
        ELSE  { pp_type = c$cio_0_11
          iou_number := 1;
          pp_number := 0;
          pp_type := c$nio_0_11
        IFEND;
      ELSEIF pp_number = 31(8) THEN
        pp_number := 0;
        pp_type := c$cio_0_11;
      ELSE
        pp_number := pp_number + 1;
      IFEND;

    WHILEND;

  PROCEND display_pp_reg_save_area_data;
?? OLDTITLE ??
?? NEWTITLE := 'display_secded_id_data', EJECT ??

{ PURPOSE:
{   This procedure displays the SECDED ID Table information.

  PROCEDURE display_secded_id_data
    (    full_display: boolean);

    TYPE
      t$line = RECORD
        CASE boolean OF
        = TRUE =
          spaces: string (5),
          count: string (7),
          address: string (11),
          syndrome: string (8),
        = FALSE =
          data: string (31),
        CASEND,
      RECEND;

    VAR
      display_string: string (osc$max_string_size),
      ignore_status: ost$status,
      index: dst$dftb_element_size,
      integer_p: ^integer,
      line: t$line,
      register_string: string (19),
      string_length: integer;

    IF full_display THEN
      display_header (TRUE, ' CURRENT SECDED ID TABLE:');
      RESET v$restart_file_seq_p TO v$data.buffer [dsc$dftb_rpw_secded_id].cell_p;
    IFEND;
    line.data := ' ';
    line.count := 'COUNT';
    line.address := ' ADDRESS';
    line.syndrome := 'SYNDROME';
    clp$put_display (v$display_control, line.data, clc$trim, ignore_status);

    FOR index := 1 TO v$data.buffer [dsc$dftb_rpw_secded_id].size DO
      line.data := ' ';
      NEXT integer_p IN v$restart_file_seq_p;
      IF integer_p = NIL THEN
        clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
        RETURN;  {---->
      IFEND;
      retrieve_register_string (integer_p^, register_string);
      line.count := register_string (1, 4);
      line.address := register_string (6, 9);
      line.syndrome (3, 4) := register_string (16, 4);
      clp$put_display (v$display_control, line.data, clc$trim, ignore_status);
    FOREND;

    IF full_display THEN
      display_trailer;
    IFEND;

  PROCEND display_secded_id_data;
?? OLDTITLE ??
?? NEWTITLE := 'display_secondary_dft_data', EJECT ??

{ PURPOSE:
{   This procedure will display information in the Secondary DFT Buffer.

  PROCEDURE display_secondary_dft_data;

    VAR
      dftb_cw_p: ^dst$dftb_control_word,
      display_string: string (osc$max_string_size),
      ignore_status: ost$status,
      index: dst$dftb_element_size,
      integer_p: ^integer,
      main_dft_cw_p: ^dst$dftb_control_word,
      register_string: string (19),
      skip_p: ^SEQ ( * ),
      ssb_hw_p: ^dst$dftb_buffer_header_word,
      string_length: integer;

    display_header (TRUE, ' SECONDARY DFT BUFFER:');

    RESET v$restart_file_seq_p TO v$data.buffer [duc$dft_cw].cell_p;
    NEXT main_dft_cw_p IN v$restart_file_seq_p;
    IF main_dft_cw_p = NIL THEN
      clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
      RETURN;  {---->
    IFEND;
    RESET v$restart_file_seq_p TO v$data.buffer[dsc$dftb_rpw_dft_secondary].cell_p;
    NEXT dftb_cw_p IN v$restart_file_seq_p;
    IF dftb_cw_p = NIL THEN
      clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
      RETURN;  {---->
    IFEND;
    IF (main_dft_cw_p^.pointer_words <> dftb_cw_p^.pointer_words) OR
          (main_dft_cw_p^.revision_level <> dftb_cw_p^.revision_level) OR
          (main_dft_cw_p^.mrb_length <> dftb_cw_p^.mrb_length) THEN
      clp$put_display (v$display_control, ' Secondary DFT Buffer is damaged - cannot display the contents.',
            clc$trim, ignore_status);
      RETURN;  {---->
    IFEND;

    clp$put_display (v$display_control, ' Secondary DFT Buffer Control Word:', clc$trim, ignore_status);

    RESET v$restart_file_seq_p TO v$data.buffer[dsc$dftb_rpw_dft_secondary].cell_p;
    display_dft_control_word (TRUE);

    RESET v$restart_file_seq_p TO v$data.buffer[dsc$dftb_rpw_dft_secondary].cell_p;
    NEXT dftb_cw_p IN v$restart_file_seq_p;
    IF dftb_cw_p = NIL THEN
      clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
      RETURN;  {---->
    IFEND;

    NEXT skip_p: [[REP (v$data.actual_number_of_pointer_words + 2) OF integer]] IN v$restart_file_seq_p;
    IF skip_p = NIL THEN
      clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
      RETURN;  {---->
    IFEND;
    clp$put_display (v$display_control, '   Secondary Maintenance Register Buffer Control Words:',
          clc$trim, ignore_status);
    FOR index := 1 TO dftb_cw_p^.number_of_mrbs DO
      NEXT integer_p IN v$restart_file_seq_p;
      IF integer_p = NIL THEN
        clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
        RETURN;  {---->
      IFEND;
      retrieve_register_string (integer_p^, register_string);
      STRINGREP (display_string, string_length, '     ', register_string);
      clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);
    FOREND;

    NEXT skip_p: [[REP 2 OF integer]] IN v$restart_file_seq_p;
    IF skip_p = NIL THEN
      clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
      RETURN;  {---->
    IFEND;
    clp$put_display (v$display_control, '   Secondary Maintenance Register Buffer:', clc$trim, ignore_status);
    FOR index := 1 TO dftb_cw_p^.mrb_length DO
      NEXT integer_p IN v$restart_file_seq_p;
      IF integer_p = NIL THEN
        clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
        RETURN;  {---->
      IFEND;
      retrieve_register_string (integer_p^, register_string);
      STRINGREP (display_string, string_length, '     ', register_string);
      clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);
    FOREND;

    NEXT skip_p: [[REP 2 OF integer]] IN v$restart_file_seq_p;
    IF skip_p = NIL THEN
      clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
      RETURN;  {---->
    IFEND;
    clp$put_display (v$display_control, '   Secondary Supportive Status Buffer:', clc$trim, ignore_status);
    NEXT ssb_hw_p IN v$restart_file_seq_p;
    IF ssb_hw_p = NIL THEN
      clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
      RETURN;  {---->
    IFEND;
    FOR index := 1 TO (ssb_hw_p^.number_of_buffers * ssb_hw_p^.buffer_size) DO
      NEXT integer_p IN v$restart_file_seq_p;
      IF integer_p = NIL THEN
        clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
        RETURN;  {---->
      IFEND;
      retrieve_register_string (integer_p^, register_string);
      STRINGREP (display_string, string_length, '     ', register_string);
      clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);
    FOREND;
    display_trailer;

  PROCEND display_secondary_dft_data;
?? OLDTITLE ??
?? NEWTITLE := 'display_trailer', EJECT ??

{ PURPOSE:
{   This procedure displays a trailer on the output file.

  PROCEDURE display_trailer;

    VAR
      ignore_status: ost$status;

    clp$put_display (v$display_control, v$star, clc$trim, ignore_status);
    clp$put_display (v$display_control, ' ', clc$trim, ignore_status);

  PROCEND display_trailer;
?? OLDTITLE ??
?? NEWTITLE := 'print_raw_data', EJECT ??

{ PURPOSE:
{   This procedure prints the raw data of a buffer.

  PROCEDURE print_raw_data
    (    data_size: dst$dftb_element_size);

    TYPE
      t$line = RECORD
        data: string (80),
        size: 1 .. 80,
      RECEND;

    VAR
      buffer_size: dst$dftb_element_size,
      display_string: string (osc$max_string_size),
      ignore_status: ost$status,
      integer_p: ^integer,
      line: t$line,
      previous_line: t$line,
      register_string: string (19),
      repeated_lines: integer,
      string_length: integer;

    buffer_size := data_size;
    line.size := 1;
    line.data := ' ';
    previous_line := line;
    repeated_lines := 0;

    WHILE buffer_size > 0 DO
      NEXT integer_p IN v$restart_file_seq_p;
      IF integer_p = NIL THEN
        clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
        RETURN;  {---->
      IFEND;
      buffer_size := buffer_size - 1;
      retrieve_register_string (integer_p^, register_string);
      line.data (line.size, #SIZE (register_string)) := register_string;
      line.size := line.size + #SIZE (register_string) + 2;
      IF (line.size > 60) OR (buffer_size <= 0) THEN
        IF (line = previous_line) AND (buffer_size > 0) THEN
          repeated_lines := repeated_lines + 1;
        ELSE
          IF repeated_lines = 1 THEN
            clp$put_display (v$display_control, previous_line.data (1, previous_line.size), clc$trim,
                  ignore_status);
          ELSEIF repeated_lines > 1 THEN
            STRINGREP (display_string, string_length, ' -- ', repeated_lines,
                  ' duplicate lines are suppressed.');
            clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);
          IFEND;
          repeated_lines := 0;
          clp$put_display (v$display_control, line.data (1, line.size), clc$trim, ignore_status);
          previous_line := line;
        IFEND;
        line.size := 1;
        line.data := ' ';
      IFEND;
    WHILEND;

  PROCEND print_raw_data;
?? OLDTITLE ??
?? NEWTITLE := 'retrieve_register_string', EJECT ??

{ PURPOSE:
{   This procedure builds a string of the register data it is sent.

  PROCEDURE retrieve_register_string
    (    register_value: integer;
     VAR register_string: string (19));

    TYPE
      t$array_or_integer = RECORD
        CASE boolean OF
        = TRUE =
          array_part: ARRAY [1 .. 4] OF 0 .. 0ffff(16),
        = FALSE =
          integer_part: integer,
        CASEND,
      RECEND;

    VAR
      array_or_integer_p: ^t$array_or_integer,
      ignore_status: ost$status,
      index: 1 .. 4,
      register_seq_p: ^SEQ (REP 1 OF integer),
      register_string_index: 0 .. 0ff(16),
      string_4: string (4);

    PUSH register_seq_p;
    NEXT array_or_integer_p IN register_seq_p;
    IF array_or_integer_p = NIL THEN
      clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
      RETURN;  {---->
    IFEND;
    array_or_integer_p^.integer_part := register_value;

    register_string := ' ';
    register_string_index := 1;
    FOR index := 1 TO 4 DO
      string_4 := 'XXXX';
      clp$convert_integer_to_rjstring (array_or_integer_p^ .array_part [index], 16, FALSE, '0',
            string_4, ignore_status);
      register_string (register_string_index, 4) := string_4;
      register_string_index := register_string_index + 5;
    FOREND;

  PROCEND retrieve_register_string;
?? OLDTITLE ??
?? NEWTITLE := 'dup$process_dft_buffer_command', EJECT ??

{ PURPOSE:
{   This procedure displays the information from the DFT buffer.

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

{ PROCEDURE process_dft_buffer, prodb (
{   display_option, do: any of
{       key
{         (all)
{       keyend
{       list of key
{         (dft_control_word) (mrb_ssb_mdb) (nrsb) (secded_id_table) (mec) (dft_error_control)
{         (pp_register_save_area) (nosve_buffer) (dft_cm_resident) (c170_pp_resident) (c170_os_buffer)
{         (secondary_dft_buffer)
{       keyend
{     anyend = all
{   display_type, dt: key
{       (detailed, d) (raw, r)
{     keyend = detailed
{   display_mdb_capture_buffer, dmcb: boolean = FALSE
{   output, o: file = $optional
{   title, t: string 1..31 = 'process_dft_buffer'
{   status)

?? PUSH (LISTEXT := ON) ??
?? FMT (FORMAT := OFF) ??

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 11] of clt$pdt_parameter_name,
      parameters: array [1 .. 6] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 1] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: 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 .. 12] of clt$keyword_specification,
          recend,
        recend,
        default_value: string (3),
      recend,
      type2: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 4] of clt$keyword_specification,
        default_value: string (8),
      recend,
      type3: record
        header: clt$type_specification_header,
        default_value: string (5),
      recend,
      type4: record
        header: clt$type_specification_header,
      recend,
      type5: record
        header: clt$type_specification_header,
        qualifier: clt$string_type_qualifier,
        default_value: string (20),
      recend,
      type6: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [90, 4, 16, 9, 56, 45, 2],
    clc$command, 11, 6, 0, 0, 0, 0, 6, ''], [
    ['DISPLAY_MDB_CAPTURE_BUFFER     ',clc$nominal_entry, 3],
    ['DISPLAY_OPTION                 ',clc$nominal_entry, 1],
    ['DISPLAY_TYPE                   ',clc$nominal_entry, 2],
    ['DMCB                           ',clc$abbreviation_entry, 3],
    ['DO                             ',clc$abbreviation_entry, 1],
    ['DT                             ',clc$abbreviation_entry, 2],
    ['O                              ',clc$abbreviation_entry, 4],
    ['OUTPUT                         ',clc$nominal_entry, 4],
    ['STATUS                         ',clc$nominal_entry, 6],
    ['T                              ',clc$abbreviation_entry, 5],
    ['TITLE                          ',clc$nominal_entry, 5]],
    [
{ 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, 531,
  clc$optional_default_parameter, 0, 3],
{ PARAMETER 2
    [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, 155,
  clc$optional_default_parameter, 0, 8],
{ PARAMETER 3
    [1, 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_default_parameter, 0, 5],
{ PARAMETER 4
    [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, 3, clc$optional_parameter, 0
  , 0],
{ PARAMETER 5
    [11, 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, 20],
{ PARAMETER 6
    [9, 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$union_type], [[clc$keyword_type, clc$list_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['ALL                            ', clc$nominal_entry, clc$normal_usage_entry, 1]]
      ],
    467, [[1, 0, clc$list_type], [451, 1, clc$max_list_size, 0, FALSE, FALSE],
        [[1, 0, clc$keyword_type], [12], [
        ['C170_OS_BUFFER                 ', clc$nominal_entry, clc$normal_usage_entry, 11],
        ['C170_PP_RESIDENT               ', clc$nominal_entry, clc$normal_usage_entry, 10],
        ['DFT_CM_RESIDENT                ', clc$nominal_entry, clc$normal_usage_entry, 9],
        ['DFT_CONTROL_WORD               ', clc$nominal_entry, clc$normal_usage_entry, 1],
        ['DFT_ERROR_CONTROL              ', clc$nominal_entry, clc$normal_usage_entry, 6],
        ['MEC                            ', clc$nominal_entry, clc$normal_usage_entry, 5],
        ['MRB_SSB_MDB                    ', clc$nominal_entry, clc$normal_usage_entry, 2],
        ['NOSVE_BUFFER                   ', clc$nominal_entry, clc$normal_usage_entry, 8],
        ['NRSB                           ', clc$nominal_entry, clc$normal_usage_entry, 3],
        ['PP_REGISTER_SAVE_AREA          ', clc$nominal_entry, clc$normal_usage_entry, 7],
        ['SECDED_ID_TABLE                ', clc$nominal_entry, clc$normal_usage_entry, 4],
        ['SECONDARY_DFT_BUFFER           ', clc$nominal_entry, clc$normal_usage_entry, 12]]
        ]
      ]
    ,
    'all'],
{ PARAMETER 2
    [[1, 0, clc$keyword_type], [4], [
    ['D                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
    ['DETAILED                       ', clc$nominal_entry, clc$normal_usage_entry, 1],
    ['R                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
    ['RAW                            ', clc$nominal_entry, clc$normal_usage_entry, 2]]
    ,
    'detailed'],
{ PARAMETER 3
    [[1, 0, clc$boolean_type],
    'FALSE'],
{ PARAMETER 4
    [[1, 0, clc$file_type]],
{ PARAMETER 5
    [[1, 0, clc$string_type], [1, 31, FALSE],
    '''process_dft_buffer'''],
{ PARAMETER 6
    [[1, 0, clc$status_type]]];
?? FMT (FORMAT := ON) ??
?? POP ??

    CONST
      p$display_option = 1,
      p$display_type = 2,
      p$display_mdb_capture_buffer = 3,
      p$output = 4,
      p$title = 5,
      p$status = 6;

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

    VAR
      data_length_valid: boolean,
      data_valid: boolean,
      dft_cw_p: ^dst$dftb_control_word,
      display_all_data: boolean,
      display_data: ARRAY [0 .. duc$dft_max_known_pointer_words] OF boolean,
      display_string: string (osc$max_string_size),
      ignore_status: ost$status,
      index: 1 .. duc$dft_max_mdb_buffers,
      list_p: ^clt$data_value,
      new_byte_size: ost$segment_length,
      option_p: ^clt$data_value,
      output_display_opened: boolean,
      ring_attributes: amt$ring_attributes,
      string_length: integer,
      titles: [STATIC] ARRAY [0 .. duc$dft_max_known_pointer_words] OF string (76) :=
            [' ------------    D F T  B U F F E R  C O N T R O L  W O R D     ------------',
             ' ------------            S E C D E D  I D  T A B L E            ------------',
             ' ----------- M A I N T E N A N C E  R E G I S T E R  B U F F E R -----------',
             ' ------------     M O D E L  D E P E N D E N T  B U F F E R     ------------',
             ' ------------             N O S / V E  B U F F E R              ------------',
             ' ------------    C 1 7 0  P P  R E S I D E N T  B U F F E R     ------------',
             ' ------------             C 1 7 0  O S  B U F F E R             ------------',
             ' ------------          M R B  C O N T R O L  W O R D S          ------------',
             ' ------ M A I N F R A M E  E L E M E N T  C O U N T E R  B U F F E R  ------',
             ' ------------   D F T  E R R O R  C O N T R O L  R E C O R D    ------------',
             ' ------------   S U P P O R T I V E  S T A T U S  B U F F E R   ------------',
             ' ------------ N O N  R E G I S T E R  S T A T U S  B U F F E R  ------------',
             ' ----------- D F T  C E N T R A L  M E M O R Y  R E S I D E N T ------------',
             ' ------------      P P  R E G I S T E R  S A V E  A R E A       ------------',
             ' ------------       S E C O N D A R Y  D F T  B U F F E R       ------------'],
      titles_pointer_word: [STATIC] string (76) :=
             ' ------------             P O I N T E R  W O R D S              ------------',
      word_index: 0 .. duc$dft_max_known_pointer_words;

*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 (v$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, v$display_control, status);
        IF NOT status.normal THEN
          EXIT /display_opened/;  {---->
        IFEND;
        output_display_opened := TRUE;
      ELSE
        v$display_control := duv$execution_environment.output_file.display_control;
        v$display_control.line_number := v$display_control.page_length + 1;
      IFEND;

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

      v$restart_file_seq_p := duv$execution_environment.data_file_p^.segment_pointer.sequence_pointer;

      { Retrieve the pointers to the individual areas of the buffer.

      dup$retrieve_dft_pointers (v$data, data_length_valid, data_valid);
      IF NOT data_length_valid THEN
        clp$put_display (v$display_control,
              'WARNING - Possible Memory Corruption in the DFT Structure on the DFT Dump Record.',
              clc$trim, ignore_status);
      IFEND;
      IF (v$data.revision_level < 4) OR (NOT data_valid) THEN
        STRINGREP (display_string, string_length, ' **ERROR** - Unsupported version.');
        clp$put_display (v$display_control, display_string (1, string_length), clc$trim, ignore_status);
        EXIT /display_opened/;  {---->
      IFEND;

      FOR word_index := 0 TO duc$dft_max_known_pointer_words DO
        display_data [word_index] := FALSE;
      FOREND;

      v$display_capture_buffer := pvt [p$display_mdb_capture_buffer].value^.boolean_value.value;
      display_all_data := (pvt [p$display_option].value^.kind = clc$keyword);
      IF NOT display_all_data THEN
        list_p := pvt [p$display_option].value;
        WHILE list_p <> NIL DO
          option_p := list_p^.element_value;
          list_p := list_p^.link;
          IF option_p^.keyword_value = 'DFT_CONTROL_WORD' THEN
            display_data [duc$dft_cw] := TRUE;
          ELSEIF option_p^.keyword_value = 'SECDED_ID_TABLE' THEN
            display_data [dsc$dftb_rpw_secded_id] := TRUE;
          ELSEIF option_p^.keyword_value = 'MRB_SSB_MDB' THEN
            display_data [dsc$dftb_rpw_mrb] := TRUE;
            display_data [dsc$dftb_rpw_mdb] := TRUE;
            display_data [dsc$dftb_rpw_mrb_cw] := TRUE;
            display_data [dsc$dftb_rpw_ssb] := TRUE;
          ELSEIF option_p^.keyword_value = 'NOSVE_BUFFER' THEN
            display_data [dsc$dftb_rpw_nosve_buffer] := TRUE;
          ELSEIF option_p^.keyword_value = 'C170_PP_RESIDENT' THEN
            display_data [dsc$dftb_rpw_c170_pp_resident] := TRUE;
          ELSEIF option_p^.keyword_value = 'C170_OS_BUFFER' THEN
            display_data [dsc$dftb_rpw_c170_os_buffer] := TRUE;
          ELSEIF option_p^.keyword_value = 'MEC' THEN
            display_data [dsc$dftb_rpw_mec] := TRUE;
          ELSEIF option_p^.keyword_value = 'DFT_ERROR_CONTROL' THEN
            display_data [dsc$dftb_rpw_dft_control_info] := TRUE;
          ELSEIF option_p^.keyword_value = 'NRSB' THEN
            display_data [dsc$dftb_rpw_nrb] := TRUE;
          ELSEIF option_p^.keyword_value = 'DFT_CM_RESIDENT' THEN
            display_data [dsc$dftb_rpw_dft_cm_resident] := TRUE;
          ELSEIF option_p^.keyword_value = 'PP_REGISTER_SAVE_AREA' THEN
            display_data [dsc$dftb_rpw_pp_reg_save_area] := TRUE;
          ELSEIF option_p^.keyword_value = 'SECONDARY_DFT_BUFFER' THEN
            display_data [dsc$dftb_rpw_dft_secondary] := TRUE;
          ELSE
          IFEND;
        WHILEND;
      IFEND;

      FOR word_index := 0 TO duc$dft_max_known_pointer_words DO
        display_data [word_index] := (display_all_data OR display_data [word_index]) AND
              (v$data.buffer [word_index].cell_p <> NIL);
      FOREND;

      IF pvt [p$display_type].value^.keyword_value = 'DETAILED' THEN
        display_memory_size;
        IF display_data [duc$dft_cw] THEN
          display_dft_control_word (FALSE);
        IFEND;
        IF display_data [dsc$dftb_rpw_mrb] AND display_data [dsc$dftb_rpw_mrb_cw] AND
              display_data [dsc$dftb_rpw_ssb] THEN
          display_mrb_data;
        IFEND;
        IF display_data [dsc$dftb_rpw_nrb] THEN
          display_nrb_data;
        IFEND;
        IF display_data [dsc$dftb_rpw_secded_id] THEN
          display_secded_id_data (TRUE);
        IFEND;
        IF display_data [dsc$dftb_rpw_mec] THEN
          display_mec_data (TRUE);
        IFEND;
        IF display_data [dsc$dftb_rpw_dft_control_info] THEN
          display_dec_data;
        IFEND;
        IF display_data [dsc$dftb_rpw_pp_reg_save_area] THEN
          display_pp_reg_save_area_data;
        IFEND;
        IF display_data [dsc$dftb_rpw_nosve_buffer] THEN
          display_os_buffer_data (TRUE);
        IFEND;
        IF display_data [dsc$dftb_rpw_c170_pp_resident] THEN
          display_header (TRUE, ' C170 PP RESIDENT BUFFER:');
          RESET v$restart_file_seq_p TO v$data.buffer [dsc$dftb_rpw_c170_pp_resident].cell_p;
          print_raw_data (v$data.buffer [dsc$dftb_rpw_c170_pp_resident].size);
          display_trailer;
        IFEND;
        IF display_data [dsc$dftb_rpw_c170_os_buffer] THEN
          display_os_buffer_data (FALSE);
        IFEND;
        IF display_data [dsc$dftb_rpw_dft_cm_resident] THEN
          display_header (TRUE, ' DFT CENTRAL MEMORY RESIDENT:');
          RESET v$restart_file_seq_p TO v$data.buffer [dsc$dftb_rpw_dft_cm_resident].cell_p;
          print_raw_data (v$data.buffer [dsc$dftb_rpw_dft_cm_resident].size);
          display_trailer;
        IFEND;
        IF display_data [dsc$dftb_rpw_dft_secondary] THEN
          display_secondary_dft_data;
        IFEND;

      ELSE

      /display_raw_data/
        FOR word_index := 0 TO duc$dft_max_known_pointer_words DO
          IF NOT display_data [word_index] THEN
            CYCLE /display_raw_data/;  {---->
          IFEND;
          display_header (FALSE, titles [word_index]);
          RESET v$restart_file_seq_p TO v$data.buffer [word_index].cell_p;
          print_raw_data (v$data.buffer [word_index].size);

          IF word_index = duc$dft_cw THEN
            display_header (FALSE, titles_pointer_word);
            RESET v$restart_file_seq_p TO v$data.buffer [duc$dft_cw].cell_p;
            NEXT dft_cw_p IN v$restart_file_seq_p;
            IF dft_cw_p = NIL THEN
              clp$put_display (v$display_control, v$nil_error, clc$trim, ignore_status);
              EXIT /display_opened/;  {---->
            IFEND;
            print_raw_data (v$data.actual_number_of_pointer_words);
          IFEND;

          IF word_index = dsc$dftb_rpw_mdb THEN
            FOR index := 1 TO duc$dft_max_mdb_buffers DO
              IF v$data.mdb [index].cell_p <> NIL THEN
                clp$put_display (v$display_control, v$dash, clc$trim, ignore_status);
                RESET v$restart_file_seq_p TO v$data.mdb [index].cell_p;
                print_raw_data (v$data.mdb [index].size);
              IFEND;
            FOREND;
          IFEND;
        FOREND;

      IFEND;

    END /display_opened/;

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

  PROCEND dup$process_dft_buffer_command;
MODEND dum$process_dft_buffer_command;
