?? RIGHT := 110 ??
?? NEWTITLE := 'Logical Configuration Manager' ??
MODULE cmm$logical_configuration_mgr;
?? PUSH (LISTEXT := ON) ??
*copyc oss$job_paged_literal
*copyc cmc$display_element_constants
*copyc cmc$minimum_page_size
*copyc rmd$volume_declarations
*copyc cme$logical_configuration_mgr
*copyc dme$tape_errors
*copyc ofe$error_codes
*copyc cmt$connection
*copyc cmt$cpu_element_definition
*copyc cmt$display_option
*copyc cmt$element_capability
*copyc cmt$element_definition
*copyc cmt$element_descriptor
*copyc cmt$element_information
*copyc cmt$element_state
*copyc cmt$lcu_display_option_key
*copyc cmt$physical_address_parts
*copyc cmt$physical_address_specifier
*copyc cmt$physical_identification
*copyc cmt$state_change_request
*copyc cmt$unit_class
*copyc cmt$unit_type
*copyc iot$logical_unit
*copyc iot$unit_type
*copyc ost$caller_identifier
*copyc ost$processor_id
*copyc pmt$mainframe_id
*copyc rmt$device_class
?? POP ??
*copyc amp$close
*copyc amp$fetch_access_information
*copyc amp$get_file_attributes
*copyc amp$get_segment_pointer
*copyc amp$open
*copyc amp$set_segment_eoi
*copyc amp$set_segment_position
*copyc avp$configuration_administrator
*copyc avp$removable_media_operator
*copyc avp$system_operator
*copyc clp$convert_integer_to_rjstring
*copyc clp$convert_integer_to_string
*copyc clp$horizontal_tab_display
*copyc clp$new_display_line
*copyc clp$put_partial_display
*copyc cmp$convert_channel_type
*copyc cmp$deadstart_phase
*copyc cmp$determine_active_path
*copyc cmp$determine_tape_element
*copyc cmp$format_error_message
*copyc cmp$get_connection_list
*copyc cmp$get_connection_status
*copyc cmp$get_cpu_element_r3
*copyc cmp$get_driver_state
*copyc cmp$get_element_information
*copyc cmp$get_element_state
*copyc cmp$get_element_type
*copyc cmp$get_ms_class_on_volume
*copyc cmp$get_parity_status_info
*copyc cmp$get_physical_attributes
*copyc cmp$multiple_iou_system
*copyc cmp$post_deadstart
*copyc cmp$process_cpu_state_change
*copyc cmp$process_state_change
*copyc cmp$search_peripheral_table
*copyc cmp$support_redundant_access
*copyc cmp$valid_channel_name
*copyc jmp$get_job_attributes
*copyc jmp$system_job
*copyc osp$append_status_integer
*copyc osp$append_status_parameter
*copyc osp$set_status_abnormal
*copyc pmp$get_mainframe_id
*copyc pmp$get_unique_name
*copyc cmv$peripheral_element_table
*copyc cmv$physical_configuration

?? TITLE := '    [XDCL, #GATE] cmp$change_cpu_element_state', EJECT ??
*copyc cmh$change_cpu_element_state

  PROCEDURE [XDCL, #GATE] cmp$change_cpu_element_state
    (    processor_id: ost$processor_id;
         state: cmt$element_state;
     VAR status: ost$status);

    VAR
      caller_id: ost$caller_identifier,
      cpu_element_p: ^cmt$cpu_element_definition,
      current_state: cmt$element_state,
      state_translation_table: [STATIC, READ, oss$job_paged_literal] ARRAY [cmt$element_state] OF
            string (4) := ['  ON', ' OFF', 'DOWN'];


    #caller_id (caller_id);
    status.normal := TRUE;

    IF NOT (avp$configuration_administrator () OR avp$system_operator () OR
                  (caller_id.ring <= 6)) THEN
       osp$set_status_abnormal ('OF', ofe$sou_not_active,
               'configuration_administration or system_operation', status);
       RETURN;
    IFEND;

    PUSH cpu_element_p;
    cmp$get_cpu_element_r3 (processor_id, cpu_element_p, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    current_state := cpu_element_p^.processor_state;

    IF current_state = state THEN
{ Issue WARNING or INFORMATIVE message }
      osp$set_status_abnormal (cmc$configuration_management_id, cme$request_state_is_crnt_state, '', status);
      RETURN;
    IFEND;

{ Current supported state changes for CPUs are:
{     ON --> DOWN
{   DOWN -->   ON
{ State changes which are NOT supported are:
{     ON -->  OFF
{    OFF -->   ON
{    OFF --> DOWN
{   DOWN -->  OFF

    IF (state = cmc$off) OR (current_state = cmc$off) THEN
      osp$set_status_abnormal (cmc$configuration_management_id, cme$lcm_unsupported_statechange,
              state_translation_table [current_state], status);
      osp$append_status_parameter (osc$status_parameter_delimiter, state_translation_table [state], status);
      RETURN;
    IFEND;

    cmp$process_cpu_state_change (processor_id, current_state, state, status);

  PROCEND cmp$change_cpu_element_state;

?? TITLE := '    [XDCL, #GATE] cmp$change_element_state', EJECT ??

*copyc CMH$CHANGE_ELEMENT_STATE

  PROCEDURE [XDCL, #GATE] cmp$change_element_state
    (    element: cmt$element_descriptor;
         state: cmt$element_state;
     VAR status: ost$status);

    VAR
      caller_id: ost$caller_identifier,
      current_state: cmt$element_state,
      definition: cmt$element_definition,
      element_info: array [1 .. 1] of cmt$element_info_item,
      element_name: cmt$element_name,
      index: integer,
      iou_name: cmt$element_name,
      job_name: jmt$system_supplied_name,
      physical_id: cmt$physical_identification,
      privileged_job: boolean,
      tape_element: boolean,
      tape_status: ost$status,
      valid_request: boolean;

    #caller_id (caller_id);
    status.normal := TRUE;
    iou_name := 'IOU0';

    /main_program/
      BEGIN
        privileged_job := caller_id.ring <= 6;

        IF NOT privileged_job THEN
          osp$set_status_abnormal (cmc$configuration_management_id, cme$lcm_ring_validation_error,
               'CMP$CHANGE_ELEMENT_STATE', status);
          EXIT /main_program/;
        IFEND;
        cmp$determine_tape_element (element, tape_element);
        IF tape_element THEN
          IF NOT (avp$system_operator () OR avp$configuration_administrator () OR
                  avp$removable_media_operator () OR privileged_job) THEN
            osp$set_status_abnormal ('OF', ofe$sou_not_active,
               'configuration_administration, removable_media_operation ' CAT
               'or system_operation', status);
            EXIT /main_program/;
          IFEND;
        ELSE
          IF NOT (avp$configuration_administrator () OR avp$system_operator () OR
                  privileged_job) THEN
            osp$set_status_abnormal ('OF', ofe$sou_not_active,
               'configuration_administration or system_operation', status);
            EXIT /main_program/;
          IFEND;
        IFEND;
        CASE element.element_type OF
        = cmc$data_channel_element =
          element_name := element.channel_descriptor.name;

  { Set up iou name if there is more than one IOU present

          IF cmp$multiple_iou_system () THEN
            iou_name := element.channel_descriptor.iou;
          IFEND;
        = cmc$controller_element, cmc$channel_adapter_element, cmc$external_processor_element,
            cmc$storage_device_element, cmc$communications_element =
          element_name := element.peripheral_descriptor.element_name;
        ELSE
          ;
        CASEND;

        element_info [1].selector := cmc$system_critical_element;
        cmp$get_element_information (element, element_info, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;

        IF element_info [1].item_returned THEN
          IF element_info [1].system_critical_element THEN
            IF element.element_type = cmc$storage_device_element THEN
              osp$set_status_abnormal (cmc$configuration_management_id,
                cme$lcm_system_critical_element, element_name, status);
              EXIT /main_program/;
            IFEND;
          IFEND;
        IFEND;

        cmp$get_element_state (element_name, iou_name, current_state, status);
        IF NOT status.normal THEN
          cmp$format_error_message (element, physical_id, FALSE, cme$lcm_element_not_found, status);
          EXIT /main_program/;
        IFEND;

        IF state = current_state THEN
          { Issue WARNING or INFORMATIVE message }
          EXIT /main_program/;
        IFEND;

        cmp$process_state_change (tape_element, {system_caller=} FALSE, element, element_info [1].
             system_critical_element, current_state, state, status);

      END /main_program/;

  PROCEND cmp$change_element_state;

?? TITLE := '    cmp$open_scratch_sa_file', EJECT ??

  PROCEDURE cmp$open_scratch_sa_file (VAR file_id: amt$file_identifier;
    VAR status: ost$status);

    VAR
      contains_data: boolean,
      existing_file: boolean,
      get_attr: array [1 .. 1] of amt$get_item,
      lfn: amt$local_file_name,
      local_file: boolean;

    status.normal := TRUE;

  /main_program/
    BEGIN

      get_attr [1].key := amc$null_attribute;

      REPEAT
        pmp$get_unique_name (lfn, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
        amp$get_file_attributes (lfn, get_attr, local_file, existing_file,
              contains_data, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      UNTIL NOT local_file;

      amp$open (lfn, amc$segment, NIL, file_id, status);
      IF NOT status.normal THEN
        EXIT /main_program/;
      IFEND;

    END /main_program/;

  PROCEND cmp$open_scratch_sa_file;

?? TITLE := '    cmp$copy_sequence_files', EJECT ??

  PROCEDURE cmp$copy_sequence_files (file_id: amt$file_identifier;
    VAR sequence: ^SEQ ( * );
    VAR status: ost$status);

    VAR
      eoi_addr: array [1 .. 1] of amt$access_info,
      from_cell: ^cell,
      index: integer,
      len: integer,
      seg: amt$segment_pointer,
      to_cell: ^cell;

    status.normal := TRUE;

  /main_program/
    BEGIN

      eoi_addr [1].key := amc$eoi_byte_address;

      amp$fetch_access_information (file_id, eoi_addr, status);
      IF NOT status.normal THEN
        EXIT /main_program/;
      IFEND;

      len := eoi_addr [1].eoi_byte_address;

      amp$get_segment_pointer (file_id, amc$sequence_pointer, seg, status);
      IF NOT status.normal THEN
        EXIT /main_program/;
      IFEND;

      RESET seg.sequence_pointer;
      RESET sequence;

      FOR index := 1 TO len DO

        NEXT from_cell IN seg.sequence_pointer;

        IF from_cell = NIL THEN
          osp$set_status_abnormal (cmc$configuration_management_id,
                cme$lcm_empty_lc, ' ', status);
        IFEND;

        NEXT to_cell IN sequence;

        IF to_cell = NIL THEN
          osp$set_status_abnormal (cmc$configuration_management_id,
                cme$lcm_empty_lc, ' ', status);
        IFEND;

        to_cell^ := from_cell^;

      FOREND;

    END /main_program/;

  PROCEND cmp$copy_sequence_files;

?? TITLE := '    [XDCL, #GATE] cmp$display_type_elements', EJECT ??

*copy CMH$DISPLAY_TYPE_ELEMENTS

  PROCEDURE [XDCL, #GATE] cmp$display_type_elements
    (    element_type: cmt$element_type;
         display_option: cmt$display_option;
         element_count: integer;
         lc_element: ^array [1 .. *] of cmt$element_definition;
     VAR display_control: clt$display_control;
     VAR status: ost$status);

    VAR
      cmv$element_type_map: [STATIC, READ, oss$job_paged_literal] array
        [cmt$element_type] of ost$name := [
        { cmc$central_memory_element } '$CENTRAL_MEMORY',
        { cmc$central_processor_element } '$CENTRAL_PROCESSOR',
        { cmc$controller_element } '$CONTROLLER',
        { cmc$data_channel_element } '$CHANNEL',
        { cmc$channel_adapter_element } '$CHANNEL_ADAPTER',
        { cmc$iou_element } '$IOU',
        { cmc$mainframe_element } '$MAINFRAME',
        { cmc$pem_element } '$PEM',
        { cmc$pp_element } '$PP',
        { cmc$storage_device_element } '$STORAGE_DEVICE',
        { cmc$external_processor_element } '$EXTERNAL_PROCESSOR',
        { cmc$communications_element } '$COMMUNICATIONS_ELEMENTS'];

    VAR
      found_element: boolean,
      i: integer,
      mainframe_element: ^cmt$element_definition,
      mainframe_id: pmt$mainframe_id;

    status.normal := TRUE;

  /main_program/
    BEGIN
      pmp$get_mainframe_id (mainframe_id, status);
      IF NOT status.normal THEN
        EXIT /main_program/;
      IFEND;
      found_element := FALSE;
      FOR i := 1 TO element_count DO
        IF lc_element^[i].element_type = element_type THEN
          found_element := TRUE;
          mainframe_element := ^lc_element^ [i];
          CASE element_type OF
          = cmc$data_channel_element =
            cmp$display_channel_element (mainframe_element, display_option, mainframe_id, element_count,
                  lc_element, display_control, status);
          = cmc$controller_element =
            cmp$display_controller_element (mainframe_element, display_option, mainframe_id, element_count,
                  lc_element, display_control, status);
          = cmc$channel_adapter_element =
            cmp$display_ca_element (mainframe_element, display_option, mainframe_id, element_count,
                  lc_element, display_control, status);
          = cmc$communications_element =
            cmp$display_comm_element (mainframe_element, display_option, mainframe_id, element_count,
                  lc_element, display_control, status);
          = cmc$storage_device_element =
            cmp$display_storage_dev_element (mainframe_element, display_option, mainframe_id, element_count,
                  lc_element, display_control, status);
          = cmc$external_processor_element =
            cmp$display_external_proc (mainframe_element, display_option, mainframe_id, element_count,
                  lc_element, display_control, status);
          ELSE
            ;
          CASEND;
          IF NOT status.normal THEN
            EXIT /main_program/;
          IFEND;
        IFEND;
      FOREND;

      IF NOT found_element THEN
        osp$set_status_abnormal (cmc$configuration_management_id,
          cme$lcm_element_not_found, cmv$element_type_map [element_type], status);
      IFEND;

    END /main_program/;

  PROCEND cmp$display_type_elements;

?? TITLE := '    [XDCL, #GATE] cmp$display_named_element', EJECT ??

*copy CMH$DISPLAY_NAMED_ELEMENT

  PROCEDURE [XDCL, #GATE] cmp$display_named_element
    (    element_name: cmt$element_name;
         iou_name: cmt$element_name;
         display_option: cmt$display_option;
         element_count: integer;
         lc_element: ^array [1 .. *] of cmt$element_definition;
     VAR display_control: clt$display_control;
     VAR status: ost$status);

    VAR
      index: integer,
      mainframe_element: ^cmt$element_definition,
      mainframe_id: pmt$mainframe_id,
      text: string (64);

    status.normal := TRUE;
    text := '   ';
  /main_program/
    BEGIN
      pmp$get_mainframe_id (mainframe_id, status);
      IF NOT status.normal THEN
        EXIT /main_program/;
      IFEND;

    /forloop/
      FOR index := 1 TO element_count DO
        IF lc_element^[index].element_name = element_name THEN
          mainframe_element := ^lc_element^[index];
          CASE mainframe_element^.element_type OF
          = cmc$data_channel_element =
            IF (mainframe_element^.data_channel.iou = iou_name) THEN
              cmp$display_channel_element (mainframe_element, display_option, mainframe_id, element_count,
                  lc_element, display_control, status);
            ELSE
              CYCLE /forloop/;
            IFEND;
          = cmc$controller_element =
            cmp$display_controller_element (mainframe_element, display_option, mainframe_id, element_count,
                  lc_element, display_control, status);
          = cmc$channel_adapter_element =
            cmp$display_ca_element (mainframe_element, display_option, mainframe_id, element_count,
                  lc_element, display_control, status);
          = cmc$communications_element =
            cmp$display_comm_element (mainframe_element, display_option, mainframe_id, element_count,
                  lc_element, display_control, status);
          = cmc$storage_device_element =
            cmp$display_storage_dev_element (mainframe_element, display_option, mainframe_id, element_count,
                  lc_element, display_control, status);
          = cmc$external_processor_element =
            cmp$display_external_proc (mainframe_element, display_option, mainframe_id, element_count,
                  lc_element, display_control, status);
          ELSE
            ;
          CASEND;
          EXIT /main_program/;
        IFEND;
      FOREND /forloop/;
      IF cmp$valid_channel_name (element_name) THEN
        text (1, 5) := iou_name (1, 5);
        text (6, *) := element_name;
      ELSE
        text (1, *) := element_name;
      IFEND;
      osp$set_status_abnormal (cmc$configuration_management_id,
            cme$lcm_element_not_found, text, status);

    END /main_program/;

  PROCEND cmp$display_named_element;

?? TITLE := '    cmp$display_ca_element', EJECT ??

  PROCEDURE cmp$display_ca_element
    (    mainframe_element: ^cmt$element_definition;
         display_option: cmt$display_option;
         mainframe_id: pmt$mainframe_id;
         element_count: integer;
         lc_element: ^array [1 .. *] of cmt$element_definition;
     VAR display_control: clt$display_control;
     VAR status: ost$status);

    VAR
      i: integer,
      iou_name: cmt$element_name,
      number: integer,
      number_string: string (10),
      product_id: string (10),
      upline_element: ^cmt$element_definition;

    status.normal := TRUE;
    iou_name := 'IOU0';

  /main_program/

    BEGIN
      put_header (cmc$msg_channel_adapter_element, mainframe_element^.element_name, display_control, status);
      IF NOT status.normal THEN
        EXIT /main_program/;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$element_id_kw] <= display_option) THEN
        product_id (1, 6) := mainframe_element^.product_id.product_number;
        product_id (7, 1) := mainframe_element^.product_id.underscore;
        product_id (8, 3) := mainframe_element^.product_id.model_number;
        put_subheader (cmc$msg_product_id, product_id, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$serial_number_kw] <= display_option) THEN
        put_subheader (cmc$msg_serial_number, mainframe_element^.serial_number, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$ioupn_kw] <= display_option) THEN
        put_subheader (cmc$msg_peripheral_driver_name, mainframe_element^.channel_adapter.
              peripheral_driver_name, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$state_kw] <= display_option) THEN
        cmp$display_element_state (mainframe_element^.element_name,iou_name, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$physical_connection_kw] <= display_option) THEN
        number := mainframe_element^.channel_adapter.physical_equipment_number;
        clp$convert_integer_to_rjstring (number, 10, TRUE, ' ', number_string, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
        put_subheader (cmc$msg_equipment_number, number_string, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;

        clp$horizontal_tab_display (display_control, cmc$starting_subheader_column, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;

        clp$put_partial_display (display_control, cmc$msg_channel_connections, clc$no_trim, amc$continue,
              status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;

        cmp$display_ca_upline_conn (mainframe_element^.channel_adapter.connection.channel, display_control,
              status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;
      IF ($cmt$display_option [cmc$all_kw] <= display_option) OR
           ($cmt$display_option [cmc$application_info_kw] <= display_option) THEN
        display_application_info (mainframe_element^, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;
      IF ($cmt$display_option [cmc$all_kw] <= display_option) OR
           ($cmt$display_option [cmc$site_info_kw] <= display_option) THEN
        display_site_info (mainframe_element^, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;
      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$connection_status_kw] <= display_option) THEN
        display_conn_status (mainframe_element, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$active_paths_kw] <= display_option) THEN
        put_subheader (cmc$msg_active_paths, ' ', display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
        display_ca_paths (cmc$active_paths, mainframe_element, mainframe_id, element_count, lc_element,
              display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$inactive_paths_kw] <= display_option) THEN
        put_subheader (cmc$msg_inactive_paths, ' ', display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
        display_ca_paths (cmc$inactive_paths, mainframe_element, mainframe_id, element_count, lc_element,
              display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$disabled_paths_kw] <= display_option) THEN
        put_subheader (cmc$msg_disabled_paths, ' ', display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
        display_ca_paths (cmc$disabled_paths, mainframe_element, mainframe_id, element_count, lc_element,
              display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$physical_paths_kw] <= display_option) THEN
        put_subheader (cmc$msg_physical_paths, ' ', display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
        display_ca_paths (cmc$physical_paths, mainframe_element, mainframe_id, element_count, lc_element,
              display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

    END /main_program/;

  PROCEND cmp$display_ca_element;

?? TITLE := '    cmp$display_channel_element', EJECT ??

  PROCEDURE cmp$display_channel_element
    (    mainframe_element: ^cmt$element_definition;
         display_option: cmt$display_option;
         mainframe_id: pmt$mainframe_id;
         element_count: integer;
         lc_element: ^array [1 .. *] of cmt$element_definition;
     VAR display_control: clt$display_control;
     VAR status: ost$status);

    VAR
      channel_type: string (11),
      element_type: cmt$element_type,
      i: integer,
      unused_iou: cmt$element_name;

    status.normal := TRUE;

  /main_program/
    BEGIN

      put_header (cmc$msg_channel_element, mainframe_element^.element_name, display_control, status);
      IF NOT status.normal THEN
        EXIT /main_program/;
      IFEND;

      cmp$convert_channel_type (mainframe_element^.data_channel.kind, channel_type);
      put_subheader (cmc$msg_channel_type, channel_type, display_control, status);
      IF NOT status.normal THEN
        EXIT /main_program/;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$state_kw] <= display_option) THEN
        cmp$display_element_state (mainframe_element^.element_name, mainframe_element^.data_channel.iou,
             display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$physical_connection_kw] <= display_option) THEN
        put_subheader (cmc$msg_mainframe, mainframe_element^.data_channel.mainframe_ownership,
              display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;

        put_subheader (cmc$msg_iou_con, mainframe_element^.data_channel.iou, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;

        clp$horizontal_tab_display (display_control, cmc$starting_subheader_column, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;

        /down_line_loop/
        FOR i := LOWERBOUND (mainframe_element^.data_channel.connection.equipment)
            TO UPPERBOUND (mainframe_element^.data_channel.connection.equipment) DO
          IF mainframe_element^.data_channel.connection.equipment [i].configured THEN
            cmp$get_element_type (mainframe_element^.data_channel.
              connection.equipment [i].element_name, unused_iou, element_type, status);
            IF NOT status.normal THEN
              EXIT /main_program/;
            IFEND;
            EXIT /down_line_loop/;
          IFEND;
        FOREND /down_line_loop/;

        CASE element_type OF
        = cmc$controller_element =
          clp$put_partial_display (display_control, cmc$msg_controller_con, clc$no_trim, amc$continue,
                status);
        = cmc$channel_adapter_element =
          clp$put_partial_display (display_control, cmc$msg_channel_adapter_con, clc$no_trim, amc$continue,
                status);
        = cmc$storage_device_element =
          clp$put_partial_display (display_control, cmc$msg_storage_device_con, clc$no_trim, amc$continue,
                status);
        = cmc$communications_element =
          clp$put_partial_display (display_control, cmc$msg_communications_con, clc$no_trim, amc$continue,
                status);
        = cmc$external_processor_element =
          clp$put_partial_display (display_control, cmc$msg_external_proc_con, clc$no_trim, amc$continue,
                status);
        CASEND;
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;

        cmp$display_element_connection (mainframe_element^.data_channel.connection.equipment,
              display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$connection_status_kw] <= display_option) THEN
        display_conn_status (mainframe_element, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$active_paths_kw] <= display_option) THEN
        put_subheader (cmc$msg_active_paths, ' ', display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
        display_channel_paths (cmc$active_paths, mainframe_element, mainframe_id, element_count, lc_element,
              display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$inactive_paths_kw] <= display_option) THEN
        put_subheader (cmc$msg_inactive_paths, ' ', display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
        display_channel_paths (cmc$inactive_paths, mainframe_element, mainframe_id, element_count, lc_element,
              display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$disabled_paths_kw] <= display_option) THEN
        put_subheader (cmc$msg_disabled_paths, ' ', display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
        display_channel_paths (cmc$disabled_paths, mainframe_element, mainframe_id, element_count, lc_element,
              display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF $cmt$display_option[cmc$physical_paths_kw] <= display_option THEN
        put_subheader (cmc$msg_physical_paths, ' ', display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
        display_channel_paths (cmc$physical_paths, mainframe_element, mainframe_id, element_count, lc_element,
              display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

    END /main_program/;

  PROCEND cmp$display_channel_element;

?? TITLE := '    cmp$display_comm_element', EJECT ??

  PROCEDURE cmp$display_comm_element
    (    mainframe_element: ^cmt$element_definition;
         display_option: cmt$display_option;
         mainframe_id: pmt$mainframe_id;
         element_count: integer;
         lc_element: ^array [1 .. *] of cmt$element_definition;
     VAR display_control: clt$display_control;
     VAR status: ost$status);

    VAR
      iou_name: cmt$element_name,
      number: integer,
      number_string: string (10),
      product_id: string (10);

    status.normal := TRUE;
    iou_name := 'IOU0';
  /main_program/
    BEGIN

      put_header (cmc$msg_communications_element, mainframe_element^.element_name, display_control, status);
      IF NOT status.normal THEN
        EXIT /main_program/;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$element_id_kw] <= display_option) THEN
        product_id (1, 6) := mainframe_element^.product_id.product_number;
        product_id (7, 1) := mainframe_element^.product_id.underscore;
        product_id (8, 3) := mainframe_element^.product_id.model_number;
        put_subheader (cmc$msg_product_id, product_id, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$serial_number_kw] <= display_option) THEN
        put_subheader (cmc$msg_serial_number, mainframe_element^.serial_number, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$ioupn_kw] <= display_option) THEN
        put_subheader (cmc$msg_peripheral_driver_name, mainframe_element^.communications_element.
              peripheral_driver_name, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$state_kw] <= display_option) THEN
        cmp$display_element_state (mainframe_element^.element_name,iou_name, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$physical_connection_kw] <= display_option) THEN
        number := mainframe_element^.communications_element.physical_equipment_number;
        clp$convert_integer_to_rjstring (number, 10, TRUE, ' ', number_string, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
        put_subheader (cmc$msg_equipment_number, number_string, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;

        cmp$display_upline_connection (mainframe_element^.communications_element.connection.port,
              display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;
      IF ($cmt$display_option [cmc$all_kw] <= display_option) OR
           ($cmt$display_option [cmc$application_info_kw] <= display_option) THEN
        display_application_info (mainframe_element^, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;
      IF ($cmt$display_option [cmc$all_kw] <= display_option) OR
           ($cmt$display_option [cmc$site_info_kw] <= display_option) THEN
        display_site_info (mainframe_element^, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$connection_status_kw] <= display_option) THEN
        display_conn_status (mainframe_element, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$active_paths_kw] <= display_option) THEN
        put_subheader (cmc$msg_active_paths, ' ', display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
        display_comm_paths (cmc$active_paths, mainframe_element, mainframe_id, element_count, lc_element,
              display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$inactive_paths_kw] <= display_option) THEN
        put_subheader (cmc$msg_inactive_paths, ' ', display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
        display_comm_paths (cmc$inactive_paths, mainframe_element, mainframe_id, element_count, lc_element,
              display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$disabled_paths_kw] <= display_option) THEN
        put_subheader (cmc$msg_disabled_paths, ' ', display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
        display_comm_paths (cmc$disabled_paths, mainframe_element, mainframe_id, element_count, lc_element,
              display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF $cmt$display_option[cmc$physical_paths_kw] <= display_option THEN
        put_subheader (cmc$msg_physical_paths, ' ', display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
        display_comm_paths (cmc$physical_paths, mainframe_element, mainframe_id, element_count, lc_element,
              display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

    END /main_program/;

  PROCEND cmp$display_comm_element;

?? TITLE := '    cmp$display_controller_element', EJECT ??

  PROCEDURE cmp$display_controller_element
    (    mainframe_element: ^cmt$element_definition;
         display_option: cmt$display_option;
         mainframe_id: pmt$mainframe_id;
         element_count: integer;
         lc_element: ^array [1 .. *] of cmt$element_definition;
     VAR display_control: clt$display_control;
     VAR status: ost$status);

    VAR
      iou_name: cmt$element_name,
      number: integer,
      number_string: string (10),
      product_id: string (10);

    status.normal := TRUE;
    iou_name := 'IOU0';

  /main_program/
    BEGIN

      put_header (cmc$msg_controller_element, mainframe_element^.element_name, display_control, status);
      IF NOT status.normal THEN
        EXIT /main_program/;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$element_id_kw] <= display_option) THEN
        product_id (1, 6) := mainframe_element^.product_id.product_number;
        product_id (7, 1) := mainframe_element^.product_id.underscore;
        product_id (8, 3) := mainframe_element^.product_id.model_number;
        put_subheader (cmc$msg_product_id, product_id, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$serial_number_kw] <= display_option) THEN
        put_subheader (cmc$msg_serial_number, mainframe_element^.serial_number, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$ioupn_kw] <= display_option) THEN
        put_subheader (cmc$msg_peripheral_driver_name, mainframe_element^.controller.peripheral_driver_name,
              display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$state_kw] <= display_option) THEN
        cmp$display_element_state (mainframe_element^.element_name, iou_name, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$physical_connection_kw] <= display_option) THEN
        number := mainframe_element^.controller.physical_equipment_number;
        clp$convert_integer_to_rjstring (number, 10, TRUE, ' ', number_string,
              status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;

        put_subheader (cmc$msg_equipment_number, number_string, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;

        cmp$display_upline_connection (mainframe_element^.controller.connection.port, display_control,
              status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;

        clp$horizontal_tab_display (display_control, cmc$starting_subheader_column, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;

        clp$put_partial_display (display_control, cmc$msg_storage_device_con, clc$no_trim, amc$continue,
              status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;

        cmp$display_element_connection (mainframe_element^.controller.connection.unit, display_control,
              status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;
      IF ($cmt$display_option [cmc$all_kw] <= display_option) OR
           ($cmt$display_option [cmc$application_info_kw] <= display_option) THEN
        display_application_info (mainframe_element^, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;
      IF ($cmt$display_option [cmc$all_kw] <= display_option) OR
           ($cmt$display_option [cmc$site_info_kw] <= display_option) THEN
        display_site_info (mainframe_element^, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$connection_status_kw] <= display_option) THEN
        display_conn_status (mainframe_element, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$active_paths_kw] <= display_option) THEN
        put_subheader (cmc$msg_active_paths, ' ', display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
        display_controller_paths (cmc$active_paths, mainframe_element, mainframe_id, element_count,
              lc_element, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$inactive_paths_kw] <= display_option) THEN
        put_subheader (cmc$msg_inactive_paths, ' ', display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
        display_controller_paths (cmc$inactive_paths, mainframe_element, mainframe_id, element_count,
              lc_element, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$disabled_paths_kw] <= display_option) THEN
        put_subheader (cmc$msg_disabled_paths, ' ', display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
        display_controller_paths (cmc$disabled_paths, mainframe_element, mainframe_id, element_count,
              lc_element, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF $cmt$display_option[cmc$physical_paths_kw] <= display_option THEN
        put_subheader (cmc$msg_physical_paths, ' ', display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
        display_controller_paths (cmc$physical_paths, mainframe_element, mainframe_id, element_count,
              lc_element, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

    END /main_program/;

  PROCEND cmp$display_controller_element;

?? TITLE := '    cmp$display_external_proc', EJECT ??

  PROCEDURE cmp$display_external_proc
    (    mainframe_element: ^cmt$element_definition;
         display_option: cmt$display_option;
         mainframe_id: pmt$mainframe_id;
         element_count: integer;
         lc_element: ^array [1 .. *] of cmt$element_definition;
     VAR display_control: clt$display_control;
     VAR status: ost$status);

    VAR
      iou_name: cmt$element_name,
      number: integer,
      number_string: string (10),
      product_id: string (10);

    status.normal := TRUE;
    iou_name := 'IOU0';

  /main_program/
    BEGIN

      put_header (cmc$msg_ext_proc_element, mainframe_element^.element_name, display_control, status);
      IF NOT status.normal THEN
        EXIT /main_program/;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$element_id_kw] <= display_option) THEN
        product_id (1, 6) := mainframe_element^.product_id.product_number;
        product_id (7, 1) := mainframe_element^.product_id.underscore;
        product_id (8, 3) := mainframe_element^.product_id.model_number;
        put_subheader (cmc$msg_product_id, product_id, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$serial_number_kw] <= display_option) THEN
        put_subheader (cmc$msg_serial_number, mainframe_element^.serial_number, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$ioupn_kw] <= display_option) THEN
        put_subheader (cmc$msg_peripheral_driver_name, mainframe_element^.external_processor.
              peripheral_driver_name, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$state_kw] <= display_option) THEN
        cmp$display_element_state (mainframe_element^.element_name, iou_name, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$physical_connection_kw] <= display_option) THEN
        number := mainframe_element^.external_processor.physical_equipment_number;
        clp$convert_integer_to_rjstring (number, 10, TRUE, ' ', number_string, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
        put_subheader (cmc$msg_equipment_number, number_string, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;

        cmp$display_upline_connection (mainframe_element^.external_processor.connection.io_port,
              display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;
      IF ($cmt$display_option [cmc$all_kw] <= display_option) OR
           ($cmt$display_option [cmc$application_info_kw] <= display_option) THEN
        display_application_info (mainframe_element^, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;
      IF ($cmt$display_option [cmc$all_kw] <= display_option) OR
           ($cmt$display_option [cmc$site_info_kw] <= display_option) THEN
        display_site_info (mainframe_element^, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$connection_status_kw] <= display_option) THEN
        display_conn_status (mainframe_element, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$active_paths_kw] <= display_option) THEN
        put_subheader (cmc$msg_active_paths, ' ', display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
        display_external_proc_paths (cmc$active_paths, mainframe_element, mainframe_id, element_count,
              lc_element, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$inactive_paths_kw] <= display_option) THEN
        put_subheader (cmc$msg_inactive_paths, ' ', display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
        display_external_proc_paths (cmc$inactive_paths, mainframe_element, mainframe_id, element_count,
              lc_element, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$disabled_paths_kw] <= display_option) THEN
        put_subheader (cmc$msg_disabled_paths, ' ', display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
        display_external_proc_paths (cmc$disabled_paths, mainframe_element, mainframe_id, element_count,
              lc_element, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF $cmt$display_option[cmc$physical_paths_kw] <= display_option THEN
        put_subheader (cmc$msg_physical_paths, ' ', display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
        display_external_proc_paths (cmc$physical_paths, mainframe_element, mainframe_id, element_count,
              lc_element, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

    END /main_program/;

  PROCEND cmp$display_external_proc;

?? TITLE := '    cmp$display_storage_dev_element', EJECT ??

  PROCEDURE cmp$display_storage_dev_element
    (    mainframe_element: ^cmt$element_definition;
         display_option: cmt$display_option;
         mainframe_id: pmt$mainframe_id;
         element_count: integer;
         lc_element: ^array [1 .. *] of cmt$element_definition;
     VAR display_control: clt$display_control;
     VAR status: ost$status);

    VAR
      element_descriptor: cmt$element_descriptor,
      element_info: array [1 .. 1] of cmt$element_info_item,
      iou_name: cmt$element_name,
      j: 1 .. 26,
      ms_class: cmt$ms_class_members,
      ms_class_info: cmt$ms_class_info,
      ms_class_str: string(1),
      number: integer,
      number_string: string (10),
      product_id: string (10),
      recorded_vsn: rmt$recorded_vsn,
      volume_found: boolean;

    status.normal := TRUE;
    iou_name := 'IOU0';
    recorded_vsn := '';

  /main_program/
    BEGIN
      put_header (cmc$msg_storage_device_element, mainframe_element^.element_name, display_control, status);
      IF NOT status.normal THEN
        EXIT /main_program/;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$element_id_kw] <= display_option) THEN
        product_id (1, 6) := mainframe_element^.product_id.product_number;
        product_id (7, 1) := mainframe_element^.product_id.underscore;
        product_id (8, 3) := mainframe_element^.product_id.model_number;
        put_subheader (cmc$msg_product_id, product_id, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$serial_number_kw] <= display_option) THEN
        put_subheader (cmc$msg_serial_number, mainframe_element^.serial_number, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$state_kw] <= display_option) THEN
        cmp$display_element_state (mainframe_element^.element_name, iou_name, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$recorded_vsn_kw] <= display_option) THEN
        element_info[1].selector := cmc$recorded_vsn;
        element_descriptor.element_type := cmc$storage_device_element;
        element_descriptor.peripheral_descriptor.use_logical_identification := TRUE;
        element_descriptor.peripheral_descriptor.element_name := mainframe_element^.element_name;
        cmp$get_element_information (element_descriptor, element_info, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
        IF element_info[1].item_returned THEN
          recorded_vsn := element_info[1].recorded_vsn;

          clp$horizontal_tab_display (display_control, cmc$starting_subheader_column, status);
          IF NOT status.normal THEN
            EXIT /main_program/;
          IFEND;
          clp$put_partial_display (display_control, 'RECORDED VSN: ', clc$no_trim, amc$continue, status);
          IF NOT status.normal THEN
            EXIT /main_program/;
          IFEND;
          clp$put_partial_display(display_control, recorded_vsn, clc$trim, amc$terminate, status);
          IF NOT status.normal THEN
            EXIT /main_program/;
          IFEND;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$parity_status_kw] <= display_option) THEN

        IF (((mainframe_element^.product_id.product_number = ' $5833') OR
             (mainframe_element^.product_id.product_number = ' $5838') OR
             (mainframe_element^.product_id.product_number = '$47444') OR
             (mainframe_element^.product_id.product_number = ' $5837')) AND
               ((mainframe_element^.product_id.model_number = '1P ') OR
                (mainframe_element^.product_id.model_number = '3P '))) THEN

            cmp$display_parity_status (mainframe_element^.element_name, display_control, status);
            IF NOT status.normal THEN
              EXIT /main_program/;
            IFEND;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$ms_class_kw] <= display_option) THEN
        IF recorded_vsn <> '' THEN
          element_info[1].selector := cmc$recorded_vsn;
          element_descriptor.element_type := cmc$storage_device_element;
          element_descriptor.peripheral_descriptor.use_logical_identification := TRUE;
          element_descriptor.peripheral_descriptor.element_name := mainframe_element^.element_name;
          cmp$get_element_information (element_descriptor, element_info, status);
          IF NOT status.normal THEN
            EXIT /main_program/;
          IFEND;

          IF element_info[1].item_returned THEN
            recorded_vsn := element_info[1].recorded_vsn;
          IFEND;
        IFEND;

        IF recorded_vsn <> '' THEN
          clp$horizontal_tab_display (display_control,cmc$starting_subheader_column, status);
          IF NOT status.normal THEN
            EXIT /main_program/;
          IFEND;
          clp$put_partial_display (display_control, cmc$msg_msclass, clc$no_trim, amc$continue, status);
          IF NOT status.normal THEN
            EXIT /main_program/;
          IFEND;
          cmp$get_ms_class_on_volume (recorded_vsn, volume_found, ms_class_info);
          IF volume_found THEN
            FOR ms_class := LOWERBOUND(ms_class_info.classes) TO UPPERBOUND(ms_class_info.classes) DO
              IF ms_class_info.classes [ms_class] THEN
                ms_class_str(1) := ms_class;
                cmp$display_name(ms_class_str(1), display_control, status);
                IF NOT status.normal THEN
                  EXIT /main_program/;
                IFEND;
              IFEND;
            FOREND;
          IFEND;
          clp$put_partial_display(display_control, ' ', clc$trim, amc$terminate, status);
          IF NOT status.normal THEN
            EXIT /main_program/;
          IFEND;
        ELSEIF NOT status.normal THEN
          status.normal := TRUE; { Go on to display other information }
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$physical_connection_kw] <= display_option) THEN
        number := mainframe_element^.storage_device.physical_unit_number;
        clp$convert_integer_to_rjstring (number, 10, TRUE, ' ', number_string, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
        put_subheader (cmc$msg_unit_number, number_string, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
        cmp$display_upline_connection (mainframe_element^.storage_device.connection.port, display_control,
              status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;
      IF ($cmt$display_option [cmc$all_kw] <= display_option) OR
           ($cmt$display_option [cmc$application_info_kw] <= display_option) THEN
        display_application_info (mainframe_element^, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;
      IF ($cmt$display_option [cmc$all_kw] <= display_option) OR
           ($cmt$display_option [cmc$site_info_kw] <= display_option) THEN
        display_site_info (mainframe_element^, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$connection_status_kw] <= display_option) THEN
        display_conn_status (mainframe_element, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$active_paths_kw] <= display_option) THEN
        put_subheader (cmc$msg_active_paths, ' ', display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
        display_storage_device_paths (cmc$active_paths, mainframe_element, mainframe_id, element_count,
              lc_element, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$inactive_paths_kw] <= display_option) THEN
        put_subheader (cmc$msg_inactive_paths, ' ', display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
        display_storage_device_paths (cmc$inactive_paths, mainframe_element, mainframe_id, element_count,
              lc_element, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF ($cmt$display_option[cmc$all_kw] <= display_option) OR
         ($cmt$display_option[cmc$disabled_paths_kw] <= display_option) THEN
        put_subheader (cmc$msg_disabled_paths, ' ', display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
        display_storage_device_paths (cmc$disabled_paths, mainframe_element, mainframe_id, element_count,
              lc_element, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      IF $cmt$display_option[cmc$physical_paths_kw] <= display_option THEN
        put_subheader (cmc$msg_physical_paths, ' ', display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
        display_storage_device_paths (cmc$physical_paths, mainframe_element, mainframe_id, element_count,
              lc_element, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

    END /main_program/;

  PROCEND cmp$display_storage_dev_element;

?? TITLE := '    cmp$display_element_state', EJECT ??

  PROCEDURE cmp$display_element_state
    (    element_name: cmt$element_name;
         iou_name: cmt$element_name;
     VAR display_control: clt$display_control;
     VAR status: ost$status);

    VAR
      index: integer,
      state: cmt$element_state,
      state_info_array: [STATIC, READ, oss$job_paged_literal] array [cmt$element_state] of
         string (4) := ['ON', 'OFF', 'DOWN'];

    status.normal := TRUE;
    /main_program/
      BEGIN
       cmp$get_element_state (element_name, iou_name, state, status);
       IF NOT status.normal THEN
         EXIT /main_program/;
       IFEND;
       put_subheader (cmc$msg_state_info, state_info_array [state], display_control, status);
       IF NOT status.normal THEN
         EXIT /main_program/;
       IFEND;
      END /main_program/;

  PROCEND cmp$display_element_state;

?? TITLE := '    cmp$display_parity_status', EJECT ??

  PROCEDURE cmp$display_parity_status
    (    element_name: cmt$element_name;
     VAR display_control: clt$display_control;
     VAR status: ost$status);

    CONST
      init_offln_drv_num = 0ff(16);    {NOSVE initialization value for 'off_line_drive_number'.}

    VAR
      off_msg1: [STATIC] string(35) :=' OFF (PHYSICAL UNIT xx IS OFF-LINE)',
      off_msg2: [STATIC] string(36) :=' OFF (PHYSICAL UNIT xx IS RESTORING)',
      parity_status: iot$unit_status,
      parity_status_info: string(39);

    status.normal := TRUE;
    cmp$get_parity_status_info (element_name, parity_status, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    IF parity_status.off_line_drive_number = init_offln_drv_num THEN
      parity_status_info := ' UNKNOWN                               ';
    ELSEIF parity_status.parity_protection_enabled THEN
      parity_status_info := ' ON                                    ';
    ELSE
      IF parity_status.restoring_drive THEN
        parity_status_info := off_msg2;
      ELSE
        parity_status_info := off_msg1;
      IFEND;
      cmp$ascii_decimal (^parity_status_info (21, *), 2, parity_status.
            off_line_drive_number);
    IFEND;
    put_subheader (cmc$msg_parity_status, parity_status_info, display_control, status);
  PROCEND cmp$display_parity_status;

?? TITLE := 'cmp$ascii_decimal', EJECT ??

  PROCEDURE cmp$ascii_decimal (msg: ^string ( * );
        number_of_characters: 1 .. 4;
        word: 0 .. 0ffff(16));

    VAR
      i: integer,
      k: integer,
      divisor: [STATIC] array [1 .. 4] of integer := [1, 10, 100, 1000];


    k := 1;
    FOR i := number_of_characters DOWNTO 1 DO
      msg^ (i) := CHR (((word DIV divisor [k]) MOD 10) + ORD ('0'));
      k := k + 1;
    FOREND;
  PROCEND cmp$ascii_decimal;

?? TITLE := '    cmp$display_upline_connection', EJECT ??

  PROCEDURE cmp$display_upline_connection
    (    upline_connection: array [ * ] of cmt$upline_connection;
     VAR display_control: clt$display_control;
     VAR status: ost$status);

    VAR
      i: integer,
      mainframe_id: pmt$mainframe_id,
      path_name: string (80),
      subtitle_displayed: boolean;

    status.normal := TRUE;
    subtitle_displayed := FALSE;
  /main_program/
    BEGIN
      pmp$get_mainframe_id (mainframe_id, status);
      IF NOT status.normal THEN
        EXIT /main_program/;
      IFEND;
    /loop/
      FOR i := LOWERBOUND (upline_connection) TO UPPERBOUND (upline_connection) DO
        IF upline_connection [i].configured THEN
          IF NOT subtitle_displayed THEN
            clp$horizontal_tab_display (display_control, cmc$starting_subheader_column, status);
            IF NOT status.normal THEN
              EXIT /main_program/;
            IFEND;
            IF upline_connection [i].upline_connection_type = cmc$data_channel_element THEN
              clp$put_partial_display (display_control, cmc$msg_channel_connections, clc$no_trim,
                    amc$continue, status);
            ELSE
              clp$put_partial_display (display_control, cmc$msg_controller_con, clc$no_trim, amc$continue,
                    status);
            IFEND;
            IF NOT status.normal THEN
              EXIT /main_program/;
            IFEND;
            subtitle_displayed := TRUE;
          IFEND;
          path_name := '  ';
          IF upline_connection [i].upline_connection_type = cmc$data_channel_element THEN
            path_name (1, 4) := upline_connection [i].iou;
            path_name (5, 1) := '/';
            path_name (6, *) := upline_connection [i].element_name;
          ELSE
            path_name (1, *) := upline_connection [i].element_name;
          IFEND;
          IF (upline_connection [i].upline_connection_type = cmc$data_channel_element) AND
             (upline_connection [i].mainframe_ownership <> mainframe_id) THEN
            CYCLE /loop/;
          IFEND;
          cmp$display_name (path_name, display_control, status);
          IF NOT status.normal THEN
            EXIT /main_program/;
          IFEND;
        IFEND;
      FOREND /loop/;

      clp$new_display_line (display_control, 0, status);
      IF NOT status.normal THEN
        EXIT /main_program/;
      IFEND;

    END /main_program/;

  PROCEND cmp$display_upline_connection;

?? TITLE := '    cmp$display_ca_upline_conn', EJECT ??

  PROCEDURE cmp$display_ca_upline_conn
    (    upline_connection: cmt$upline_connection;
     VAR display_control: clt$display_control;
     VAR status: ost$status);

    VAR
      path_name: string (80);

    status.normal := TRUE;

  /main_program/

    BEGIN

      IF upline_connection.configured THEN
        path_name := '  ';
        path_name (1, 4) := upline_connection.iou;
        path_name (5, 1) := '/';
        path_name (6, *) := upline_connection.element_name;
        cmp$display_name (path_name, display_control, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
      IFEND;

      clp$new_display_line (display_control, 0, status);
      IF NOT status.normal THEN
        EXIT /main_program/;
      IFEND;

    END /main_program/;

  PROCEND cmp$display_ca_upline_conn;

?? TITLE := '    cmp$display_element_connection', EJECT ??

  PROCEDURE cmp$display_element_connection
    (    element_connection: array [ * ] of cmt$element_connection;
     VAR display_control: clt$display_control;
     VAR status: ost$status);

    VAR
      i: integer;

    status.normal := TRUE;

  /main_program/
    BEGIN

      FOR i := LOWERBOUND (element_connection) TO UPPERBOUND
            (element_connection) DO
        IF element_connection [i].configured THEN
          cmp$display_name (element_connection [i].element_name, display_control, status);
          IF NOT status.normal THEN
            EXIT /main_program/;
          IFEND;
        IFEND;
      FOREND;

      clp$new_display_line (display_control, 0, status);
      IF NOT status.normal THEN
        EXIT /main_program/;
      IFEND;

    END /main_program/;

  PROCEND cmp$display_element_connection;

?? TITLE := '    cmp$display_name', EJECT ??

  PROCEDURE cmp$display_name
    (    message: string ( * );
     VAR display_control: clt$display_control;
     VAR status: ost$status);

    VAR
      column_number: amt$page_width,
      i: integer,
      message_length: integer;

    status.normal := TRUE;

  /main_program/
    BEGIN

      message_length := STRLENGTH (message);

    /forloop/
      FOR i := 1 TO message_length DO
        IF message (i, 1) = ' ' THEN
          message_length := i - 1;
          EXIT /forloop/;
        IFEND;
      FOREND /forloop/;

      IF display_control.page_width < display_control.column_number +
            cmc$spacing + message_length THEN
        clp$new_display_line (display_control, 0, status);
        IF NOT status.normal THEN
          EXIT /main_program/;
        IFEND;
        column_number := cmc$starting_name_column;
      ELSE
        column_number := display_control.column_number + cmc$spacing;
      IFEND;

      clp$horizontal_tab_display (display_control, column_number, status);
      IF NOT status.normal THEN
        EXIT /main_program/;
      IFEND;

      clp$put_partial_display (display_control, message, clc$trim, amc$continue, status);
      IF NOT status.normal THEN
        EXIT /main_program/;
      IFEND;

    END /main_program/;
  PROCEND cmp$display_name;

?? TITLE := '    determine_active_path', EJECT ??

  PROCEDURE determine_active_path
    (    channel_p: ^cmt$element_definition;
         downline_1_p: ^cmt$element_definition;
         downline_2_p: ^cmt$element_definition;
     VAR active: boolean;
     VAR disabled: boolean;
     VAR status: ost$status);

    VAR
      connection_status: cmt$connection_status,
      element_descriptor: cmt$element_descriptor;

    status.normal := TRUE;
    active := FALSE;
    disabled := FALSE;

    IF channel_p = NIL THEN
      RETURN;
    IFEND;

    IF channel_p^.element_type <> cmc$data_channel_element THEN
      RETURN;
    IFEND;

    cmp$get_driver_state (channel_p^.element_name, channel_p^.data_channel.iou, active, status);
    IF (NOT status.normal) OR (NOT active) THEN
      RETURN;
    IFEND;
    active := FALSE;

    IF downline_1_p = NIL THEN
      RETURN;
    IFEND;

    element_descriptor.element_type := channel_p^.element_type;
    element_descriptor.channel_descriptor.iou := channel_p^.data_channel.iou;
    element_descriptor.channel_descriptor.use_logical_identification := TRUE;
    element_descriptor.channel_descriptor.name := channel_p^.element_name;

    cmp$get_connection_status (element_descriptor, downline_1_p^.element_name, connection_status, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    CASE connection_status OF
    = cmc$active =
      active := TRUE;
    = cmc$inactive =

    = cmc$disabled =
      disabled := TRUE;
    CASEND;

    IF NOT active THEN
      RETURN;
    IFEND;

    IF downline_2_p <> NIL THEN
      element_descriptor.element_type := downline_1_p^.element_type;
      element_descriptor.peripheral_descriptor.use_logical_identification := TRUE;
      element_descriptor.peripheral_descriptor.element_name := downline_1_p^.element_name;

      cmp$get_connection_status (element_descriptor, downline_2_p^.element_name, connection_status, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      CASE connection_status OF
      = cmc$active =
        active := TRUE;
      = cmc$inactive =
        active := FALSE;
      = cmc$disabled =
        active := FALSE;
        disabled := TRUE;
      CASEND;

      IF NOT active THEN
        RETURN;
      IFEND;

      IF cmp$support_redundant_access (downline_1_p^.element_type, downline_1_p^.product_id) THEN
        cmp$determine_active_path (channel_p^, downline_1_p^, downline_2_p^, active, status);
        IF (NOT status.normal) OR (NOT active) THEN
          RETURN;
        IFEND;
      IFEND;
    IFEND;

  PROCEND determine_active_path;

?? TITLE := '    display_application_info', EJECT ??

  PROCEDURE display_application_info
    (    element: cmt$element_definition;
     VAR display_control: clt$display_control;
     VAR status: ost$status);

    VAR
      element_descriptor: cmt$element_descriptor,
      element_info: array [1 .. 1] of cmt$element_info_item,
      ignore: ost$status,
      string_p: ^string ( * );

    status.normal := TRUE;
    element_descriptor.element_type := element.element_type;
    element_descriptor.peripheral_descriptor.use_logical_identification := TRUE;
    element_descriptor.peripheral_descriptor.element_name := element.element_name;
    element_info [1].selector := cmc$application_string_size;
    cmp$get_element_information (element_descriptor, element_info, ignore);
    IF NOT ignore.normal THEN
      RETURN;
    IFEND;
    IF element_info [1].item_returned THEN
      IF element_info [1].application_info_string_size > 0 THEN
        PUSH string_p: [element_info [1].application_info_string_size];
        element_info [1].selector := cmc$application_information;
        element_info [1].application_information := string_p;
        cmp$get_element_information (element_descriptor, element_info, ignore);
        IF NOT ignore.normal THEN
          RETURN;
        IFEND;
        IF element_info [1].item_returned THEN
          put_subheader (cmc$msg_application_info, element_info [1].application_information^,
               display_control, status);
          IF NOT status.normal THEN
            RETURN;
          IFEND;
        IFEND;
      IFEND;
    IFEND;
  PROCEND display_application_info;

?? TITLE := '    display_site_info', EJECT ??

  PROCEDURE display_site_info
    (    element: cmt$element_definition;
     VAR display_control: clt$display_control;
     VAR status: ost$status);

    VAR
      element_descriptor: cmt$element_descriptor,
      element_info: array [1 .. 1] of cmt$element_info_item,
      ignore: ost$status,
      string_p: ^string ( * );

    status.normal := TRUE;
    element_descriptor.element_type := element.element_type;
    element_descriptor.peripheral_descriptor.use_logical_identification := TRUE;
    element_descriptor.peripheral_descriptor.element_name := element.element_name;
    element_info [1].selector := cmc$site_info_string_size;
    cmp$get_element_information (element_descriptor, element_info, ignore);
    IF NOT ignore.normal THEN
      RETURN;
    IFEND;
    IF element_info [1].item_returned THEN
      IF element_info [1].site_info_string_size > 0 THEN
        PUSH string_p: [element_info [1].site_info_string_size];
        element_info [1].selector := cmc$site_information;
        element_info [1].site_information := string_p;
        cmp$get_element_information (element_descriptor, element_info, ignore);
        IF NOT ignore.normal THEN
          RETURN;
        IFEND;
        IF element_info [1].item_returned THEN
          put_subheader (cmc$msg_site_info, element_info [1].site_information^, display_control
                     ,status);
          IF NOT status.normal THEN
            RETURN;
          IFEND;
        IFEND;
      IFEND;
    IFEND;
  PROCEND display_site_info;
?? TITLE := '    display_ca_paths', EJECT ??

  PROCEDURE display_ca_paths
    (    path_option: cmt$path_types;
         mainframe_element: ^cmt$element_definition;
         mainframe_id: pmt$mainframe_id;
         element_count: integer;
         lc_element: ^array [1 .. *] of cmt$element_definition;
     VAR display_control: clt$display_control;
     VAR status: ost$status);

    VAR
      downline_element: ^cmt$element_definition,
      downline_element_found: boolean,
      i: integer,
      path_found: boolean,
      upline_element: ^cmt$element_definition;

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

    IF (mainframe_element^.channel_adapter.connection.channel.configured) AND
            (mainframe_element^.channel_adapter.connection.channel.mainframe_ownership = mainframe_id) THEN
      find_named_element (mainframe_element^.channel_adapter.connection.channel.element_name,
              mainframe_id, mainframe_element^.channel_adapter.connection.channel.iou, element_count,
              lc_element, upline_element, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      downline_element_found := FALSE;
      FOR i := LOWERBOUND (mainframe_element^.channel_adapter.connection.equipment) TO
              UPPERBOUND (mainframe_element^.channel_adapter.connection.equipment) DO
        IF mainframe_element^.channel_adapter.connection.equipment [i].configured THEN
          find_named_element (mainframe_element^.channel_adapter.connection.equipment [i].
                element_name, mainframe_id, upline_element^.data_channel.iou, element_count,
                lc_element, downline_element, status);
          IF NOT status.normal THEN
            RETURN;
          IFEND;
          downline_element_found := TRUE;
          display_path_status (path_option, upline_element, mainframe_element, downline_element,
                path_found, display_control, status);
          IF NOT status.normal THEN
            RETURN;
          IFEND;
        IFEND;
      FOREND;
      IF NOT downline_element_found THEN
        display_path_status (path_option, upline_element, mainframe_element, NIL, path_found,
               display_control, status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;
      IFEND;
    IFEND;

    IF NOT path_found THEN
      put_subheader ('  NONE', ' ', display_control, status);
    IFEND;

  PROCEND display_ca_paths;

?? TITLE := '    display_channel_paths', EJECT ??

  PROCEDURE display_channel_paths
    (    path_option: cmt$path_types;
         mainframe_element: ^cmt$element_definition;
         mainframe_id: pmt$mainframe_id;
         element_count: integer;
         lc_element: ^array [1 .. *] of cmt$element_definition;
     VAR display_control: clt$display_control;
     VAR status: ost$status);

    VAR
      downline_element_1: ^cmt$element_definition,
      downline_element_2: ^cmt$element_definition,
      i: integer,
      j: integer,
      path_found: boolean;

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

    FOR i := LOWERBOUND (mainframe_element^.data_channel.connection.equipment) TO
          UPPERBOUND (mainframe_element^.data_channel.connection.equipment) DO
      IF mainframe_element^.data_channel.connection.equipment [i].configured THEN
        find_named_element (mainframe_element^.data_channel.connection.equipment [i].element_name,
              mainframe_id, mainframe_element^.data_channel.iou, element_count, lc_element,
              downline_element_1, status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;
        CASE downline_element_1^.element_type OF
        = cmc$controller_element =
          FOR j := LOWERBOUND (downline_element_1^.controller.connection.unit) TO
                UPPERBOUND (downline_element_1^.controller.connection.unit) DO
            IF downline_element_1^.controller.connection.unit [j].configured THEN
              find_named_element (downline_element_1^.controller.connection.unit [j].element_name,
                    mainframe_id, mainframe_element^.data_channel.iou, element_count, lc_element,
                    downline_element_2, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              display_path_status (path_option, mainframe_element, downline_element_1, downline_element_2,
                    path_found, display_control, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          FOREND;
        = cmc$channel_adapter_element =
          FOR j := LOWERBOUND (downline_element_1^.channel_adapter.connection.equipment) TO
                UPPERBOUND (downline_element_1^.channel_adapter.connection.equipment) DO
            IF downline_element_1^.channel_adapter.connection.equipment [j].configured THEN
              find_named_element (downline_element_1^.channel_adapter.connection.equipment [j].
                    element_name, mainframe_id, mainframe_element^.data_channel.iou, element_count,
                    lc_element, downline_element_2, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              display_path_status (path_option, mainframe_element, downline_element_1, downline_element_2,
                    path_found, display_control, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          FOREND;
        ELSE
          display_path_status (path_option, mainframe_element, downline_element_1, NIL, path_found,
                display_control, status);
          IF NOT status.normal THEN
            RETURN;
          IFEND;
        CASEND;
      IFEND;
    FOREND;

    IF NOT path_found THEN
      put_subheader ('  NONE', ' ', display_control, status);
    IFEND;

  PROCEND display_channel_paths;

?? TITLE := '    display_comm_paths', EJECT ??

  PROCEDURE display_comm_paths
    (    path_option: cmt$path_types;
         mainframe_element: ^cmt$element_definition;
         mainframe_id: pmt$mainframe_id;
         element_count: integer;
         lc_element: ^array [1 .. *] of cmt$element_definition;
     VAR display_control: clt$display_control;
     VAR status: ost$status);

    VAR
      i: integer,
      path_found: boolean,
      upline_element: ^cmt$element_definition;

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

    FOR i := LOWERBOUND (mainframe_element^.communications_element.connection.port) TO
          UPPERBOUND (mainframe_element^.communications_element.connection.port) DO
      IF (mainframe_element^.communications_element.connection.port [i].configured) AND
            (mainframe_element^.communications_element.connection.port [i].mainframe_ownership =
            mainframe_id) THEN
        find_named_element (mainframe_element^.communications_element.connection.port [i].element_name,
              mainframe_id, mainframe_element^.communications_element.connection.port [i].iou,
              element_count, lc_element, upline_element, status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;
        display_path_status (path_option, upline_element, mainframe_element, NIL, path_found, display_control,
              status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;
      IFEND;
    FOREND;

    IF NOT path_found THEN
      put_subheader ('  NONE', ' ', display_control, status);
    IFEND;

  PROCEND display_comm_paths;

?? TITLE := '    display_conn_status', EJECT ??

  PROCEDURE display_conn_status
    (    mainframe_element: ^cmt$element_definition;
     VAR display_control: clt$display_control;
     VAR status: ost$status);

    VAR
      connection: cmt$connection,
      connection_count: integer,
      connection_list: ^array [1 .. * ] of cmt$connection,
      i: integer;

    status.normal := TRUE;

    put_subheader (cmc$msg_connection_status, ' ', display_control, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$horizontal_tab_display (display_control, cmc$upline_connection_column, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$put_partial_display (display_control, cmc$msg_upline_element, clc$trim, amc$continue, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$horizontal_tab_display (display_control, cmc$connection_status_column, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$put_partial_display (display_control, cmc$msg_connect_status_header, clc$trim, amc$continue, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$horizontal_tab_display (display_control, cmc$downline_connection_column, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$put_partial_display (display_control, cmc$msg_downline_element, clc$trim, amc$terminate, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    connection_count := 16;
    REPEAT
      PUSH connection_list: [1 .. connection_count];
      cmp$get_connection_list (mainframe_element^, connection_count, connection_list, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
    UNTIL connection_count <= UPPERBOUND (connection_list^);

    FOR i := 1 TO connection_count DO
      connection := connection_list^ [i];

      clp$horizontal_tab_display (display_control, cmc$upline_connection_column, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$put_partial_display (display_control, connection.upline_element, clc$trim, amc$continue, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$horizontal_tab_display (display_control, cmc$connection_status_column, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      CASE connection.status OF
      = cmc$active =
        clp$put_partial_display (display_control, 'ACTIVE', clc$trim, amc$continue, status);
      = cmc$inactive =
        clp$put_partial_display (display_control, 'INACTIVE', clc$trim, amc$continue, status);
      = cmc$disabled =
        clp$put_partial_display (display_control, 'DISABLED', clc$trim, amc$continue, status);
      CASEND;
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$horizontal_tab_display (display_control, cmc$downline_connection_column, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$put_partial_display (display_control, connection.downline_element, clc$trim, amc$terminate, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
    FOREND;

  PROCEND display_conn_status;

?? TITLE := '    display_controller_paths', EJECT ??

  PROCEDURE display_controller_paths
    (    path_option: cmt$path_types;
         mainframe_element: ^cmt$element_definition;
         mainframe_id: pmt$mainframe_id;
         element_count: integer;
         lc_element: ^array [1 .. *] of cmt$element_definition;
     VAR display_control: clt$display_control;
     VAR status: ost$status);

    VAR
      downline_element: ^cmt$element_definition,
      i: integer,
      j: integer,
      path_found: boolean,
      upline_element: ^cmt$element_definition;

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

    FOR i := LOWERBOUND (mainframe_element^.controller.connection.port) TO
          UPPERBOUND (mainframe_element^.controller.connection.port) DO
      IF (mainframe_element^.controller.connection.port [i].configured) AND
            (mainframe_element^.controller.connection.port [i].mainframe_ownership = mainframe_id) THEN
        find_named_element (mainframe_element^.controller.connection.port [i].element_name,
              mainframe_id, mainframe_element^.controller.connection.port [i].iou, element_count,
              lc_element, upline_element, status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;
        FOR j := LOWERBOUND (mainframe_element^.controller.connection.unit) TO
              UPPERBOUND (mainframe_element^.controller.connection.unit) DO
          IF mainframe_element^.controller.connection.unit [j].configured THEN
            find_named_element (mainframe_element^.controller.connection.unit [j].element_name,
                  mainframe_id, upline_element^.data_channel.iou, element_count, lc_element,
                  downline_element, status);
            IF NOT status.normal THEN
              RETURN;
            IFEND;
            display_path_status (path_option, upline_element, mainframe_element, downline_element, path_found,
                  display_control, status);
            IF NOT status.normal THEN
              RETURN;
            IFEND;
          IFEND;
        FOREND;
      IFEND;
    FOREND;

    IF NOT path_found THEN
      put_subheader ('  NONE', ' ', display_control, status);
    IFEND;

  PROCEND display_controller_paths;

?? TITLE := '    display_external_proc_paths', EJECT ??

  PROCEDURE display_external_proc_paths
    (    path_option: cmt$path_types;
         mainframe_element: ^cmt$element_definition;
         mainframe_id: pmt$mainframe_id;
         element_count: integer;
         lc_element: ^array [1 .. *] of cmt$element_definition;
     VAR display_control: clt$display_control;
     VAR status: ost$status);

    VAR
      i: integer,
      path_found: boolean,
      upline_element: ^cmt$element_definition;

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

    FOR i := LOWERBOUND (mainframe_element^.external_processor.connection.io_port) TO
          UPPERBOUND (mainframe_element^.external_processor.connection.io_port) DO
      IF (mainframe_element^.external_processor.connection.io_port [i].configured) AND
            (mainframe_element^.external_processor.connection.io_port [i].mainframe_ownership =
            mainframe_id) THEN
        find_named_element (mainframe_element^.external_processor.connection.io_port [i].element_name,
              mainframe_id, mainframe_element^.external_processor.connection.io_port [i].iou,
              element_count, lc_element, upline_element, status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;
        display_path_status (path_option, upline_element, mainframe_element, NIL, path_found, display_control,
              status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;
      IFEND;
    FOREND;

    IF NOT path_found THEN
      put_subheader ('  NONE', ' ', display_control, status);
    IFEND;

  PROCEND display_external_proc_paths;

?? TITLE := '    display_path_status', EJECT ??

  PROCEDURE display_path_status
    (    path_option: cmt$path_types;
         channel_element: ^cmt$element_definition;
         downline_element_1: ^cmt$element_definition;
         downline_element_2: ^cmt$element_definition;
     VAR path_found: boolean;
     VAR display_control: clt$display_control;
     VAR status: ost$status);

    VAR
      active_path: boolean,
      address_string: ost$string,
      disabled_path: boolean;

    status.normal := TRUE;

    determine_active_path (channel_element, downline_element_1, downline_element_2, active_path,
          disabled_path, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    CASE path_option OF
    = cmc$active_paths =
      IF NOT active_path THEN
        RETURN;
      IFEND;
    = cmc$inactive_paths =
      IF active_path OR disabled_path THEN
        RETURN;
      IFEND;
    = cmc$disabled_paths =
      IF NOT disabled_path THEN
        RETURN;
      IFEND;
    ELSE
    CASEND;

    path_found := TRUE;

    clp$horizontal_tab_display (display_control, cmc$starting_subheader_column + 2, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$put_partial_display (display_control, channel_element^.data_channel.iou, clc$trim, amc$continue,
          status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$put_partial_display (display_control, '.', clc$trim, amc$continue, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$put_partial_display (display_control, channel_element^.element_name, clc$trim, amc$continue, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$put_partial_display (display_control, '.', clc$trim, amc$continue, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$put_partial_display (display_control, downline_element_1^.element_name, clc$trim, amc$continue,
          status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    IF downline_element_2 <> NIL THEN
      clp$put_partial_display (display_control, '.', clc$trim, amc$continue, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$put_partial_display (display_control, downline_element_2^.element_name, clc$trim, amc$continue,
            status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
    IFEND;

    clp$horizontal_tab_display (display_control, cmc$status_column, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$put_partial_display (display_control, channel_element^.data_channel.iou, clc$trim, amc$continue,
          status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$put_partial_display (display_control, '.', clc$trim, amc$continue, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$put_partial_display (display_control, channel_element^.element_name, clc$trim, amc$continue, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    CASE downline_element_1^.element_type OF

    = cmc$channel_adapter_element =
      clp$put_partial_display (display_control, '.C', clc$trim, amc$continue, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      clp$convert_integer_to_string (downline_element_1^.channel_adapter.physical_equipment_number, 10, FALSE,
            address_string, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      clp$put_partial_display (display_control, address_string.value, clc$trim, amc$terminate, status);

    = cmc$communications_element =
      clp$put_partial_display (display_control, '.C', clc$trim, amc$continue, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      clp$convert_integer_to_string (downline_element_1^.communications_element.physical_equipment_number,
            10, FALSE, address_string, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      clp$put_partial_display (display_control, address_string.value, clc$trim, amc$terminate, status);

    = cmc$controller_element =
      clp$put_partial_display (display_control, '.C', clc$trim, amc$continue, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      clp$convert_integer_to_string (downline_element_1^.controller.physical_equipment_number, 10, FALSE,
            address_string, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      clp$put_partial_display (display_control, address_string.value, clc$trim, amc$continue, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      clp$put_partial_display (display_control, '.U', clc$trim, amc$continue, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      clp$convert_integer_to_string (downline_element_2^.storage_device.physical_unit_number, 10, FALSE,
            address_string, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      clp$put_partial_display (display_control, address_string.value, clc$trim, amc$terminate, status);

    = cmc$storage_device_element =
      clp$put_partial_display (display_control, '.U', clc$trim, amc$continue, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      clp$convert_integer_to_string (downline_element_1^.storage_device.physical_unit_number, 10, FALSE,
            address_string, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      clp$put_partial_display (display_control, address_string.value, clc$trim, amc$terminate, status);

    = cmc$external_processor_element =
      clp$put_partial_display (display_control, '.C', clc$trim, amc$continue, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      clp$convert_integer_to_string (downline_element_1^.external_processor.physical_equipment_number,
            10, FALSE, address_string, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      clp$put_partial_display (display_control, address_string.value, clc$trim, amc$terminate, status);
    CASEND;
    IF NOT status.normal THEN
      RETURN;
    IFEND;

  PROCEND display_path_status;

?? TITLE := '    display_storage_device_paths', EJECT ??

  PROCEDURE display_storage_device_paths
    (    path_option: cmt$path_types;
         mainframe_element: ^cmt$element_definition;
         mainframe_id: pmt$mainframe_id;
         element_count: integer;
         lc_element: ^array [1 .. *] of cmt$element_definition;
     VAR display_control: clt$display_control;
     VAR status: ost$status);

    VAR
      i: integer,
      j: integer,
      path_found: boolean,
      upline_element_1: ^cmt$element_definition,
      upline_element_2: ^cmt$element_definition;

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

    FOR i := LOWERBOUND (mainframe_element^.storage_device.connection.port) TO
          UPPERBOUND (mainframe_element^.storage_device.connection.port) DO
      IF mainframe_element^.storage_device.connection.port [i].configured THEN
        CASE mainframe_element^.storage_device.connection.port [i].upline_connection_type OF
        = cmc$data_channel_element =
          IF mainframe_element^.storage_device.connection.port [i].mainframe_ownership = mainframe_id THEN
            find_named_element (mainframe_element^.storage_device.connection.port [i].element_name,
                  mainframe_id, mainframe_element^.storage_device.connection.port [i].iou, element_count,
                  lc_element, upline_element_1, status);
            IF NOT status.normal THEN
              RETURN;
            IFEND;
            display_path_status (path_option, upline_element_1, mainframe_element, NIL, path_found,
                  display_control, status);
            IF NOT status.normal THEN
              RETURN;
            IFEND;
          IFEND;
        = cmc$controller_element =
          find_named_element (mainframe_element^.storage_device.connection.port [i].element_name,
                mainframe_id, mainframe_element^.storage_device.connection.port [i].iou, element_count,
                lc_element, upline_element_1, status);
          IF NOT status.normal THEN
            RETURN;
          IFEND;
          FOR j := LOWERBOUND (upline_element_1^.controller.connection.port) TO
                UPPERBOUND (upline_element_1^.controller.connection.port) DO
            IF (upline_element_1^.controller.connection.port [j].configured) AND
                  (upline_element_1^.controller.connection.port [j].mainframe_ownership = mainframe_id) THEN
              find_named_element (upline_element_1^.controller.connection.port [j].element_name,
                    mainframe_id, upline_element_1^.controller.connection.port [j].iou, element_count,
                    lc_element, upline_element_2, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              display_path_status (path_option, upline_element_2, upline_element_1, mainframe_element,
                    path_found, display_control, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          FOREND;
        CASEND;
      IFEND;
    FOREND;

    IF NOT path_found THEN
      put_subheader ('  NONE', ' ', display_control, status);
    IFEND;

  PROCEND display_storage_device_paths;

?? TITLE := '    find_named_element', EJECT ??

  PROCEDURE find_named_element
    (    name: cmt$element_name;
         mainframe_id: pmt$mainframe_id;
         iou: cmt$element_name;
         element_count: integer;
         lc_element: ^array [1 .. *] of cmt$element_definition;
     VAR element: ^cmt$element_definition;
     VAR status: ost$status);

    VAR
      i: integer;

    status.normal := TRUE;

    FOR i := 1 TO element_count DO
      IF lc_element^ [i].element_type = cmc$data_channel_element THEN
        IF (lc_element^ [i].element_name = name) AND (lc_element^ [i].data_channel.iou = iou) AND
              (lc_element^ [i].data_channel.mainframe_ownership = mainframe_id) THEN
          element := ^lc_element^ [i];
          RETURN;
        IFEND;
      ELSE
        IF lc_element^ [i].element_name = name THEN
          element := ^lc_element^ [i];
          RETURN;
        IFEND;
      IFEND;
    FOREND;

    osp$set_status_abnormal (cmc$configuration_management_id, cme$lcm_element_not_found, name, status);

  PROCEND find_named_element;

?? TITLE := '    put_header', EJECT ??

  PROCEDURE put_header
    (    descriptor: string ( * );
         value: string ( * );
     VAR display_control: clt$display_control;
     VAR status: ost$status);

    status.normal := TRUE;

    clp$new_display_line (display_control, 1, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$horizontal_tab_display (display_control, cmc$starting_element_column, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$put_partial_display (display_control, descriptor, clc$no_trim, amc$continue, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$put_partial_display (display_control, value, clc$trim, amc$terminate, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

  PROCEND put_header;

?? TITLE := '    put_subheader', EJECT ??

  PROCEDURE put_subheader
    (    descriptor: string ( * );
         value: string ( * );
     VAR display_control: clt$display_control;
     VAR status: ost$status);

    status.normal := TRUE;

    clp$horizontal_tab_display (display_control, cmc$starting_subheader_column, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$put_partial_display (display_control, descriptor, clc$no_trim, amc$continue, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$put_partial_display (display_control, value, clc$trim, amc$terminate, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

  PROCEND put_subheader;

MODEND cmm$logical_configuration_mgr;
