?? RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE Dump Analyzer : Display Maintenance Registers Command' ??
MODULE dum$display_maintenance_reg;

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

?? NEWTITLE := 'Global Declarations Referenced by This Module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc due$exception_condition_codes
*copyc dut$condition_registers
*copyc dut$registers_definition
?? POP ??
*copyc clp$close_display
*copyc clp$convert_integer_to_rjstring
*copyc clp$horizontal_tab_display
*copyc clp$new_display_line
*copyc clp$open_display_reference
*copyc clp$put_partial_display
*copyc dup$display_message
*copyc dup$evaluate_parameters
*copyc dup$is_cpu1_installed
*copyc dup$new_page_procedure
*copyc dup$retrieve_register
*copyc ocp$find_debug_address
*copyc osp$append_status_integer
*copyc osp$append_status_parameter
*copyc osp$disestablish_cond_handler
*copyc osp$establish_block_exit_hndlr
*copyc osp$set_status_abnormal
?? EJECT ??
*copyc duv$dump_environment_p
*copyc duv$execution_environment
*copyc duv$title_data
?? OLDTITLE ??
?? NEWTITLE := 'Global Declarations Declared by This Module', EJECT ??

{ Define the PDT for the display_maintenance_registers command

{ PROCEDURE display_maintenance_registers, display_maintenance_register, dismr (
{   element, e: key
{       (processor p) (input_output_unit iou) (memory m) (all a)
{     keyend = all
{   processor, p: any of
{       key
{         (all a)
{       keyend
{       integer 0..3
{     anyend = all
{   title, t: string 1..31 = 'display_maintenance_registers'
{   output, o: file = $optional
{   iou, i: any of
{       key
{         (all a)
{       keyend
{       integer 0..1
{     anyend = all
{   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$keyword_type_qualifier,
        keyword_specs: array [1 .. 8] of clt$keyword_specification,
        default_value: string (3),
      recend,
      type2: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 2] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$integer_type_qualifier,
        recend,
        default_value: string (3),
      recend,
      type3: record
        header: clt$type_specification_header,
        qualifier: clt$string_type_qualifier,
        default_value: string (31),
      recend,
      type4: record
        header: clt$type_specification_header,
      recend,
      type5: 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 .. 2] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$integer_type_qualifier,
        recend,
        default_value: string (3),
      recend,
      type6: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [90, 4, 16, 9, 45, 42, 449],
    clc$command, 11, 6, 0, 0, 0, 0, 6, ''], [
    ['E                              ',clc$abbreviation_entry, 1],
    ['ELEMENT                        ',clc$nominal_entry, 1],
    ['I                              ',clc$abbreviation_entry, 5],
    ['IOU                            ',clc$nominal_entry, 5],
    ['O                              ',clc$abbreviation_entry, 4],
    ['OUTPUT                         ',clc$nominal_entry, 4],
    ['P                              ',clc$abbreviation_entry, 2],
    ['PROCESSOR                      ',clc$nominal_entry, 2],
    ['STATUS                         ',clc$nominal_entry, 6],
    ['T                              ',clc$abbreviation_entry, 3],
    ['TITLE                          ',clc$nominal_entry, 3]],
    [
{ 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, 303,
  clc$optional_default_parameter, 0, 3],
{ PARAMETER 2
    [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, 121,
  clc$optional_default_parameter, 0, 3],
{ PARAMETER 3
    [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, 31],
{ PARAMETER 4
    [6, 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
    [4, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 121,
  clc$optional_default_parameter, 0, 3],
{ 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$keyword_type], [8], [
    ['A                              ', clc$abbreviation_entry, clc$normal_usage_entry, 4],
    ['ALL                            ', clc$nominal_entry, clc$normal_usage_entry, 4],
    ['INPUT_OUTPUT_UNIT              ', clc$nominal_entry, clc$normal_usage_entry, 2],
    ['IOU                            ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
    ['M                              ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
    ['MEMORY                         ', clc$nominal_entry, clc$normal_usage_entry, 3],
    ['P                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
    ['PROCESSOR                      ', clc$nominal_entry, clc$normal_usage_entry, 1]]
    ,
    'all'],
{ PARAMETER 2
    [[1, 0, clc$union_type], [[clc$integer_type, clc$keyword_type],
    FALSE, 2],
    81, [[1, 0, clc$keyword_type], [2], [
      ['A                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
      ['ALL                            ', clc$nominal_entry, clc$normal_usage_entry, 1]]
      ],
    20, [[1, 0, clc$integer_type], [0, 3, 10]]
    ,
    'all'],
{ PARAMETER 3
    [[1, 0, clc$string_type], [1, 31, FALSE],
    '''display_maintenance_registers'''],
{ PARAMETER 4
    [[1, 0, clc$file_type]],
{ PARAMETER 5
    [[1, 0, clc$union_type], [[clc$integer_type, clc$keyword_type],
    FALSE, 2],
    81, [[1, 0, clc$keyword_type], [2], [
      ['A                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
      ['ALL                            ', clc$nominal_entry, clc$normal_usage_entry, 1]]
      ],
    20, [[1, 0, clc$integer_type], [0, 1, 10]]
    ,
    'all'],
{ PARAMETER 6
    [[1, 0, clc$status_type]]];
?? FMT (FORMAT := ON) ??
?? POP ??

    CONST
      p$element = 1,
      p$processor = 2,
      p$title = 3,
      p$output = 4,
      p$iou = 5,
      p$status = 6;

    VAR
      pvt: array [1 .. 6] of clt$parameter_value;
?? EJECT ??
  CONST
    c$column_number = 33;

?? EJECT ??

  VAR
    v$display_control: clt$display_control,
    v$line_length: 0 .. duc$de_max_definition_length;

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

{ PURPOSE:
{   This procedure scans a byte of a register and displays the names of any bits set.

  PROCEDURE display_bit_names
    (    starting_register_byte_number: 1 .. duc$de_max_register_length;
         register_value: ARRAY [1 .. duc$de_max_register_length] OF 0 .. 0ff(16);
         register_bit_names: ARRAY [ * ] OF string (duc$de_max_definition_length));

    TYPE
      t$set_or_byte = RECORD
        CASE boolean OF
        = TRUE =
          set_part: SET OF 0 .. 7,
        = FALSE =
          byte_part: 0 .. 0ff(16),
        CASEND,
      RECEND;

    VAR
      bit: 0 .. 7,
      bit_display_length: integer,
      bit_number: integer,
      bit_string: string (9),
      byte_number: 1 .. duc$de_max_register_length,
      byte_set: t$set_or_byte,
      data_after_max_length: boolean,
      ignore_status: ost$status,
      next_position: 0 .. duc$de_max_definition_length,
      position: 0 .. duc$de_max_definition_length,
      string_2: string (2);

    FOR byte_number := starting_register_byte_number TO duc$de_max_register_length DO
      byte_set.byte_part := register_value [byte_number];

     /scan_bits/
      FOR bit := 0 TO 7 DO
        IF NOT (bit IN byte_set.set_part) THEN
          CYCLE /scan_bits/;  {---->
        IFEND;

        bit_number := ((byte_number - 1) * 8) + bit;
        IF (bit_number > UPPERBOUND (register_bit_names)) OR
              (bit_number < LOWERBOUND (register_bit_names)) THEN
          CYCLE /scan_bits/;  {---->
        IFEND;

        { Display the bit number.

        clp$horizontal_tab_display (v$display_control, c$column_number, ignore_status);
        string_2 := 'XX';
        clp$convert_integer_to_rjstring (bit_number, 10, FALSE, '0', string_2, ignore_status);
        STRINGREP (bit_string, bit_display_length, 'bit ', string_2, ' : ');
        clp$put_partial_display (v$display_control, bit_string, clc$no_trim, amc$continue, ignore_status);

        { Determine the maximum length of a line for the output file.

        data_after_max_length := FALSE;

        IF v$line_length = duc$de_max_definition_length THEN
          data_after_max_length := FALSE;
        ELSE

         /scan_bit_name/
          FOR position := (v$line_length + 1) TO STRLENGTH (register_bit_names [bit_number]) DO
            IF register_bit_names [bit_number] (position) <> ' ' THEN
              data_after_max_length := TRUE;
              EXIT /scan_bit_name/;  {---->
            IFEND;
          FOREND /scan_bit_name/;
        IFEND;

        { Display the bit name.

        IF NOT data_after_max_length THEN
          clp$put_partial_display (v$display_control, register_bit_names [bit_number] (1, v$line_length),
                clc$trim, amc$terminate, ignore_status);
        ELSE

         /locate_last_blank/
          FOR position := 0 TO (v$line_length - 1) DO
            IF (register_bit_names [bit_number] (v$line_length - position) = ' ') THEN
              EXIT /locate_last_blank/;  {---->
            IFEND;
          FOREND /locate_last_blank/;

          clp$put_partial_display (v$display_control,
                register_bit_names [bit_number] (1, (v$line_length - position)), clc$trim, amc$terminate,
                ignore_status);
          next_position := v$line_length - position + 1;
          clp$horizontal_tab_display (v$display_control, (c$column_number + 9), ignore_status);
          clp$put_partial_display (v$display_control, register_bit_names [bit_number] (next_position,
                (STRLENGTH (register_bit_names [bit_number]) - next_position)), clc$trim, amc$terminate,
                ignore_status);
        IFEND;
      FOREND /scan_bits/;
    FOREND;

  PROCEND display_bit_names;
?? OLDTITLE ??
?? NEWTITLE := 'display_eid_information', EJECT ??

{ PURPOSE:
{   This procedure displays the element number, the model number and the serial number from the EID register.

  PROCEDURE display_eid_information
    (    register_value: ARRAY [1 .. duc$de_max_register_length] OF 0 .. 0ff(16));

    VAR
      element_string: string (11),
      ignore_status: ost$status,
      serial_number_string: string (4),
      string_2: string (2);

    { Display the element number.

    CASE register_value [duc$de_element_byte_number] OF
    = 00 =
      element_string := 'PROCESSOR  ';
    = 01 =
      element_string := 'MEMORY     ';
    = 02 =
      element_string := 'IOU        ';
    = 03 =
      element_string := 'ECS COUPLER';
    = 04 =
      element_string := '    PEM    ';
    ELSE
      element_string := ' UNDEFINED ';
    CASEND;
    clp$horizontal_tab_display (v$display_control, c$column_number, ignore_status);
    clp$put_partial_display (v$display_control, 'element: ', clc$no_trim, amc$continue, ignore_status);
    clp$put_partial_display (v$display_control, element_string, clc$trim, amc$terminate, ignore_status);

    { Display the model number.

    clp$horizontal_tab_display (v$display_control, c$column_number, ignore_status);
    string_2 := 'XX';
    clp$convert_integer_to_rjstring (register_value [duc$de_model_byte_number], 16, FALSE, '0', string_2,
          ignore_status);
    clp$put_partial_display (v$display_control, 'model  : ', clc$no_trim, amc$continue, ignore_status);
    clp$put_partial_display (v$display_control, string_2, clc$trim, amc$terminate, ignore_status);

    { Display the serial number.

    clp$horizontal_tab_display (v$display_control, c$column_number, ignore_status);
    serial_number_string := 'XXXX';
    clp$convert_integer_to_rjstring (register_value [duc$de_serial_num_byte_number], 16, FALSE, '0',
          serial_number_string (1, 2), ignore_status);
    clp$convert_integer_to_rjstring (register_value [duc$de_serial_num_byte_number + 1], 16, FALSE, '0',
          serial_number_string (3, 2), ignore_status);
    clp$put_partial_display (v$display_control, 's / n  : ', clc$no_trim, amc$continue, ignore_status);
    clp$put_partial_display (v$display_control, serial_number_string, clc$trim, amc$terminate, ignore_status);

  PROCEND display_eid_information;
?? OLDTITLE ??
?? NEWTITLE := 'display_iou_registers', EJECT ??

{ PURPOSE:
{   This procedure displays the iou registers.

  PROCEDURE display_iou_registers
    (VAR status: ost$status);

    VAR
      ending_iou: 0 .. duc$de_maximum_ious,
      ignore_status: ost$status,
      iou: 0 .. duc$de_maximum_ious,
      iou_displayed: boolean,
      model_number: 0 .. 0ff(16),
      register: dut$de_maintenance_register,
      register_index: 1 .. duc$de_number_of_pro_mrs_dumped,
      starting_iou: 0 .. duc$de_maximum_ious,
      string_2: string (2);

    status.normal := TRUE;
    iou_displayed := FALSE;

    { Determine the starting and ending iou numbers to display.

    IF pvt [p$iou].value^.kind = clc$integer THEN
      starting_iou := pvt [p$iou].value^.integer_value.value;
      ending_iou := starting_iou;
    ELSE
      starting_iou := 0;
      ending_iou := duc$de_maximum_ious;
    IFEND;

   /display_iou/
    FOR iou := starting_iou TO ending_iou DO
      IF NOT duv$dump_environment_p^.iou_maintenance_registers [iou].available THEN
        IF (iou = ending_iou) AND NOT iou_displayed THEN
          IF starting_iou = ending_iou THEN
            osp$set_status_abnormal (duc$dump_analyzer_id, due$data_not_on_dump,
                  'The maintenance registers for iou', status);
            osp$append_status_integer (osc$status_parameter_delimiter, iou, 10, FALSE, status);
            osp$append_status_parameter (osc$status_parameter_delimiter, 'are', status);
          ELSE
            osp$set_status_abnormal (duc$dump_analyzer_id, due$data_not_on_dump,
                  'The maintenance registers for the iou are', status);
          IFEND;
          RETURN;  {---->
        IFEND;
        CYCLE /display_iou/;  {---->
      IFEND;
      iou_displayed := TRUE;

      { Display the iou number.

      v$display_control.line_number := v$display_control.page_length + 1;
      clp$new_display_line (v$display_control, 1, ignore_status);
      clp$put_partial_display (v$display_control, '  INPUT/OUTPUT UNIT', clc$no_trim, amc$continue,
            ignore_status);
      string_2 := 'XX';
      clp$convert_integer_to_rjstring (iou, 16, FALSE, '0', string_2, ignore_status);
      clp$put_partial_display (v$display_control, string_2, clc$no_trim, amc$terminate, ignore_status);
      clp$new_display_line (v$display_control, 1, ignore_status);

      { Retrieve the model number.

      model_number := 0;

      dup$retrieve_register (duc$de_iou, iou, 10(16), register);
      IF register.available THEN
        model_number := register.value [duc$de_model_byte_number];
      IFEND;

     /display_register/
      FOR register_index := 1 TO duc$de_number_of_iou_mrs_dumped DO
        register := duv$dump_environment_p^.iou_maintenance_registers [iou].registers [register_index];
        IF NOT register.available THEN
          CYCLE /display_register/;  {---->
        IFEND;

        { Display the register number.

        string_2 := 'XX';
        clp$convert_integer_to_rjstring (register.number, 16, FALSE, '0', string_2, ignore_status);
        clp$put_partial_display (v$display_control, string_2, clc$trim, amc$continue, ignore_status);
        clp$put_partial_display (v$display_control, '  ', clc$no_trim, amc$continue, ignore_status);

        { Display the register in groups of sixteen bits.

        display_register_groups (register.value);

        { Display the register name.

        IF (model_number < 50(16)) OR (model_number > 5F(16)) THEN
          clp$put_partial_display (v$display_control, duv$rd_general_iou_reg_def [register.number], clc$trim,
                amc$terminate, ignore_status);
        ELSE
          clp$put_partial_display (v$display_control, duv$rd_93x_iou_reg_def [register.number], clc$trim,
                amc$terminate, ignore_status);
        IFEND;

        { Display information about certain bits set in the registers.

        CASE register.number OF
        = 0 =
          IF model_number < 40(16) THEN
            display_bit_names (1, register.value, duv$rd_i0_i1_i2_iou_ss_def);
          ELSE
            display_bit_names (1, register.value, duv$rd_general_iou_ss_def);
          IFEND;

        = 10(16) =
          display_eid_information (register.value);

        ELSE
        CASEND;
      FOREND /display_register/;
    FOREND /display_iou/;

  PROCEND display_iou_registers;
?? OLDTITLE ??
?? NEWTITLE := 'display_memory_registers', EJECT ??

{ PURPOSE:
{   This procedure displays the memory registers.

  PROCEDURE display_memory_registers
    (VAR status: ost$status);

    VAR
      ignore_status: ost$status,
      model_number: 0 .. 0ff(16),
      register: dut$de_maintenance_register,
      register_index: 1 .. duc$de_number_of_pro_mrs_dumped,
      string_2: string (2);

    status.normal := TRUE;

    IF NOT duv$dump_environment_p^.mem_maintenance_registers.available THEN
      osp$set_status_abnormal (duc$dump_analyzer_id, due$data_not_on_dump,
            'The memory maintenance registers are', status);
      RETURN;  {---->
    IFEND;

    v$display_control.line_number := v$display_control.page_length + 1;
    clp$new_display_line (v$display_control, 1, ignore_status);
    clp$put_partial_display (v$display_control, '  MEMORY', clc$no_trim, amc$terminate, ignore_status);
    clp$new_display_line (v$display_control, 1, ignore_status);

    { Retrieve the model number.

    model_number := 0;

    dup$retrieve_register (duc$de_memory, 0, 10(16), register);
    IF register.available THEN
      model_number := register.value [duc$de_model_byte_number];
    IFEND;

   /display_register/
    FOR register_index := 1 TO duc$de_number_of_mem_mrs_dumped DO
      register := duv$dump_environment_p^.mem_maintenance_registers.registers [register_index];
      IF NOT register.available THEN
        CYCLE /display_register/;  {---->
      IFEND;

      { Display the register number.

      string_2 := 'XX';
      clp$convert_integer_to_rjstring (register.number, 16, FALSE, '0', string_2, ignore_status);
      clp$put_partial_display (v$display_control, string_2, clc$trim, amc$continue, status);
      clp$put_partial_display (v$display_control, '  ', clc$no_trim, amc$continue, status);

      { Display the register in groups of sixteen bits.

      display_register_groups (register.value);

      { Display the register name.

      IF (model_number >= 50(16)) AND (model_number <= 5F(16)) THEN
        clp$put_partial_display (v$display_control, duv$rd_93x_mem_reg_def [register.number], clc$trim,
              amc$terminate, ignore_status);
      ELSEIF (model_number = 46(16)) OR (model_number = 48(16)) THEN
        clp$put_partial_display (v$display_control, duv$rd_cy2000_mem_reg_def [register.number],
              clc$trim, amc$terminate, ignore_status);
      ELSE
        clp$put_partial_display (v$display_control, duv$rd_general_mem_reg_def [register.number],
              clc$trim, amc$terminate, ignore_status);
      IFEND;

      { Display information about certain bits set in the registers.

      CASE register.number OF
      = 0 =
        IF model_number = 34(16) THEN
          display_bit_names (1, register.value, duv$rd_model_34_mem_ss_def);
        ELSEIF (model_number >= 50(16)) AND (model_number <= 5F(16)) THEN
          display_bit_names (1, register.value, duv$rd_93x_mem_ss_def);
        ELSEIF (model_number = 46(16)) OR (model_number = 48(16)) THEN
          display_bit_names (1, register.value, duv$rd_cy2000_mem_ss_def);
        ELSE
          display_bit_names (1, register.value, duv$rd_general_mem_ss_def);
        IFEND;

      = 10(16) =
        display_eid_information (register.value);

      ELSE
      CASEND;
    FOREND;

  PROCEND display_memory_registers;
?? OLDTITLE ??
?? NEWTITLE := 'display_processor_registers', EJECT ??

{ PURPOSE:
{   This procedure displays the processor registers.

  PROCEDURE display_processor_registers
    (VAR status: ost$status);

    TYPE
      t$pva_or_array = RECORD
        CASE boolean OF
        = TRUE =
          array_part: ARRAY [1 .. 6] OF 0 .. 0ff(16),
        = FALSE =
          pva_part: ost$pva,
        CASEND,
      RECEND;

    VAR
      byte_number: 1 .. duc$de_max_register_length,
      display_string: string (osc$max_string_size),
      ending_processor: 0 .. duc$de_maximum_processors,
      found: boolean,
      ignore_status: ost$status,
      local_status: ost$status,
      model_number: 0 .. 0ff(16),
      module_name: pmt$program_name,
      offset: ost$segment_offset,
      offset_in_section: ost$segment_offset,
      processor: 0 .. duc$de_maximum_processors,
      processor_displayed: boolean,
      pva_or_array: t$pva_or_array,
      reg_00_second_def: boolean,
      reg_31_second_def: boolean,
      register: dut$de_maintenance_register,
      register_index: 1 .. duc$de_number_of_pro_mrs_dumped,
      register_name_string: string (duc$de_max_definition_length),
      section_name: pmt$program_name,
      segment: ost$segment,
      starting_byte_number: 1 .. duc$de_max_register_length,
      starting_processor: 0 .. duc$de_maximum_processors,
      string_2: string (2),
      string_length: integer;

    status.normal := TRUE;
    processor_displayed := FALSE;

    { Determine the starting and ending processor numbers to display.

    IF pvt [p$processor].value^.kind = clc$integer THEN
      starting_processor := pvt [p$processor].value^.integer_value.value;
      ending_processor := starting_processor;
    ELSE
      starting_processor := 0;
      ending_processor := duc$de_maximum_processors;
    IFEND;

   /display_processor/
    FOR processor := starting_processor TO ending_processor DO
      reg_00_second_def := FALSE;
      reg_31_second_def := FALSE;
      IF NOT duv$dump_environment_p^.pro_maintenance_registers [processor].available THEN
        dup$is_cpu1_installed (duc$ee_cic_dismr, processor, v$display_control);
        IF (processor = ending_processor) AND NOT processor_displayed THEN
          IF starting_processor = ending_processor THEN
            osp$set_status_abnormal (duc$dump_analyzer_id, due$data_not_on_dump,
                  'The maintenance registers for processor', status);
            osp$append_status_integer (osc$status_parameter_delimiter, processor, 10, FALSE, status);
            osp$append_status_parameter (osc$status_parameter_delimiter, 'are', status);
          ELSE
            osp$set_status_abnormal (duc$dump_analyzer_id, due$data_not_on_dump,
                  'The maintenance registers for the processor are', status);
          IFEND;
          RETURN;  {---->
        IFEND;
        CYCLE /display_processor/;  {---->
      IFEND;
      processor_displayed := TRUE;

      { Display the processor number.

      v$display_control.line_number := v$display_control.page_length + 1;
      clp$new_display_line (v$display_control, 1, ignore_status);
      clp$put_partial_display (v$display_control, '  PROCESSOR   ', clc$no_trim, amc$continue, ignore_status);
      string_2 := 'XX';
      clp$convert_integer_to_rjstring (processor, 16, FALSE, '0', string_2, ignore_status);
      clp$put_partial_display (v$display_control, string_2, clc$no_trim, amc$terminate, ignore_status);
      clp$new_display_line (v$display_control, 1, ignore_status);

      { Retrieve the model number.

      model_number := 0;

      dup$retrieve_register (duc$de_cpu, processor, 10(16), register);
      IF register.available THEN
        model_number := register.value [duc$de_model_byte_number];
      IFEND;

     /display_register/
      FOR register_index := 1 TO duc$de_number_of_pro_mrs_dumped DO
        register := duv$dump_environment_p^.pro_maintenance_registers [processor].registers [register_index];
        IF NOT register.available THEN
          CYCLE /display_register/;  {---->
        IFEND;

        { Display the register number.

        string_2 := 'XX';
        clp$convert_integer_to_rjstring (register.number, 16, FALSE, '0', string_2, ignore_status);
        clp$put_partial_display (v$display_control, string_2, clc$trim, amc$continue, ignore_status);
        clp$put_partial_display (v$display_control, '  ', clc$no_trim, amc$continue, ignore_status);

        { Display the register in groups of sixteen bits.

        display_register_groups (register.value);

        { Display the register name.

        IF register.number = 00(16) THEN
          IF NOT reg_00_second_def THEN
            register_name_string := 'status summary before CPU halt';
            reg_00_second_def := TRUE;
          ELSE
            register_name_string := 'status summary after CPU halt';
            reg_00_second_def := FALSE;
          IFEND;
          IF (model_number <= 50(16)) OR (model_number >= 5F(16)) THEN
            duv$rd_general_pro_reg_def [register.number] := register_name_string;
          ELSEIF ((model_number >= 50(16)) AND (model_number <= 53(16))) OR
                (model_number = 5B(16)) OR (model_number = 5D(16)) OR (model_number = 5E(16)) THEN
            duv$rd_930_pro_reg_def [register.number] := register_name_string;
          ELSE
            duv$rd_932_pro_reg_def [register.number] := register_name_string;
          IFEND;
        ELSEIF register.number = 31(16) THEN
          IF NOT reg_31_second_def THEN
            register_name_string := 'csa addr before halt';
            reg_31_second_def := TRUE;
          ELSE
            register_name_string := 'csa addr after halt';
            reg_31_second_def := FALSE;
          IFEND;
          IF (model_number <= 50(16)) OR (model_number >= 5F(16)) THEN
            duv$rd_general_pro_reg_def [register.number] := register_name_string;
          ELSEIF ((model_number >= 50(16)) AND (model_number <= 53(16))) OR
                (model_number = 5B(16)) OR (model_number = 5D(16)) OR (model_number = 5E(16)) THEN
            duv$rd_930_pro_reg_def [register.number] := register_name_string;
          ELSE
            duv$rd_932_pro_reg_def [register.number] := register_name_string;
          IFEND;
        IFEND;

        IF ((model_number >= 54(16)) AND (model_number <= 55(16))) OR (model_number = 5F(16)) OR
              (model_number = 5C(16)) THEN
          clp$put_partial_display (v$display_control, duv$rd_932_pro_reg_def [register.number], clc$trim,
                amc$terminate, ignore_status);
        ELSEIF (model_number >= 50(16)) AND (model_number <= 5E(16)) THEN
          clp$put_partial_display (v$display_control, duv$rd_930_pro_reg_def [register.number], clc$trim,
                amc$terminate, ignore_status);
        ELSE
          clp$put_partial_display (v$display_control, duv$rd_general_pro_reg_def [register.number], clc$trim,
                amc$terminate, ignore_status);
        IFEND;

        { Display information about certain bits set in the registers.

        CASE register.number OF
        = 0 =
          IF (model_number = 46(16)) OR (model_number = 48(16)) THEN
            starting_byte_number := (duc$rd_cy2000_ss_lower_bit DIV 8) + 1;
            display_bit_names (starting_byte_number, register.value, duv$rd_cy2000_pro_ss_def);
          ELSE
            starting_byte_number := (duc$rd_ss_lower_bit DIV 8) + 1;
            display_bit_names (starting_byte_number, register.value, duv$rd_general_pro_ss_def);
          IFEND;

        = 10(16) =
          display_eid_information (register.value);

        = 40(16) =
          FOR byte_number := 3 TO 8 DO
            pva_or_array.array_part [byte_number - 2] := register.value [byte_number];
          FOREND;
          offset := pva_or_array.pva_part.offset;
          segment := pva_or_array.pva_part.seg;
          ocp$find_debug_address (segment, offset, found, module_name, section_name, offset_in_section,
                local_status);
          IF local_status.normal AND found THEN
            STRINGREP (display_string, string_length, 'module : ', module_name);
            clp$horizontal_tab_display (v$display_control, c$column_number, ignore_status);
            clp$put_partial_display (v$display_control, display_string (1, string_length), clc$trim,
                  amc$terminate, ignore_status);
            STRINGREP (display_string, string_length, 'procedure : ', section_name);
            clp$horizontal_tab_display (v$display_control, c$column_number, ignore_status);
            clp$put_partial_display (v$display_control, display_string (1, string_length), clc$trim,
                  amc$terminate, ignore_status);
            STRINGREP (display_string, string_length, 'offset : ', offset_in_section: #(16));
            clp$horizontal_tab_display (v$display_control, c$column_number, ignore_status);
            clp$put_partial_display (v$display_control, display_string (1, string_length), clc$trim,
                  amc$terminate, ignore_status);
          IFEND;

        = 42(16) =
          starting_byte_number := (duc$cr_mtr_condition_lower_bit DIV 8) + 1;
          display_bit_names (starting_byte_number, register.value, duv$cr_mtr_condition_reg_def);

        = 43(16) =
          starting_byte_number := (duc$cr_user_condition_lower_bit DIV 8) + 1;
          display_bit_names (starting_byte_number, register.value, duv$cr_user_condition_reg_def);

        = 80(16) =
          CASE model_number OF
          = 11(16), 12(16), 13(16), 14(16) =
            display_bit_names (1, register.value, duv$rd_pro_810_830_pfs_0);
          = 20(16) =
            display_bit_names (1, register.value, duv$rd_pro_835_pfs_0);
          = 30(16), 31(16), 32(16), 33(16) =
            display_bit_names (1, register.value, duv$rd_pro_845_860_pfs_0);
          = 40(16), 41(16), 42(16), 44(16) =
            display_bit_names (1, register.value, duv$rd_pro_990_pfs_0);
          ELSE
          CASEND;

        = 81(16) =
          CASE model_number OF
          = 13(16), 14(16) =
            display_bit_names (1, register.value, duv$rd_pro_810_830_pfs_1);
          = 20(16) =
            display_bit_names (1, register.value, duv$rd_pro_835_pfs_1);
          = 30(16), 31(16), 32(16), 33(16) =
            display_bit_names (1, register.value, duv$rd_pro_845_860_pfs_1);
          = 40(16), 41(16), 42(16), 44(16) =
            display_bit_names (1, register.value, duv$rd_pro_990_pfs_1);
          ELSE
          CASEND;

        = 82(16) =
          CASE model_number OF
          = 30(16), 31(16), 32(16), 33(16) =
            display_bit_names (1, register.value, duv$rd_pro_845_860_pfs_2);
          = 40(16), 41(16), 42(16), 44(16) =
            display_bit_names (1, register.value, duv$rd_pro_990_pfs_2);
          ELSE
          CASEND;

        = 83(16) =
          CASE model_number OF
          = 30(16), 31(16), 32(16), 33(16) =
            display_bit_names (1, register.value, duv$rd_pro_845_860_pfs_3);
          = 40(16), 41(16), 42(16), 44(16) =
            display_bit_names (1, register.value, duv$rd_pro_990_pfs_3);
          ELSE
          CASEND;

        = 84(16) =
          CASE model_number OF
          = 30(16), 31(16), 32(16), 33(16) =
            display_bit_names (1, register.value, duv$rd_pro_845_860_pfs_4);
          = 40(16), 41(16), 42(16), 44(16) =
            display_bit_names (1, register.value, duv$rd_pro_990_pfs_4);
          ELSE
          CASEND;

        = 85(16) =
          CASE model_number OF
          = 30(16), 31(16), 32(16), 33(16) =
            display_bit_names (1, register.value, duv$rd_pro_845_860_pfs_5);
          = 40(16), 41(16), 42(16), 44(16) =
            display_bit_names (1, register.value, duv$rd_pro_990_pfs_5);
          ELSE
          CASEND;

        = 86(16) =
          CASE model_number OF
          = 30(16), 31(16), 32(16), 33(16) =
            display_bit_names (1, register.value, duv$rd_pro_845_860_pfs_6);
          = 40(16), 41(16), 42(16), 44(16) =
            display_bit_names (1, register.value, duv$rd_pro_990_pfs_6);
          ELSE
          CASEND;

        = 87(16) =
          CASE model_number OF
          = 30(16), 31(16), 32(16), 33(16) =
            display_bit_names (1, register.value, duv$rd_pro_845_860_pfs_7);
          = 40(16), 41(16), 42(16), 44(16) =
            display_bit_names (1, register.value, duv$rd_pro_990_pfs_7);
          ELSE
          CASEND;

        = 88(16) =
          CASE model_number OF
          = 30(16), 31(16), 32(16), 33(16) =
            display_bit_names (1, register.value, duv$rd_pro_845_860_pfs_8);
          = 40(16), 41(16), 42(16), 44(16) =
            display_bit_names (1, register.value, duv$rd_pro_990_pfs_8);
          ELSE
          CASEND;

        = 89(16) =
          CASE model_number OF
          = 30(16), 31(16), 32(16), 33(16) =
            display_bit_names (1, register.value, duv$rd_pro_845_860_pfs_9);
          = 40(16), 41(16), 42(16), 44(16) =
            display_bit_names (1, register.value, duv$rd_pro_990_pfs_9);
          ELSE
          CASEND;

        = 8a(16) =
          CASE model_number OF
          = 40(16), 41(16), 42(16), 44(16) =
            display_bit_names (1, register.value, duv$rd_pro_990_pfs_a);
          ELSE
          CASEND;

        = 8b(16) =
          CASE model_number OF
          = 40(16), 41(16), 42(16), 44(16) =
            display_bit_names (1, register.value, duv$rd_pro_990_pfs_b);
          ELSE
          CASEND;

        = 8c(16) =
          CASE model_number OF
          = 40(16), 41(16), 42(16), 44(16) =
            display_bit_names (1, register.value, duv$rd_pro_990_pfs_c);
          ELSE
          CASEND;

        = 8d(16) =
          CASE model_number OF
          = 40(16), 41(16), 42(16), 44(16) =
            display_bit_names (1, register.value, duv$rd_pro_990_pfs_d);
          ELSE
          CASEND;

        = 8e(16) =
          CASE model_number OF
          = 40(16), 41(16), 42(16), 44(16) =
            display_bit_names (1, register.value, duv$rd_pro_990_pfs_e);
          ELSE
          CASEND;

        = 8f(16) =
          CASE model_number OF
          = 40(16), 41(16), 42(16), 44(16) =
            display_bit_names (1, register.value, duv$rd_pro_990_pfs_f);
          ELSE
          CASEND;

        ELSE
        CASEND;
      FOREND /display_register/;
    FOREND /display_processor/;

  PROCEND display_processor_registers;
?? OLDTITLE ??
?? NEWTITLE := 'display_register_groups', EJECT ??

{ PURPOSE:
{   This procedure displays the register in groups of sixteen bits.

  PROCEDURE display_register_groups
    (    register_value: ARRAY [1 .. duc$de_max_register_length] OF 0 .. 0ff(16));

    TYPE
      t$array_or_string = RECORD
        CASE boolean OF
        = TRUE =
          array_part: ARRAY [1 .. (duc$de_max_register_length DIV 2)] OF t$display_group,
        = FALSE =
          string_part: string (20),
        CASEND,
      RECEND,

      t$display_group = RECORD
        first_half: string (2),
        second_half: string (2),
        blank_space: string (1),
      RECEND;

    VAR
      array_or_string: t$array_or_string,
      byte_number: 0 .. duc$de_max_register_length,
      group_index: 1 .. duc$de_max_register_length,
      ignore_status: ost$status;

    byte_number := 0;
    FOR group_index := 1 TO (duc$de_max_register_length DIV 2) DO
      byte_number := byte_number + 1;
      array_or_string.array_part [group_index].first_half := 'XX';
      clp$convert_integer_to_rjstring (register_value [byte_number], 16, FALSE, '0',
            array_or_string.array_part [group_index].first_half, ignore_status);
      byte_number := byte_number + 1;
      array_or_string.array_part [group_index].second_half := 'XX';
      clp$convert_integer_to_rjstring (register_value [byte_number], 16, FALSE, '0',
            array_or_string.array_part [group_index].second_half, ignore_status);
      array_or_string.array_part [group_index].blank_space := ' ';
    FOREND;
    clp$put_partial_display (v$display_control, array_or_string.string_part, clc$no_trim, amc$continue,
          ignore_status);
    clp$put_partial_display (v$display_control, '      ', clc$no_trim, amc$continue, ignore_status);

  PROCEND display_register_groups;
?? OLDTITLE ??
?? NEWTITLE := 'dup$display_maintenance_reg', EJECT ??

{ PURPOSE:
{   This procedure displays the maintenance register values for the PROCESSOR(s), the MEMORY and the IOU(s).

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

    VAR
      default_list: ARRAY [1 .. 2] OF dut$default_change_list_entry,
      ignore_status: ost$status,
      local_status: ost$status,
      output_display_opened: boolean,
      page_width: amt$page_width,
      ring_attributes: amt$ring_attributes;

*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;

    { Change the default value for the PROCESSOR and IOU parameters.

    default_list [1].default_name := duc$dp_processor;
    default_list [1].number := p$processor;
    default_list [2].default_name := duc$dp_iou;
    default_list [2].number := p$iou;
    dup$evaluate_parameters (parameter_list, default_list, #SEQ (pdt), ^pvt, status);
    IF NOT status.normal THEN
      RETURN;  {---->
    IFEND;

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

    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^;

      { Setup the length of the output line.

      IF v$display_control.page_width > 132 THEN
        page_width := 132;
      ELSEIF v$display_control.page_width < 80 THEN
        page_width := 80;
      ELSE
        page_width := v$display_control.page_width;
      IFEND;
      IF (page_width - c$column_number + 9) > duc$de_max_definition_length THEN
        v$line_length := duc$de_max_definition_length;
      ELSE
        v$line_length := page_width - c$column_number + 9;
      IFEND;

      { Display the processor registers.

      IF (pvt [p$element].value^.keyword_value = 'ALL') OR
            (pvt [p$element].value^.keyword_value = 'PROCESSOR') THEN
        display_processor_registers (local_status);
        IF NOT local_status.normal THEN
          dup$display_message (local_status, v$display_control);
        IFEND;
      IFEND;

      { Display the memory registers.

      IF (pvt [p$element].value^.keyword_value = 'ALL') OR
            (pvt [p$element].value^.keyword_value = 'MEMORY') THEN
        display_memory_registers (local_status);
        IF NOT local_status.normal THEN
          dup$display_message (local_status, v$display_control);
        IFEND;
      IFEND;

      { Display the iou registers.

      IF (pvt [p$element].value^.keyword_value = 'ALL') OR
            (pvt [p$element].value^.keyword_value = 'INPUT_OUTPUT_UNIT') THEN
        display_iou_registers (local_status);
        IF NOT local_status.normal THEN
          dup$display_message (local_status, v$display_control);
        IFEND;
      IFEND;
    END /display_opened/;

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

  PROCEND dup$display_maintenance_reg;
MODEND dum$display_maintenance_reg;
