?? RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE Dump Analyzer : Display MAC Soft Registers Command' ??
MODULE dum$display_mac_soft_registers;

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

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

{ PURPOSE:
{   This procedure displays the information from the S0 record: MSR.

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

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

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

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

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

    TYPE
      t$data_line = RECORD
        CASE boolean OF
        = TRUE =
          line: string(22),
        = FALSE =
          space_1: string (2),
          number: string (2),
          space_2: string (2),
          value: ARRAY [1 .. 8] OF string (2),
        CASEND,
      RECEND,

      t$mac_soft_register = PACKED RECORD
        unused: 0 .. 0fff(16),
        fill: 0 .. 0f(16),
        number: 0 .. 0ff(16),
        value: PACKED ARRAY [1 .. 8] OF t$mac_soft_register_entry,
      RECEND,

      t$mac_soft_register_entry = PACKED RECORD
        fill: 0 .. 0f(16),
        data: 0 .. 0ff(16),
      RECEND,

      t$register_20 = PACKED RECORD
        CASE boolean OF
        = TRUE =
          register: ARRAY [1 .. 8] OF 0 .. 0ff(16),
        = FALSE =
          bits: PACKED ARRAY [0 .. 6] OF boolean,
          leftover: boolean,
          unused_1: 0 .. 0fffffff(16),
          unused_2: 0 .. 0fffffff(16),
        CASEND,
      RECEND,

      t$register_21 = PACKED RECORD
        CASE boolean OF
        = TRUE =
          register: ARRAY [1 .. 8] OF 0 .. 0ff(16),
        = FALSE =
          cti_pp_number: 0 .. 01f(16),
          mode: boolean,
          cti_reload_of_cm: boolean,
          unused_1: 0 .. 01ffffff(16),
          edd_select: boolean,
          edd_esm_dump_select: boolean,
          edd_tape_density: boolean,
          unused_2: 0 .. 3,
          edd_tape_type: 0 .. 7,
          unused_3: 0 .. 7,
          edd_tape_channel: 0 .. 1f(16),
          edd_tape_equipment: 0 .. 0f(16),
          edd_tape_unit: 0 .. 0f(16),
          unused_4: 0 .. 0ff(16),
        CASEND,
      RECEND,

      t$register_22 = PACKED RECORD
        CASE boolean OF
        = TRUE =
          register: ARRAY [1 .. 8] OF 0 .. 0ff(16),
        = FALSE =
          unused_1: 0 .. 0ffffffff(16),
          unused_2: 0 .. 0ffffff(16),
          edd_counter: 0 .. 0ff(16),
        CASEND,
      RECEND,

      t$register_23 = PACKED RECORD
        CASE boolean OF
        = TRUE =
          register: ARRAY [1 .. 8] OF 0 .. 0ff(16),
        = FALSE =
          initialize_cm: boolean,
          unused_1: 0 .. 07fffffff(16),
          unused_2: 0 .. 0ffffffff(16),
        CASEND,
      RECEND;

    VAR
      cell_p: ^cell,
      data_line: t$data_line,
      data_value: clt$data_value,
      display_control: clt$display_control,
      display_string: string (osc$max_string_size),
      entry_p: ^dut$de_other_record_entry,
      ignore_status: ost$status,
      index: 1 .. 8,
      mac_soft_register_p: ^t$mac_soft_register,
      msr_dump_record_size: amt$file_byte_address,
      output_display_opened: boolean,
      register: ARRAY [1 .. 8] OF 0 .. 0ff(16),
      register_20: t$register_20,
      register_21: t$register_21,
      register_22: t$register_22,
      register_23: t$register_23,
      restart_file_seq_p: ^ SEQ ( * ),
      ring_attributes: amt$ring_attributes,
      string_integer: string (6),
      string_length: integer;

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

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

    PROCEDURE [INLINE] clean_up;

      VAR
        ignore_status: ost$status;

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

    PROCEND clean_up;
?? OLDTITLE ??
?? EJECT ??

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

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

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

   /display_opened/
    BEGIN

      { Prepare the output display file.

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

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

      data_value.kind := clc$name;
      data_value.name_value := 'MSR';
      dup$find_record_list_entry (data_value, entry_p);
      IF entry_p = NIL THEN
        clp$put_display (display_control, ' **ERROR** - Cannot find the MSR record on the restart file.',
              clc$trim, ignore_status);
        osp$set_status_abnormal (duc$dump_analyzer_id, due$data_not_on_dump, 'The specified record is',
              status);
        EXIT /display_opened/;  {---->
      IFEND;

      restart_file_seq_p := duv$execution_environment.data_file_p^.segment_pointer.sequence_pointer;
      cell_p := #ADDRESS (#RING (restart_file_seq_p), #SEGMENT (restart_file_seq_p),
            entry_p^.first_byte);
      RESET restart_file_seq_p TO cell_p;
      msr_dump_record_size := entry_p^.size;

      clp$put_display (display_control, '  MAC SOFT REGISTERS', clc$trim, ignore_status);
      clp$put_display (display_control, ' ', clc$trim, ignore_status);

      WHILE msr_dump_record_size > #SIZE (t$mac_soft_register) DO
        data_line.line := ' ';
        NEXT mac_soft_register_p IN restart_file_seq_p;
        IF mac_soft_register_p = NIL THEN
          osp$set_status_abnormal (duc$dump_analyzer_id, due$nil_pointer, '', status);
          EXIT /display_opened/;  {---->
        IFEND;
        msr_dump_record_size := msr_dump_record_size - #SIZE (mac_soft_register_p^);
        clp$convert_integer_to_rjstring (mac_soft_register_p^.number, 16, FALSE, '0', data_line.number,
              ignore_status);
        FOR index := 1 TO 8 DO
          clp$convert_integer_to_rjstring (mac_soft_register_p^.value [index].data, 16, FALSE, '0',
                data_line.value [index], ignore_status);
          register [index] := mac_soft_register_p^.value [index].data;
        FOREND;
        clp$put_display (display_control, data_line.line, clc$trim, ignore_status);
        IF mac_soft_register_p^.number = 20(16) THEN
          register_20.register := register;
          IF register_20.bits [0] THEN
            clp$put_display (display_control,
                  '        BIT  00:     Check-in with the console bit is set.',
                  clc$trim, ignore_status);
          ELSE
            clp$put_display (display_control,
                  '        BIT  00:     Check-in with the console bit is NOT set.',
                  clc$trim, ignore_status);
          IFEND;
          IF register_20.bits [1] THEN
            clp$put_display (display_control,
                  '        BIT  01:     Successful acceptance of a data file from',
                  clc$trim, ignore_status);
            clp$put_display (display_control,
                  '                     console bit is set.', clc$trim, ignore_status);
          ELSE
            clp$put_display (display_control,
                  '        BIT  01:     Successful acceptance of a data file from',
                  clc$trim, ignore_status);
            clp$put_display (display_control,
                  '                     console bit is NOT set.', clc$trim, ignore_status);
          IFEND;
          IF register_20.bits [2] THEN
            clp$put_display (display_control,
                  '        BIT  02:     Unsuccessful acceptance of a data file from',
                  clc$trim, ignore_status);
            clp$put_display (display_control,
                  '                     console bit is set.', clc$trim, ignore_status);
          ELSE
            clp$put_display (display_control,
                  '        BIT  02:     Unsuccessful acceptance of a data file from',
                  clc$trim, ignore_status);
            clp$put_display (display_control,
                  '                     console bit is NOT set.', clc$trim, ignore_status);
          IFEND;
          IF register_20.bits [3] THEN
            clp$put_display (display_control,
                  '        BIT  03:     Successful acceptance and/or execution of an operator',
                  clc$trim, ignore_status);
            clp$put_display (display_control,
                  '                     command bit is set.', clc$trim, ignore_status);
          ELSE
            clp$put_display (display_control,
                  '        BIT  03:     Successful acceptance and/or execution of an operator.',
                  clc$trim, ignore_status);
            clp$put_display (display_control,
                  '                     command bit is NOT set.', clc$trim, ignore_status);
          IFEND;
          IF register_20.bits [4] THEN
            clp$put_display (display_control,
                  '        BIT  04:     Unsuccessful acceptance and/or execution of an operator',
                  clc$trim, ignore_status);
            clp$put_display (display_control,
                  '                     command bit is set.', clc$trim, ignore_status);
          ELSE
            clp$put_display (display_control,
                  '        BIT  04:     Unsuccessful acceptance and/or execution of an operator',
                  clc$trim, ignore_status);
            clp$put_display (display_control,
                  '                     command bit is NOT set.', clc$trim, ignore_status);
          IFEND;
          IF register_20.bits [5] THEN
            clp$put_display (display_control,
                  '        BIT  05:     Error detected during automatic mode bit is set.',
                  clc$trim, ignore_status);
          ELSE
            clp$put_display (display_control,
                  '        BIT  05:     Error detected during automatic mode bit is NOT set.',
                  clc$trim, ignore_status);
          IFEND;
          IF register_20.bits [6] THEN
            clp$put_display (display_control, '        BIT  06:     Enable 721 emulation bit is set.',
                  clc$trim, ignore_status);
          ELSE
            clp$put_display (display_control, '        BIT  06:     Enable 721 emulation bit is NOT set.',
                  clc$trim, ignore_status);
          IFEND;
        ELSEIF mac_soft_register_p^.number = 21(16) THEN
          register_21.register := register;
          clp$convert_integer_to_rjstring (register_21.cti_pp_number, 16, TRUE, '0',
                string_integer (1, 6), ignore_status);
          STRINGREP (display_string, string_length, '        BITS 00-04:  CTI PP Number = ',
                string_integer (1, 6), '.');
          clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);
          IF register_21.mode THEN
            clp$put_display (display_control, '        BIT  05:     Mode = Manual.',
                  clc$trim, ignore_status);
          ELSE
            clp$put_display (display_control, '        BIT  05:     Mode = Automatic.',
                  clc$trim, ignore_status);
          IFEND;
          IF register_21.cti_reload_of_cm THEN
            clp$put_display (display_control, '        BIT  06:     CTI reload of CM from EDD tape = YES.',
                  clc$trim, ignore_status);
          ELSE
            clp$put_display (display_control, '        BIT  06:     CTI reload of CM from EDD tape = NO.',
                  clc$trim, ignore_status);
          IFEND;
          IF register_21.edd_select THEN
            clp$put_display (display_control, '        BIT  32:     EDD select = YES.',
                  clc$trim, ignore_status);
          ELSE
            clp$put_display (display_control, '        BIT  32:     EDD select = NO.',
                  clc$trim, ignore_status);
          IFEND;
          IF register_21.edd_esm_dump_select THEN
            clp$put_display (display_control, '        BIT  33:     EDD ESM dump select = YES.',
                  clc$trim, ignore_status);
          ELSE
            clp$put_display (display_control, '        BIT  33:     EDD ESM dump select = NO.',
                  clc$trim, ignore_status);
          IFEND;
          IF register_21.edd_tape_density THEN
            clp$put_display (display_control, '        BIT  34:     EDD tape density = 1600 PE.',
                  clc$trim, ignore_status);
          ELSE
            clp$put_display (display_control, '        BIT  34:     EDD tape density = 6250 GE.',
                  clc$trim, ignore_status);
          IFEND;
          IF register_21.edd_tape_type = 1 THEN
            clp$put_display (display_control, '        BITS 37-39:  EDD tape type = IPI.',
                  clc$trim, ignore_status);
          ELSE
            clp$put_display (display_control, '        BITS 37-39:  EDD tape_type = ISMT.',
                  clc$trim, ignore_status);
          IFEND;
          clp$convert_integer_to_rjstring (register_21.edd_tape_channel, 16, TRUE, '0',
                string_integer (1, 6), ignore_status);
          STRINGREP (display_string, string_length, '        BITS 43-47:  CM reload edd tape channel = ',
                string_integer (1, 6), '.');
          clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);
          clp$convert_integer_to_rjstring (register_21.edd_tape_equipment, 16, TRUE, '0',
                string_integer (1, 6), ignore_status);
          STRINGREP (display_string, string_length, '        BITS 48-51:  CM reload edd tape equipment = ',
                string_integer (1, 6), '.');
          clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);
          clp$convert_integer_to_rjstring (register_21.edd_tape_unit, 16, TRUE, '0',
                string_integer (1, 6), ignore_status);
          STRINGREP (display_string, string_length, '        BITS 52-55:  CM reload edd tape unit = ',
                string_integer (1, 6), '.');
          clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);
        ELSEIF mac_soft_register_p^.number = 22(16) THEN
          register_22.register := register;
          clp$convert_integer_to_rjstring (register_22.edd_counter, 10, TRUE, '0',
                string_integer (1, 6), ignore_status);
          clp$put_display (display_control,
                '        BITS 56-63:  Number of times EDD was executed before', clc$trim, ignore_status);
          STRINGREP (display_string, string_length, '                     re-initiating NOS/VE = ',
                string_integer (1, 6), '.');
          clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);
        ELSEIF mac_soft_register_p^.number = 23(16) THEN
          register_23.register := register;
          IF register_23.initialize_cm THEN
            clp$put_display (display_control, '        BIT  0:      Initialize CM bit is set.',
                  clc$trim, ignore_status);
          ELSE
            clp$put_display (display_control, '        BIT  0:      Initialize CM bit is NOT set.',
                  clc$trim, ignore_status);
          IFEND;
        ELSEIF mac_soft_register_p^.number = 27(16) THEN
          EXIT /display_opened/;  {---->
        IFEND;
      WHILEND;

    END /display_opened/;

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

  PROCEND dup$display_mac_soft_registers;
MODEND dum$display_mac_soft_registers;
