?? RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE Dump Analyzer : Display Alternate IOU Environment Control Command' ??
MODULE dum$display_alternate_iou_ec;

{ PURPOSE:
{   This module contains the command which displays the alternate environment control information
{   that is stored in the AE0 and AE1 records.

?? 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$determine_dump_information
*copyc dup$display_register_data
*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
?? NEWTITLE := 'Global Declarations Declared by This Module', EJECT ??
  CONST
    c$number_of_bytes = 8;

  TYPE
    t$record_data = PACKED ARRAY [1 .. c$number_of_bytes] OF t$record_data_entry,

    t$record_data_entry = PACKED RECORD
      unused: 0 .. 0f(16),
      byte_part: 0 .. 0ff(16),
    RECEND;

    VAR
      v$bit_descriptions: [STATIC] ARRAY [0 .. 63] OF string (35) :=
            [REP 32 OF ' ', '8K PP Memory', 'System Initialization', REP 17 OF ' ', 'Load Mode', 'Dump Mode',
             'Idle Mode', REP 2 OF ' ', 'Clock Wide', 'Clock Narrow', 'Enable Deadstart/Dump/Idle',
             'Enable Testmode', 'Enable O.S. Bounds Checking', 'Enable (R)+(A) to PP Memory',
             'Individual Channel MC', 'Enable Error Stop'];

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

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

  PROCEDURE display_record_data
    (    string_index: string (1);
         entry_p: ^dut$de_other_record_entry;
         dump_information_iou: dut$di_iou_data;
     VAR display_control: clt$display_control);

    VAR
      cell_p: ^cell,
      data_size: integer,
      display_string: string (osc$max_string_size),
      error_string: string (17),
      ignore_status: ost$status,
      iou_string: string (25),
      record_data_p: ^t$record_data,
      restart_file_seq_p: ^SEQ ( * ),
      string_length: integer;

    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;
    data_size := entry_p^.size;

    IF #SIZE (t$record_data) > data_size THEN
      clp$put_display (display_control, 'ERROR - Not enough data in the record, data not displayed.',
            clc$trim, ignore_status);
      RETURN;  {---->
    IFEND;

    STRINGREP (display_string, string_length, 'AE', string_index, ' - Alternate IOU', string_index,
          ' Environment Control Record:');
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);
    clp$put_display (display_control, ' ', clc$trim, ignore_status);
    STRINGREP (display_string, string_length, '      This record contains the contents of the IOU',
          string_index, ' Dependent');
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);
    clp$put_display (display_control, '      Environment Control Register prior to the deadstart operation',
          clc$trim, ignore_status);
    clp$put_display (display_control, '      performed to obtain this dump.', clc$trim, ignore_status);
    clp$put_display (display_control, ' ', clc$trim, ignore_status);

    iou_string := 'The IOU model type is an ';
    CASE dump_information_iou.model OF
    = duc$di_im_i0_5x =
      STRINGREP (display_string, string_length, '      ', iou_string, 'I0.');
    = duc$di_im_i1_1x =
      STRINGREP (display_string, string_length, '      ', iou_string, 'I1.');
    = duc$di_im_i2_20 =
      STRINGREP (display_string, string_length, '      ', iou_string, 'I2, model 20.');
    = duc$di_im_i4_40 =
      STRINGREP (display_string, string_length, '      ', iou_string, 'I4, model 40.');
    = duc$di_im_i4_42 =
      STRINGREP (display_string, string_length, '      ', iou_string, 'I4, model 42.');
    = duc$di_im_i4_43 =
      STRINGREP (display_string, string_length, '      ', iou_string, 'I4, model 43.');
    = duc$di_im_i4_44 =
      STRINGREP (display_string, string_length, '      ', iou_string, 'I4, model 44.');
    = duc$di_im_i4_46 =
      STRINGREP (display_string, string_length, '      ', iou_string, 'I4, model 46.');
    ELSE
      STRINGREP (display_string, string_length, '      ', iou_string, 'unknown.');
    CASEND;
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);
    clp$put_display (display_control, ' ', clc$trim, ignore_status);

    NEXT record_data_p IN restart_file_seq_p;
    data_size := data_size - #SIZE (record_data_p^);
    CASE dump_information_iou.model OF
    = duc$di_im_i0_5x, duc$di_im_i1_1x, duc$di_im_i2_20, duc$di_im_i4_40, duc$di_im_i4_42 =
      display_register_data ('NIO', record_data_p^, display_control);
    ELSE
    CASEND;

    IF #SIZE (t$record_data) > data_size THEN
      clp$put_display (display_control, 'ERROR - Not enough data in the record, data not displayed.',
            clc$trim, ignore_status);
      RETURN;  {---->
    IFEND;
    NEXT record_data_p IN restart_file_seq_p;
    CASE dump_information_iou.model OF
    = duc$di_im_i4_40, duc$di_im_i4_42, duc$di_im_i4_43, duc$di_im_i4_44, duc$di_im_i4_46 =
      display_register_data ('CIO', record_data_p^, display_control);
    ELSE
    CASEND;

  PROCEND display_record_data;
?? OLDTITLE ??
?? NEWTITLE := 'display_register_data', EJECT ??

{ PURPOSE:
{   This procedure displays the register data from the record.

  PROCEDURE display_register_data
    (    description: string (3);
         record_data: t$record_data;
     VAR display_control: clt$display_control);

    TYPE
      t$bits_or_number = PACKED RECORD
        CASE boolean OF
        = TRUE =
          bit_part: PACKED ARRAY [0 .. 4] OF boolean,
        = FALSE =
          number_part: 0 .. 1f(16),
        CASEND,
      RECEND,

      t$bytes_or_bits = RECORD
        CASE boolean OF
        = TRUE =
          byte_part: ARRAY [1 .. 8] OF 0 .. 0ff(16),
        = FALSE =
          bit_part: PACKED ARRAY [0 .. 63] OF boolean,
        CASEND,
      RECEND;

    VAR
      bits_or_number: t$bits_or_number,
      byte_index: 0 .. 0ff(16),
      bytes_or_bits: t$bytes_or_bits,
      display_string: string (osc$max_string_size),
      ignore_status: ost$status,
      index: 0 .. 0ff(16),
      string_2: string (2),
      string_6: string (6),
      string_length: integer;

    FOR index := 1 TO c$number_of_bytes DO
      bytes_or_bits.byte_part [index] := record_data [index].byte_part;
    FOREND;
    STRINGREP (display_string, string_length, '   ', description, ' Environment Control Register');
    dup$display_register_data (display_string (1, string_length), bytes_or_bits.byte_part, display_control);

    FOR index := 35 TO 39 DO
      bits_or_number.bit_part [index-35] := bytes_or_bits.bit_part [index];
    FOREND;
    clp$convert_integer_to_rjstring (bits_or_number.number_part, 16, TRUE, '0', string_6, ignore_status);
    STRINGREP (display_string, string_length, '       PP Number (bits 35-39) = ', string_6);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    FOR index := 43 TO 47 DO
      bits_or_number.bit_part [index-43] := bytes_or_bits.bit_part [index];
    FOREND;
    clp$convert_integer_to_rjstring (bits_or_number.number_part, 16, TRUE, '0', string_6, ignore_status);
    STRINGREP (display_string, string_length, '       Channel Number (bits 43-47) = ', string_6);
    clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);

    FOR index := 0 TO 63 DO
      IF bytes_or_bits.bit_part [index] AND (v$bit_descriptions [index] <> ' ') THEN
        STRINGREP (display_string, string_length, '       Bit ', index, ' = ', v$bit_descriptions [index]);
        clp$put_display (display_control, display_string (1, string_length), clc$trim, ignore_status);
      IFEND;
    FOREND;

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

  PROCEND display_register_data;
?? OLDTITLE ??
?? NEWTITLE := 'dup$display_alternate_iou_ec', EJECT ??

{ PURPOSE:
{   This procedure displays the alternate iou environment control information.

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

{ PROCEDURE display_alternate_iou_ec, disaie (
{   output, o: file = $optional
{   title, t: string 1..31 = 'display_alternate_iou_ec'
{   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 (26),
      recend,
      type3: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [90, 8, 30, 13, 12, 7, 220],
    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, 26],
{ 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_alternate_iou_ec'''],
{ 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;

    VAR
      data_displayed: boolean,
      data_value: clt$data_value,
      display_control: clt$display_control,
      dump_information: dut$dump_information,
      entry_p: ^dut$de_other_record_entry,
      ignore_status: ost$status,
      output_display_opened: boolean,
      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 (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^;

      dup$determine_dump_information (dump_information);
      data_displayed := FALSE;

      IF dump_information.iou [0].model <> duc$di_im_unknown THEN
        data_value.kind := clc$name;
        data_value.name_value := 'AE0';
        dup$find_record_list_entry (data_value, entry_p);
        IF entry_p <> NIL THEN
          data_displayed := TRUE;
          display_record_data ('0', entry_p, dump_information.iou [0], display_control);
        IFEND;
      IFEND;

      IF dump_information.iou [1].model <> duc$di_im_unknown THEN
        data_value.kind := clc$name;
        data_value.name_value := 'AE1';
        dup$find_record_list_entry (data_value, entry_p);
        IF entry_p <> NIL THEN
          data_displayed := TRUE;
          display_record_data ('1', entry_p, dump_information.iou [1], display_control);
        IFEND;
      IFEND;

      IF NOT data_displayed THEN
        osp$set_status_abnormal (duc$dump_analyzer_id, due$data_not_on_dump, 'The AE0 and AE1 records are',
              status);
      IFEND;

    END /display_opened/;

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

  PROCEND dup$display_alternate_iou_ec;
MODEND dum$display_alternate_iou_ec;
