?? RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE Device Management' ??
MODULE dmm$display_device_files_r3;

{
{ PURPOSE:
{
{  The purpose of this module is to display information from tables contained
{  in device management owned device files.  This includes the Device
{  Allocation Table (DAT), Device File List (DFL), Volume Directory, Volume
{  Label, Device Log, and Login Table.


?? NEWTITLE := '  Global Declarations Referenced by this module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc oss$job_paged_literal
*copyc cyd$cybil_structure_definitions
*copyc osd$integer_limits
*copyc dmt$device_file_list_index
*copyc dmt$device_file_stored_fmd
*copyc dmt$directory_index
*copyc dmt$disk_file_descriptor
*copyc dmt$error_condition_codes
*copyc dmt$file_allocation_table
*copyc dmt$file_medium_descriptor
*copyc dmt$ms_device_allocation_table
*copyc dmt$ms_device_file_list_entry
*copyc dmt$ms_volume_directory
*copyc dmt$ms_volume_label
*copyc dmt$stored_ms_fmd_header
*copyc gft$file_desc_entry_p
*copyc ost$status
*copyc ofe$error_codes
?? POP ??
*copyc avp$system_administrator
*copyc clp$convert_integer_to_rjstring
*copyc clp$convert_integer_to_string
*copyc clp$new_display_line
*copyc clp$new_display_page
*copyc clp$put_display
*copyc clp$put_partial_display
*copyc dmp$analyze_dat_position
*copyc dmp$attach_device_file
*copyc dmp$change_dfl_damage
*copyc dmp$change_sft_damage_detection
*copyc dmp$change_sft_file_damaged
*copyc dmp$close_dat_r3
*copyc dmp$close_dfl_r3
*copyc dmp$close_directory_r3
*copyc dmp$close_file
*copyc dmp$close_label_r3
*copyc dmp$close_log_r3
*copyc dmp$close_login_table_r3
*copyc dmp$detach_device_file
*copyc dmp$get_disk_file_descriptor_p
*copyc dmp$get_fmd_by_index
*copyc dmp$open_dat_r3
*copyc dmp$open_dfl_r3
*copyc dmp$open_directory_r3
*copyc dmp$open_file
*copyc dmp$open_label_r3
*copyc dmp$open_log_r3
*copyc dmp$open_login_table_r3
*copyc dmp$reassign_file
*copyc dmp$utility_flush_logs
*copyc gfp$get_fde_p
*copyc mmp$get_sdtx_entry_p
*copyc mmp$get_segment_length
*copyc mmp$mfh_for_segment_manager
*copyc osp$establish_condition_handler
*copyc osp$set_status_abnormal
*copyc osp$set_status_from_condition
*copyc pmp$continue_to_cause
*copyc pmp$convert_binary_unique_name
*copyc pmp$find_executing_task_xcb
*copyc pmp$get_legible_date_time
*copyc i#move

    CONST
      contiguous_dau_range_array_size = 7;

    TYPE
      contiguous_dau_info = record
        low: integer,
        high: integer,
        occurrences: integer,
        total_daus: integer,
      recend;

?? TITLE := '  dmp$change_file_damage_r3', EJECT ??

  PROCEDURE [XDCL, #GATE] dmp$change_file_damage_r3
    (    p: ^cell;
         damage: boolean;
         damage_detection: boolean;
         dfl_damage: boolean;
     VAR status: ost$status);

     VAR
       p_dfd: ^dmt$disk_file_descriptor,
       p_fde: gft$file_desc_entry_p,
       p_fmd: ^dmt$file_medium_descriptor,
       sdtxe_p: ^mmt$segment_descriptor_extended,
       system_file_id: gft$system_file_identifier,
       xcb_p: ^ost$execution_control_block;

    pmp$find_executing_task_xcb (xcb_p);
    sdtxe_p := mmp$get_sdtx_entry_p (xcb_p, #SEGMENT(p));
    system_file_id := sdtxe_p^.sfid;

    gfp$get_fde_p (system_file_id, p_fde);
    IF p_fde = NIL THEN
      RETURN;
    IFEND;
    dmp$get_disk_file_descriptor_p (p_fde, p_dfd);
    dmp$get_fmd_by_index (p_dfd, 1, p_fmd);
    IF (p_fmd <> NIL) AND (p_fmd^.in_use) THEN
      dmp$change_sft_file_damaged (system_file_id, damage, p_fde^.global_file_name, status);
      dmp$change_sft_damage_detection (system_file_id, damage_detection, p_fde^.global_file_name, status);
      IF dfl_damage THEN
        dmp$change_dfl_damage (p_fmd^.avt_index, $dmt$file_damage [dmc$media_image_inconsistent],
              $dmt$file_damage [], p_fmd^.dfl_index, TRUE, p_fde^.global_file_name, status);
      ELSE
        dmp$change_dfl_damage (p_fmd^.avt_index, $dmt$file_damage [],
              $dmt$file_damage [dmc$media_image_inconsistent], p_fmd^.dfl_index, FALSE,
              p_fde^.global_file_name, status);
      IFEND;
    IFEND;

  PROCEND dmp$change_file_damage_r3;
?? TITLE := '  dmp$copy_dat', EJECT ??

  PROCEDURE [XDCL, #GATE] dmp$copy_dat
    (    recorded_vsn: rmt$recorded_vsn;
         p_output_file: ^cell;
     VAR status: ost$status);

    VAR
      p_dat: ^dmt$ms_device_allocation_table;

?? NEWTITLE := 'DAT_HANDLER', EJECT ??

    PROCEDURE dat_handler
     (    condition: pmt$condition;
          condition_information: ^pmt$condition_information;
          save_area: ^ost$stack_frame_save_area;
      VAR handler_status: ost$status);

      VAR
        local_status: ost$status;

      IF condition.selector = pmc$user_defined_condition THEN
        pmp$continue_to_cause (pmc$execute_standard_procedure, handler_status);
        RETURN;
      IFEND;

      osp$set_status_from_condition (dmc$device_manager_ident, condition, save_area, status, handler_status);

      IF NOT handler_status.normal THEN
        status := handler_status;
      IFEND;

      dmp$close_dat_r3 (p_dat, local_status);

      EXIT dmp$copy_dat;

    PROCEND dat_handler;
?? OLDTITLE ??
?? EJECT ??

    dmp$open_dat_r3 (recorded_vsn, p_dat, status);

    IF status.normal THEN
      osp$establish_condition_handler (^dat_handler, FALSE);
      i#move (p_dat, p_output_file, #SIZE (p_dat^));
      dmp$close_dat_r3 (p_dat, status)
    IFEND;

  PROCEND dmp$copy_dat;

?? TITLE := '  dmp$copy_device_file', EJECT ??

  PROCEDURE [XDCL, #GATE] dmp$copy_device_file
    (    recorded_vsn: rmt$recorded_vsn;
         file_name: ost$name;
         output_p: ^cell;
     VAR status: ost$status);

    VAR
      ignore: boolean,
      segment_pointer: mmt$segment_pointer,
      seq_pointer: ^ost$sequence_pointer,
      system_file_id: gft$system_file_identifier;

?? NEWTITLE := 'COPY_HANDLER', EJECT ??

    PROCEDURE copy_handler
      (    condition: pmt$condition;
           condition_information: ^pmt$condition_information;
           save_area: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      VAR
        local_status: ost$status;

      IF condition.selector = pmc$user_defined_condition THEN
        pmp$continue_to_cause (pmc$execute_standard_procedure, handler_status);
        RETURN; {----->
      IFEND;

      osp$set_status_from_condition (dmc$device_manager_ident, condition, save_area, status, handler_status);

      IF NOT handler_status.normal THEN
        status := handler_status;
      IFEND;

      #SPOIL (segment_pointer);
      IF segment_pointer.seq_pointer <> NIL THEN
        dmp$close_file (segment_pointer.seq_pointer, status);
        segment_pointer.seq_pointer := NIL;
        #SPOIL (segment_pointer);
      IFEND;

      dmp$detach_device_file (system_file_id, ignore, ignore, local_status);
      EXIT dmp$copy_device_file; {----->

    PROCEND copy_handler;
?? OLDTITLE ??
?? EJECT ??
    IF NOT avp$system_administrator () THEN
      osp$set_status_abnormal ('OS', ofe$sou_not_active, 'system_administration', status);
      RETURN;
    IFEND;

    dmp$attach_device_file (recorded_vsn, file_name, system_file_id, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    osp$establish_condition_handler (^copy_handler, FALSE);
    segment_pointer.kind := mmc$sequence_pointer;
    segment_pointer.seq_pointer := NIL;
    #SPOIL (segment_pointer);
    dmp$open_file (system_file_id, osc$os_ring_1, osc$tsrv_ring, mmc$sar_read, mmc$as_sequential,
          segment_pointer, status);
    IF status.normal THEN
      seq_pointer := #LOC (segment_pointer.seq_pointer);
      i#move (segment_pointer.seq_pointer, output_p, seq_pointer^.length);
    IFEND;

    IF segment_pointer.seq_pointer <> NIL THEN
      dmp$close_file (segment_pointer.seq_pointer, status);
      segment_pointer.seq_pointer := NIL;
      #SPOIL (segment_pointer);
    IFEND;

    dmp$detach_device_file (system_file_id, ignore, ignore, status);

  PROCEND dmp$copy_device_file;
?? TITLE := '  dmp$copy_dfl', EJECT ??

  PROCEDURE [XDCL, #GATE] dmp$copy_dfl
    (    recorded_vsn: rmt$recorded_vsn;
         p_output_file: ^cell;
     VAR status: ost$status);

    VAR
      p_dfl: ^dmt$ms_device_file_list_table;

?? NEWTITLE := 'DFL_HANDLER', EJECT ??

    PROCEDURE dfl_handler
     (    condition: pmt$condition;
          condition_information: ^pmt$condition_information;
          save_area: ^ost$stack_frame_save_area;
      VAR handler_status: ost$status);

      VAR
        local_status: ost$status;

      IF condition.selector = pmc$user_defined_condition THEN
        pmp$continue_to_cause (pmc$execute_standard_procedure, handler_status);
        RETURN;
      IFEND;

      osp$set_status_from_condition (dmc$device_manager_ident, condition, save_area, status, handler_status);

      IF NOT handler_status.normal THEN
        status := handler_status;
      IFEND;

      dmp$close_dfl_r3 (p_dfl, local_status);

      EXIT dmp$copy_dfl;

    PROCEND dfl_handler;
?? OLDTITLE ??
?? EJECT ??

    dmp$open_dfl_r3 (recorded_vsn, p_dfl, status);

    IF status.normal THEN
      osp$establish_condition_handler (^dfl_handler, FALSE);
      i#move (p_dfl, p_output_file, #SIZE (p_dfl^));
      dmp$close_dfl_r3 (p_dfl, status);
    IFEND;

  PROCEND dmp$copy_dfl;

?? TITLE := '  dmp$copy_directory', EJECT ??

  PROCEDURE [XDCL, #GATE] dmp$copy_directory
    (    recorded_vsn: rmt$recorded_vsn;
         p_output_file: ^cell;
     VAR status: ost$status);

    VAR
      p_dir: ^dmt$ms_volume_directory;

?? NEWTITLE := 'DIRECTORY_HANDLER', EJECT ??

    PROCEDURE directory_handler
     (    condition: pmt$condition;
          condition_information: ^pmt$condition_information;
          save_area: ^ost$stack_frame_save_area;
      VAR handler_status: ost$status);

      VAR
        local_status: ost$status;

      IF condition.selector = pmc$user_defined_condition THEN
        pmp$continue_to_cause (pmc$execute_standard_procedure, handler_status);
        RETURN;
      IFEND;

      osp$set_status_from_condition (dmc$device_manager_ident, condition, save_area, status, handler_status);

      IF NOT handler_status.normal THEN
        status := handler_status;
      IFEND;

      dmp$close_directory_r3 (p_dir, local_status);

      EXIT dmp$copy_directory;

    PROCEND directory_handler;
?? OLDTITLE ??
?? EJECT ??

    dmp$open_directory_r3 (recorded_vsn, p_dir, status);

    IF status.normal THEN
      osp$establish_condition_handler (^directory_handler, FALSE);
      i#move (p_dir, p_output_file, #SIZE (p_dir^));
      dmp$close_directory_r3 (p_dir, status);
    IFEND;

  PROCEND dmp$copy_directory;

?? TITLE := '  dmp$copy_label', EJECT ??

  PROCEDURE [XDCL, #GATE] dmp$copy_label
    (    recorded_vsn: rmt$recorded_vsn;
         p_output_file: ^cell;
     VAR status: ost$status);

    VAR
      length: ost$segment_length,
      local_status: ost$status,
      p_label: ^dmt$ms_volume_label;

?? NEWTITLE := 'LABEL_HANDLER', EJECT ??

    PROCEDURE label_handler
     (    condition: pmt$condition;
          condition_information: ^pmt$condition_information;
          save_area: ^ost$stack_frame_save_area;
      VAR handler_status: ost$status);

      VAR
        local_status: ost$status;

      IF condition.selector = pmc$user_defined_condition THEN
        pmp$continue_to_cause (pmc$execute_standard_procedure, handler_status);
        RETURN;
      IFEND;

      osp$set_status_from_condition (dmc$device_manager_ident, condition, save_area, status, handler_status);

      IF NOT handler_status.normal THEN
        status := handler_status;
      IFEND;

      dmp$close_label_r3 (p_label, local_status);

      EXIT dmp$copy_label;

    PROCEND label_handler;
?? OLDTITLE ??
?? EJECT ??

    dmp$open_label_r3 (recorded_vsn, p_label, status);

    IF status.normal THEN
      mmp$get_segment_length (p_label, #RING (p_label), length, status);

      IF status.normal THEN
        osp$establish_condition_handler (^label_handler, FALSE);
        i#move (p_label, p_output_file, length);
        dmp$close_label_r3 (p_label, status);
      ELSE
        dmp$close_label_r3 (p_label, local_status);
      IFEND;
    IFEND;

  PROCEND dmp$copy_label;
?? TITLE := '  dmp$copy_log', EJECT ??

  PROCEDURE [XDCL, #GATE] dmp$copy_log
    (    recorded_vsn: rmt$recorded_vsn;
         p_output_file: ^cell;
     VAR status: ost$status);

    VAR
      p_log: ^SEQ ( * );

?? NEWTITLE := 'LOG_HANDLER', EJECT ??

    PROCEDURE log_handler
     (    condition: pmt$condition;
          condition_information: ^pmt$condition_information;
          save_area: ^ost$stack_frame_save_area;
      VAR handler_status: ost$status);

      VAR
        local_status: ost$status;

      IF condition.selector = pmc$user_defined_condition THEN
        pmp$continue_to_cause (pmc$execute_standard_procedure, handler_status);
        RETURN;
      IFEND;

      osp$set_status_from_condition (dmc$device_manager_ident, condition, save_area, status, handler_status);

      IF NOT handler_status.normal THEN
        status := handler_status;
      IFEND;

      dmp$close_log_r3 (p_log, local_status);

      EXIT dmp$copy_log;

    PROCEND log_handler;
?? OLDTITLE ??
?? EJECT ??

    dmp$open_log_r3 (recorded_vsn, p_log, status);

    IF status.normal THEN
      osp$establish_condition_handler (^log_handler, FALSE);
      i#move (p_log, p_output_file, #SIZE (p_log^));
      dmp$close_log_r3 (p_log, status);
    IFEND;

  PROCEND dmp$copy_log;
?? TITLE := '  dmp$copy_login_table', EJECT ??

  PROCEDURE [XDCL, #GATE] dmp$copy_login_table
    (    recorded_vsn: rmt$recorded_vsn;
         p_output_file: ^cell;
     VAR status: ost$status);

    VAR
      p_login_table: ^dmt$ms_mainframe_login_table;

?? NEWTITLE := 'LOGIN_TABLE_HANDLER', EJECT ??

    PROCEDURE login_table_handler
     (    condition: pmt$condition;
          condition_information: ^pmt$condition_information;
          save_area: ^ost$stack_frame_save_area;
      VAR handler_status: ost$status);

      VAR
        local_status: ost$status;

      IF condition.selector = pmc$user_defined_condition THEN
        pmp$continue_to_cause (pmc$execute_standard_procedure, handler_status);
        RETURN;
      IFEND;

      osp$set_status_from_condition (dmc$device_manager_ident, condition, save_area, status, handler_status);

      IF NOT handler_status.normal THEN
        status := handler_status;
      IFEND;

      dmp$close_login_table_r3 (p_login_table, local_status);

      EXIT dmp$copy_login_table;

    PROCEND login_table_handler;
?? OLDTITLE ??
?? EJECT ??

    dmp$open_login_table_r3 (recorded_vsn, p_login_table, status);

    IF status.normal THEN
      osp$establish_condition_handler (^login_table_handler, FALSE);
      i#move (p_login_table, p_output_file, #SIZE (p_login_table^));
      dmp$close_login_table_r3 (p_login_table, status);
    IFEND;
  PROCEND dmp$copy_login_table;
?? TITLE := '  dmp$utility_flush_logs_r3', EJECT ??

  PROCEDURE [XDCL, #GATE] dmp$utility_flush_logs_r3;

    dmp$utility_flush_logs;

  PROCEND dmp$utility_flush_logs_r3;
?? TITLE := '  display_fat', EJECT ??

  PROCEDURE display_fat (VAR display_control: clt$display_control;
        stored_fat: dmt$stored_ms_device_file_fat;
    VAR status: ost$status);

    VAR
      au_index: dmt$dau_address,
      aux_string,
      integer_string: ost$string;

    status.normal := TRUE;

    clp$put_display (display_control, 'Stored Device File Fat Header', clc$trim, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    CASE stored_fat.header.allocation_style OF
    = dmc$a0 =
      aux_string.value := 'dmc$a0';
      aux_string.size := 6;
    = dmc$a1 =
      aux_string.value := 'dmc$a1';
      aux_string.size := 6;
    = dmc$a2 =
      aux_string.value := 'dmc$a2';
      aux_string.size := 6;
    = dmc$a3 =
      aux_string.value := 'dmc$a3';
      aux_string.size := 6;
    = dmc$a4 =
      aux_string.value := 'dmc$a4';
      aux_string.size := 6;
    = dmc$a5 =
      aux_string.value := 'dmc$a5';
      aux_string.size := 6;
    = dmc$a6 =
      aux_string.value := 'dmc$a6';
      aux_string.size := 6;
    = dmc$a7 =
      aux_string.value := 'dmc$a7';
      aux_string.size := 6;
    = dmc$a8 =
      aux_string.value := 'dmc$a8';
      aux_string.size := 6;
    = dmc$acyl =
      aux_string.value := 'dmc$acyl';
      aux_string.size := 8;
    CASEND;

    clp$put_partial_display (display_control, '  Allocation Style     - ', clc$no_trim, amc$start, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

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

    clp$put_partial_display (display_control, '  Byte Address         - ', clc$no_trim, amc$start, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$convert_integer_to_string (stored_fat.header.byte_address, 10, FALSE, integer_string, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

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

    clp$put_partial_display (display_control, '  Bytes/Allocation     - ', clc$no_trim, amc$start, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$convert_integer_to_string (stored_fat.header.bytes_per_allocation, 10, FALSE, integer_string, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

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

    clp$put_partial_display (display_control, '  Bytes/Mau            - ', clc$no_trim, amc$start, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$convert_integer_to_string (stored_fat.header.bytes_per_mau, 10, FALSE, integer_string, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

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

    clp$put_partial_display (display_control, '  Clear Space          - ', clc$no_trim, amc$start, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    IF stored_fat.header.clear_space THEN
      aux_string.value := 'True';
      aux_string.size := 4;
    ELSE
      aux_string.value := 'False';
      aux_string.size := 5;
    IFEND;

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

    clp$put_partial_display (display_control, '  Daus/Allocation Unit - ', clc$no_trim, amc$start, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$convert_integer_to_string (stored_fat.header.daus_per_allocation_unit, 10, FALSE, integer_string,
          status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

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

    clp$put_partial_display (display_control, '  Daus/Cylinder        - ', clc$no_trim, amc$start, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$convert_integer_to_string (stored_fat.header.daus_per_cylinder, 10, FALSE, integer_string, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

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

    clp$put_partial_display (display_control, '  Daus/Transfer Unit   - ', clc$no_trim, amc$start, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$convert_integer_to_string (stored_fat.header.daus_per_transfer_unit, 10, FALSE, integer_string,
          status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

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

    clp$put_partial_display (display_control, '  Global File Name     - ', clc$no_trim, amc$start, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    display_binary_unique_name (display_control, stored_fat.header.global_file_name, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$put_partial_display (display_control, '  Maus/Allocation Unit - ', clc$no_trim, amc$start, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$convert_integer_to_string (stored_fat.header.maus_per_allocation_unit, 10, FALSE, integer_string,
          status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

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

    clp$put_partial_display (display_control, '  Maus/Dau             - ', clc$no_trim, amc$start, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$convert_integer_to_string (stored_fat.header.maus_per_dau, 10, FALSE, integer_string, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

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

    clp$put_partial_display (display_control, '  Maus/Transfer Unit   - ', clc$no_trim, amc$start, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$convert_integer_to_string (stored_fat.header.maus_per_transfer_unit, 10, FALSE, integer_string,
          status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

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

    clp$put_partial_display (display_control, '  Preset Value         - ', clc$no_trim, amc$start, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$convert_integer_to_string (stored_fat.header.preset_value, 10, FALSE, integer_string, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

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

    clp$put_partial_display (display_control, '  Number Faus          - ', clc$no_trim, amc$start, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$convert_integer_to_string (stored_fat.header.number_faus, 10, FALSE, integer_string, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

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

    clp$put_display (display_control, 'File Allocation Units', clc$trim, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    FOR au_index := 1 TO stored_fat.header.number_faus DO
      clp$put_partial_display (display_control, '  Dau Address - ', clc$no_trim, amc$start, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$convert_integer_to_string (stored_fat.file_allocation_units [au_index].dau_address, 10, FALSE,
            integer_string, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

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

      clp$put_partial_display (display_control, '  State       - ', clc$no_trim, amc$start, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      CASE stored_fat.file_allocation_units [au_index].state OF
      = dmc$fau_free =
        aux_string.value := 'dmc$fau_free';
        aux_string.size := 12;
      = dmc$fau_invalid_data =
        aux_string.value := 'dmc$fau_invalid_data';
        aux_string.size := 20;
      = dmc$fau_invalid_and_flawed =
        aux_string.value := 'dmc$fau_invalid_and_flawed';
        aux_string.size := 26;
      = dmc$fau_initialized =
        aux_string.value := 'dmc$fau_initialized';
        aux_string.size := 19;
      = dmc$fau_initialized_and_flawed =
        aux_string.value := 'dmc$fau_initialized_and_flawed';
        aux_string.size := 30;
      = dmc$fau_initialization_in_prog =
        aux_string.value := 'dmc$fau_initialization_in_prog';
        aux_string.size := 30;
      ELSE
        ;
      CASEND;

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

      clp$put_partial_display (display_control, '  Status      - ', clc$no_trim, amc$start, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      CASE stored_fat.file_allocation_units [au_index].status OF
      = dmc$add_to_chain =
        aux_string.value := 'dmc$add_to_chain';
        aux_string.size := 16;
      = dmc$delete_from_chain =
        aux_string.value := 'dmc$delete_from_chain';
        aux_string.size := 21;
      = dmc$no_change_required =
        aux_string.value := 'dmc$no_change_required';
        aux_string.size := 22;
      ELSE
        ;
      CASEND;

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

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

  PROCEND display_fat;
?? TITLE := '  display_stored_fmd', EJECT ??

  PROCEDURE display_stored_fmd (VAR display_control: clt$display_control;
        p_stored_df_fmd: ^dmt$device_file_stored_fmd;
    VAR status: ost$status);

    VAR
      stored_df_fmd: ^dmt$device_file_stored_fmd,
      aux_string,
      integer_string: ost$string,
      fmd_version: ^dmt$stored_ms_version_number,
      stored_fmd_header: ^dmt$stored_ms_fmd_header,
      stored_fmd_subfile: ^dmt$stored_ms_fmd_subfile;

    status.normal := TRUE;
    stored_df_fmd := p_stored_df_fmd;

    RESET stored_df_fmd;
    NEXT fmd_version IN stored_df_fmd;
    IF fmd_version = NIL THEN
      osp$set_status_abnormal (dmc$device_manager_ident, dme$invalid_fmd, 'No FMD version number.', status);
      RETURN;
    IFEND;

    NEXT stored_fmd_header: [fmd_version^] IN stored_df_fmd;
    IF stored_fmd_header = NIL THEN
      osp$set_status_abnormal (dmc$device_manager_ident, dme$invalid_fmd, 'No FMD header.', status);
      RETURN;
    IFEND;

    clp$put_display (display_control, 'Stored Fmd Header', clc$trim, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    CASE fmd_version^ OF
    = 0 =
      clp$put_display (display_control, '  Version                   - 0', clc$trim, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$put_partial_display (display_control, '  Clear Space               - ', clc$no_trim, amc$start,
            status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      IF stored_fmd_header^.version_0_0.clear_space THEN
        aux_string.value := 'True';
        aux_string.size := 4;
      ELSE
        aux_string.value := 'False';
        aux_string.size := 5;
      IFEND;

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

      clp$put_partial_display (display_control, '  File Hash                 - ', clc$no_trim, amc$start,
            status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$convert_integer_to_string (stored_fmd_header^.version_0_0.file_hash, 10, FALSE, integer_string,
            status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

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

      clp$put_partial_display (display_control, '  File Limit                - ', clc$no_trim, amc$start,
            status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$convert_integer_to_string (stored_fmd_header^.version_0_0.file_limit, 10, FALSE, integer_string,
            status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

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

      clp$put_partial_display (display_control, '  File Type                 - ', clc$no_trim, amc$start,
            status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      CASE stored_fmd_header^.version_0_0.file_kind OF
      = gfc$fk_job_permanent_file =
        aux_string.value := 'gfc$fk_job_permanent_file';
        aux_string.size := 25;
      = gfc$fk_device_file =
        aux_string.value := 'gfc$fk_device_file';
        aux_string.size := 18;
      = gfc$fk_job_local_file =
        aux_string.value := 'gfc$fk_job_local_file';
        aux_string.size := 21;
      = gfc$fk_unnamed_file =
        aux_string.value := 'gfc$fk_unnamed_file';
        aux_string.size := 19;
      = gfc$fk_catalog =
        aux_string.value := 'gfc$fk_catalog';
        aux_string.size := 14;
      ELSE
        ;
      CASEND;

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

      clp$put_partial_display (display_control, '  Locked File               - ', clc$no_trim, amc$start,
            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;

      IF stored_fmd_header^.version_0_0.locked_file.required THEN
        clp$put_partial_display (display_control, 'True, ', clc$trim, amc$terminate, status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;
      ELSE
        clp$put_partial_display (display_control, 'False)', clc$trim, amc$terminate, status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;
      IFEND;

      clp$put_partial_display (display_control, '  Number Subfiles           - ', clc$no_trim, amc$start,
            status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$convert_integer_to_string (stored_fmd_header^.version_0_0.number_fmds, 10, FALSE,
            integer_string, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

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

      clp$put_partial_display (display_control, '  Overflow Allowed          - ', clc$no_trim, amc$start,
            status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      IF stored_fmd_header^.version_0_0.overflow_allowed THEN
        aux_string.value := 'True';
        aux_string.size := 4;
      ELSE
        aux_string.value := 'False';
        aux_string.size := 5;
      IFEND;

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

      clp$put_partial_display (display_control, '  Preset Value              - ', clc$no_trim, amc$start,
            status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$convert_integer_to_string (stored_fmd_header^.version_0_0.preset_value, 10, FALSE, integer_string,
            status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

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

      clp$put_partial_display (display_control, '  Requested Allocation Size - ', clc$no_trim, amc$start,
            status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$convert_integer_to_string (stored_fmd_header^.version_0_0.requested_allocation_size, 10, FALSE,
            integer_string, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

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

      clp$put_partial_display (display_control, '  Requested Class           - ', clc$no_trim, amc$start,
            status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      aux_string.value (1) := stored_fmd_header^.version_0_0.requested_class;
      aux_string.size := 1;

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

      clp$put_partial_display (display_control, '  Requested Class Ordinal   - ', clc$no_trim, amc$start,
            status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$convert_integer_to_string (stored_fmd_header^.version_0_0.requested_class_ordinal, 10, FALSE,
            integer_string, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

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

      clp$put_partial_display (display_control, '  Requested Transfer Size   - ', clc$no_trim, amc$start,
            status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$convert_integer_to_string (stored_fmd_header^.version_0_0.requested_transfer_size, 10, FALSE,
            integer_string, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

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

      clp$put_partial_display (display_control, '  Requested Volume.Rec_Vsn  - ', clc$no_trim, amc$start,
            status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$put_partial_display (display_control, stored_fmd_header^.version_0_0.requested_volume.recorded_vsn,
            clc$trim, amc$terminate, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$put_partial_display (display_control, '  Requested Volume.Set_Name - ', clc$no_trim, amc$start,
            status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$put_partial_display (display_control, stored_fmd_header^.version_0_0.requested_volume.setname,
            clc$trim, amc$terminate, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
    = 1 =
      clp$put_partial_display (display_control, '  Version                  - 1', clc$trim, amc$terminate,
            status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$put_partial_display (display_control, '  Number Subfiles           - ', clc$no_trim, amc$start,
            status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$convert_integer_to_string (stored_fmd_header^.version_1_0.number_fmds, 10, FALSE,
            integer_string, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

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

    NEXT stored_fmd_subfile: [fmd_version^] IN stored_df_fmd;
    IF stored_fmd_subfile = NIL THEN
      osp$set_status_abnormal (dmc$device_manager_ident, dme$invalid_fmd, 'FMD too small to hold subfiles.',
            status);
      RETURN;
    IFEND;

    clp$put_display (display_control, 'Stored Fmd Subfile', clc$trim, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    CASE fmd_version^ OF
    = 0 =
      clp$put_partial_display (display_control, '  Version                   - 0', clc$trim, amc$terminate,
            status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$put_partial_display (display_control, '  Byte Address              - ', clc$no_trim, amc$start,
            status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$convert_integer_to_string (stored_fmd_subfile^.version_0_0.stored_byte_address *
            dmc$byte_address_converter, 10, FALSE, integer_string, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

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

      clp$put_partial_display (display_control, '  Device File List Index    - ', clc$no_trim, amc$start,
            status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$convert_integer_to_string (stored_fmd_subfile^.version_0_0.device_file_list_index, 10, FALSE,
            integer_string, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

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

      clp$put_partial_display (display_control, '  Interval Vsn              - ', clc$no_trim, amc$start,
            status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      display_binary_unique_name (display_control, stored_fmd_subfile^.version_0_0.internal_vsn, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$put_partial_display (display_control, '  Recorded Vsn              - ', clc$no_trim, amc$start,
            status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$put_partial_display (display_control, stored_fmd_subfile^.version_0_0.recorded_vsn, clc$trim,
            amc$terminate, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
    = 1 =
      clp$put_display (display_control, '  Version                   - 1', clc$trim, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$put_partial_display (display_control, '  Recorded Vsn              - ', clc$no_trim, amc$start,
            status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$put_partial_display (display_control, stored_fmd_subfile^.version_1_0.recorded_vsn, clc$trim,
            amc$terminate, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
    ELSE
      ;
    CASEND;

  PROCEND display_stored_fmd;
?? TITLE := '  display_binary_unique_name', EJECT ??

  PROCEDURE display_binary_unique_name (VAR display_control: clt$display_control;
        binary_unique_name: ost$binary_unique_name;
    VAR status: ost$status);

    VAR
      unique_name: ost$name;

    status.normal := TRUE;
    pmp$convert_binary_unique_name (binary_unique_name, unique_name, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

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

  PROCEND display_binary_unique_name;

?? TITLE := '  display_date', EJECT ??

  PROCEDURE display_date (VAR display_control: clt$display_control;
        date: dmt$date;
    VAR status: ost$status);

    VAR
      integer_string: ost$string;

    status.normal := TRUE;

    clp$convert_integer_to_string (date.year, 10, FALSE, integer_string, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$put_partial_display (display_control, integer_string.value (1, integer_string.size), 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$convert_integer_to_string (date.month, 10, FALSE, integer_string, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$put_partial_display (display_control, integer_string.value (1, integer_string.size), 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$convert_integer_to_string (date.day, 10, FALSE, integer_string, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

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

  PROCEND display_date;


?? TITLE := '  display_directory_header', EJECT ??

  PROCEDURE display_directory_header (VAR display_control: clt$display_control;
        directory_header: dmt$ms_volume_directory_head;
        recorded_vsn: rmt$recorded_vsn;
    VAR status: ost$status);

    VAR
      date: ost$date,
      time: ost$time,
      title_string: string (80),
      integer_string: ost$string;

    status.normal := TRUE;

    pmp$get_legible_date_time (osc$mdy_date, date, osc$hms_time, time, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    title_string (1, * ) := 'DIRECTORY : ';
    title_string (13, rmc$recorded_vsn_size) := recorded_vsn;
    title_string (20, 8) := date.mdy;
    title_string (29, 8) := time.hms;

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

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

    clp$put_display (display_control, title_string, clc$trim, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$put_partial_display (display_control, '  Number Of Entries - ', clc$no_trim, amc$start, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$convert_integer_to_string (directory_header.number_of_entries, 10, FALSE, integer_string, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

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

  PROCEND display_directory_header;

?? TITLE := '  display_directory_entry', EJECT ??

  PROCEDURE display_directory_entry (VAR display_control: clt$display_control;
        directory_entry: dmt$ms_volume_directory_entry;
    VAR status: ost$status);

    VAR
      aux_string: ost$string;

    status.normal := TRUE;

    clp$put_partial_display (display_control, '  Entry Available    - ', clc$no_trim, amc$start, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    IF directory_entry.entry_available THEN
      aux_string.value := 'True';
      aux_string.size := 4;
    ELSE
      aux_string.value := 'False';
      aux_string.size := 5;
    IFEND;

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

    IF NOT directory_entry.entry_available THEN
      clp$put_partial_display (display_control, '  User Supplied Name - ', clc$no_trim, amc$start, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

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

      clp$put_partial_display (display_control, '  Global File Name   - ', clc$no_trim, amc$start, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      display_binary_unique_name (display_control, directory_entry.global_file_name, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      display_stored_fmd (display_control, ^directory_entry.stored_df_fmd, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
    IFEND;

  PROCEND display_directory_entry;

?? TITLE := '  accumulate_dat_info', EJECT ??

  PROCEDURE accumulate_dat_info (
        recorded_vsn: rmt$recorded_vsn;
    VAR display_control: clt$display_control;
    VAR dau_status_counts: array [dmt$dau_status] of integer;
    VAR contiguous_dau_counts: array [1 .. contiguous_dau_range_array_size] of contiguous_dau_info;
    VAR contiguous_dau_max: integer;
    VAR total_available_daus: integer;
    VAR status: ost$status);

    VAR
      contiguous_count: integer,
      contiguous_index: integer,
      dat_index: dmt$dau_address,
      date: ost$date,
      dau_status: dmt$dau_status,
      mainframe_id: dmt$mainframe_assigned,
      p_dat: ^dmt$ms_device_allocation_table,
      p_dat_entry: ^dmt$ms_device_allocation_unit,
      time: ost$time,
      title_string: string (80);

    status.normal := TRUE;

    dmp$open_dat_r3 (recorded_vsn, p_dat, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    contiguous_count := 0;
    contiguous_dau_max := 0;
    total_available_daus := 0;

  /accumulate_dat/
    BEGIN

      pmp$get_legible_date_time (osc$mdy_date, date, osc$hms_time, time, status);
      IF NOT status.normal THEN
        EXIT /accumulate_dat/;
      IFEND;

      title_string (1, * ) := 'DEVICE SPACE : ';
      title_string (16, rmc$recorded_vsn_size) := recorded_vsn;
      title_string (23, 8) := date.mdy;
      title_string (32, 8) := time.hms;

      clp$new_display_page (display_control, status);
      IF NOT status.normal THEN
        EXIT /accumulate_dat/;
      IFEND;

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

      clp$put_display (display_control, title_string, clc$trim, status);
      IF NOT status.normal THEN
        EXIT /accumulate_dat/;
      IFEND;

      display_dat_header (display_control, p_dat^.header, status);
      IF NOT status.normal THEN
          EXIT /accumulate_dat/;
      IFEND;

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

      clp$put_display (display_control, 'Device Allocation Table', clc$trim, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

    /scan_dat_entries/
      FOR dat_index := 0 TO p_dat^.header.number_of_entries - 1 DO

        p_dat_entry := ^p_dat^.body [dat_index];
        dau_status := p_dat_entry^.dau_status;

        dau_status_counts [dau_status] := dau_status_counts [dau_status] + 1;

        IF (dau_status = dmc$dau_usable) OR (dau_status = dmc$dau_assigned_to_mainframe) THEN
          contiguous_count := contiguous_count + 1;
          total_available_daus := total_available_daus + 1;
        ELSE
          IF contiguous_count > 0 THEN
          /update_contiguous_dau_counts/
            FOR contiguous_index := LOWERBOUND(contiguous_dau_counts) TO UPPERBOUND(contiguous_dau_counts) DO
              IF (contiguous_count >= contiguous_dau_counts [contiguous_index].low) AND
                    (contiguous_count <= contiguous_dau_counts [contiguous_index].high) THEN
                contiguous_dau_counts [contiguous_index].occurrences :=
                      contiguous_dau_counts [contiguous_index].occurrences + 1;
                contiguous_dau_counts [contiguous_index].total_daus :=
                      contiguous_dau_counts [contiguous_index].total_daus + contiguous_count;
                IF contiguous_count > contiguous_dau_max THEN
                  contiguous_dau_max := contiguous_count;
                IFEND;
                EXIT /update_contiguous_dau_counts/;
              IFEND
            FOREND /update_contiguous_dau_counts/;
            contiguous_count := 0;
          IFEND;
        IFEND;

      FOREND /scan_dat_entries/;
    END /accumulate_dat/;

    dmp$close_dat_r3 (p_dat, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

  PROCEND accumulate_dat_info;

?? TITLE := '  accumulate_device_file_space', EJECT ??

  PROCEDURE accumulate_device_file_space (recorded_vsn: rmt$recorded_vsn;
    VAR display_control: clt$display_control;
    VAR dfle_flag_counts: array [dmt$dfl_entry_flags] of integer;
    VAR assigned_dfle_file_counts: array [gft$file_kind] of integer;
    VAR status: ost$status);

{
{   The purpose of this procedure is to accumulate counts concerning device file allocation.
{

    VAR
      dfl_index: dmt$device_file_list_index,
      p_device_file: ^dmt$ms_device_file_list_table,
      dfle_flag: dmt$dfl_entry_flags,
      file_kind: gft$file_kind,
      p_dfl_entry: ^dmt$ms_device_file_list_entry;

    status.normal := TRUE;
    dmp$open_dfl_r3 (recorded_vsn, p_device_file, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

  /display_device_file_totals/
    BEGIN

      display_device_file_header (display_control, ^p_device_file^.header, recorded_vsn, status);
      IF NOT status.normal THEN
        EXIT /display_device_file_totals/;
      IFEND;

    /accumulate_dfl_entries/
      FOR dfl_index := 1 TO p_device_file^.header.number_of_entries DO

        p_dfl_entry := ^p_device_file^.entries [dfl_index];
        dfle_flag := p_dfl_entry^.flags;

        dfle_flag_counts [dfle_flag] := dfle_flag_counts [dfle_flag] + 1;
        IF dfle_flag = dmc$dfle_assigned_to_file THEN
          file_kind := p_dfl_entry^.file_kind;
          assigned_dfle_file_counts [file_kind] := assigned_dfle_file_counts [file_kind] + 1;
        IFEND;

      FOREND /accumulate_dfl_entries/;
    END /display_device_file_totals/;

    dmp$close_dfl_r3 (p_device_file, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
  PROCEND accumulate_device_file_space;

?? TITLE := '  display_line', EJECT ??

  PROCEDURE display_line (output_line: string ( * );
        number: integer;
    VAR display_control: clt$display_control;
    VAR status: ost$status);

{
{   The purpose of this procedure is to output a line with the number converted to a string
{ appended to the line.
{

    VAR
      integer_length: integer,
      integer_string: string (osc$max_string_size),
      line: string (osc$max_string_size);


    STRINGREP (integer_string, integer_length, number);
    line := output_line;
    line (STRLENGTH (output_line) + 1, integer_length) := integer_string;
    clp$put_display (display_control, line, clc$trim, status);

  PROCEND display_line;

?? TITLE := '  display_device_file_header', EJECT ??

  PROCEDURE display_device_file_header (VAR display_control: clt$display_control;
        p_device_file_header: ^dmt$ms_device_file_list_header;
        recorded_vsn: rmt$recorded_vsn;
    VAR status: ost$status);

    VAR
      date: ost$date,
      time: ost$time,
      title_string: string (80),
      aux_string,
      integer_string: ost$string;

    status.normal := TRUE;

    pmp$get_legible_date_time (osc$mdy_date, date, osc$hms_time, time, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    title_string (1, * ) := 'DEVICE FILE LIST : ';
    title_string (20, rmc$recorded_vsn_size) := recorded_vsn;
    title_string (27, 8) := date.mdy;
    title_string (36, 8) := time.hms;

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

    clp$put_display (display_control, title_string, clc$trim, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

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

    clp$put_partial_display (display_control, '  Number Of Entries - ', clc$no_trim, amc$start, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$convert_integer_to_string (p_device_file_header^.number_of_entries, 10, FALSE, integer_string,
          status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

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

    clp$put_partial_display (display_control, '  Version Number    - ', clc$no_trim, amc$start, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    CASE p_device_file_header^.version_number OF
    = dmc$dflt_0_0 =
      aux_string.value := 'dmc$dflt_0_0';
      aux_string.size := 12;
    = dmc$dflt_1_0 =
      aux_string.value := 'dmc$dflt_1_0';
      aux_string.size := 12;
    ELSE
      ;
    CASEND;

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

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

  PROCEND display_device_file_header;
?? TITLE := '  display_dfl_entry', EJECT ??

  PROCEDURE display_dfl_entry (VAR display_control: clt$display_control;
        dfl_index: dmt$device_file_list_index;
        p_dfl_entry: ^dmt$ms_device_file_list_entry;
    VAR status: ost$status);

    VAR
      integer_string: string (osc$max_string_size),
      integer_length: integer,
      display_string: string (osc$max_string_size),
      aux_integer_length: integer,
      login_index: dmt$login_table_entry_index,
      first: boolean;

    status.normal := TRUE;

    STRINGREP (integer_string, integer_length, dfl_index);

    CASE p_dfl_entry^.flags OF
    = dmc$dfle_available =
      display_string := '       Dfle Available                                                ';
      display_string (1, integer_length) := integer_string;
    = dmc$dfle_assigned_to_mainframe =
      display_string := '       Mainframe Assigned(Login Seq, Login Index)-                     ';
      display_string (1, integer_length) := integer_string;
      STRINGREP (integer_string, integer_length, p_dfl_entry^.mainframe_assigned.log_in_sequence);
      display_string (51, integer_length) := integer_string;
      display_string (51 + integer_length, 2) := ', ';
      STRINGREP (integer_string, aux_integer_length, p_dfl_entry^.mainframe_assigned.log_in_index);
      display_string (51 + integer_length + 2, aux_integer_length) := integer_string;
    = dmc$dfle_assigned_to_file =
      display_string := '       File Type-             File Hash-     Fba-                       ';
      display_string (1, integer_length) := integer_string;
      CASE p_dfl_entry^.file_kind OF
      = gfc$fk_job_permanent_file =
        display_string (18, 12) := 'Permanent   ';
      = gfc$fk_device_file =
        display_string (18, 12) := 'Device      ';
      = gfc$fk_job_local_file =
        display_string (18, 12) := 'Temp Named  ';
      = gfc$fk_unnamed_file =
        display_string (18, 12) := 'Temp Unnamed';
      = gfc$fk_global_unnamed =
        display_string (18, 12) := 'Temp Global ';
      = gfc$fk_catalog =
        display_string (18, 12) := 'Catalog     ';
      ELSE
        ;
      CASEND;
      STRINGREP (integer_string, integer_length, p_dfl_entry^.file_hash);
      display_string (41, integer_length) := integer_string;
      STRINGREP (integer_string, integer_length, p_dfl_entry^.file_byte_address);
      display_string (49, integer_length) := integer_string;

      clp$put_display (display_control, display_string, clc$trim, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$put_partial_display (display_control, '       GFN - ', clc$no_trim, amc$start, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      display_binary_unique_name (display_control, p_dfl_entry^.global_file_name, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      display_string := '       Daus/Alloc Unit-    Dau Chain Status-                           ';
      STRINGREP (integer_string, integer_length, p_dfl_entry^.daus_per_allocation_unit);
      display_string (24, integer_length) := integer_string;
      IF p_dfl_entry^.dau_chain_status = dmc$dau_chain_linked THEN
        display_string (45, 12) := 'Chain Linked';
      ELSE
        display_string (45, 16) := 'Chain Not Linked';
      IFEND;

      clp$put_display (display_control, display_string, clc$trim, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      display_string := '       First Dau Address-           Subfile Length-                    ';
      STRINGREP (integer_string, integer_length, p_dfl_entry^.first_dau_address);
      display_string (26, integer_length) := integer_string;
      STRINGREP (integer_string, integer_length, p_dfl_entry^.fmd_length);
      display_string (52, integer_length) := integer_string;

      clp$put_display (display_control, display_string, clc$trim, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      display_string := '       Logical Length-           End Of Information-                   ';
      STRINGREP (integer_string, integer_length, p_dfl_entry^.logical_length);
      display_string (23, integer_length) := integer_string;
      STRINGREP (integer_string, integer_length, p_dfl_entry^.end_of_information);
      display_string (53, integer_length) := integer_string;

      clp$put_display (display_control, display_string, clc$trim, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      display_string := '       End Of File-           Login Set-(                              ';
      STRINGREP (integer_string, integer_length, p_dfl_entry^.end_of_file);
      display_string (20, integer_length) := integer_string;
      first := TRUE;
      aux_integer_length := 43;
      FOR login_index := LOWERVALUE (dmt$login_table_entry_index) TO UPPERVALUE (dmt$login_table_entry_index)
            DO
        IF login_index IN p_dfl_entry^.login_set THEN
          IF NOT first THEN
            display_string (aux_integer_length, 2) := ', ';
            aux_integer_length := aux_integer_length + 2;
          IFEND;

          STRINGREP (integer_string, integer_length, login_index);
          display_string (aux_integer_length, integer_length) := integer_string;
          aux_integer_length := aux_integer_length + integer_length;
          first := FALSE;
        IFEND;
      FOREND;

      display_string (aux_integer_length, 1) := ')';

      clp$put_display (display_control, display_string, clc$trim, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      first := TRUE;
      display_string := '       Abnormalities: None.';
      aux_integer_length := 23;

      IF dmc$eoi_modified_by_recovery IN p_dfl_entry^.damage THEN
        first := FALSE;
        display_string (aux_integer_length, 25) := 'Eoi modified by recovery.';
        aux_integer_length := aux_integer_length + 24;
      IFEND;

      IF dmc$media_image_inconsistent IN p_dfl_entry^.damage THEN
        IF NOT first THEN
          display_string (aux_integer_length, 2) := ', ';
          aux_integer_length := aux_integer_length + 3;
        IFEND;
        first := FALSE;
        display_string (aux_integer_length, 19) := 'Media inconsistent.';
        aux_integer_length := aux_integer_length + 18;
      IFEND;

      IF dmc$allocation_chain_broken IN p_dfl_entry^.damage THEN
        IF NOT first THEN
          display_string (aux_integer_length, 2) := ', ';
          aux_integer_length := aux_integer_length + 3;
        IFEND;
        first := FALSE;
        display_string (aux_integer_length, 24) := 'Allocation chain broken.';
      IFEND;
    CASEND;

      clp$put_display (display_control, display_string, clc$trim, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

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

  PROCEND display_dfl_entry;
?? TITLE := '  display_label_header', EJECT ??

  PROCEDURE display_label_header (VAR display_control: clt$display_control;
        p_label_header: ^dmt$volume_label_header;
    VAR status: ost$status);

    VAR
      date: ost$date,
      time: ost$time,
      title_string: string (80),
      integer_string,
      aux_string: ost$string;

    status.normal := TRUE;

    pmp$get_legible_date_time (osc$mdy_date, date, osc$hms_time, time, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    title_string (1, * ) := 'LABEL : ';
    title_string (9, rmc$recorded_vsn_size) := p_label_header^.recorded_vsn;
    title_string (16, 8) := date.mdy;
    title_string (25, 8) := time.hms;

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

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

    clp$put_display (display_control, title_string, clc$trim, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

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

    clp$put_display (display_control, 'Label Header', clc$trim, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$put_partial_display (display_control, '  Recorded Vsn     - ', clc$no_trim, amc$start, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

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

    clp$put_partial_display (display_control, '  Internal Vsn     - ', clc$no_trim, amc$start, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    display_binary_unique_name (display_control, p_label_header^.internal_vsn, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$put_partial_display (display_control, '  Creation Date    - ', clc$no_trim, amc$start, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    display_date (display_control, p_label_header^.creation_date, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$put_partial_display (display_control, '  Expiration Date  - ', clc$no_trim, amc$start, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    display_date (display_control, p_label_header^.expiration_date, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$put_partial_display (display_control, '  Label Type       - ', clc$no_trim, amc$start, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

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

    clp$put_partial_display (display_control, '  Version Number   - ', clc$no_trim, amc$start, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    CASE p_label_header^.version_number OF
    = dmc$ms_label_0_0 =
      aux_string.value := 'ms_label_0_0';
      aux_string.size := 12;
    = dmc$ms_label_1_0 =
      aux_string.value := 'ms_label_1_0';
      aux_string.size := 12;
    ELSE
      aux_string.value := 'invalid label';
      aux_string.size := 13;
    CASEND;

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

    clp$put_partial_display (display_control, '  Cylinders/Device - ', clc$no_trim, amc$start, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$convert_integer_to_string (p_label_header^.positions_per_device, 10, FALSE, integer_string, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

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

    clp$put_partial_display (display_control, '  Bytes/Dau        - ', clc$no_trim, amc$start, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$convert_integer_to_string (p_label_header^.bytes_per_dau, 10, FALSE, integer_string, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

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

    clp$put_partial_display (display_control, '  Bytes/Mau        - ', clc$no_trim, amc$start, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$convert_integer_to_string (p_label_header^.bytes_per_mau, 10, FALSE, integer_string, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

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

  PROCEND display_label_header;
?? TITLE := '  display_label_0_0', EJECT ??

  PROCEDURE display_label_0_0 (VAR display_control: clt$display_control;
        p_label_0_0: ^dmt$ms_label_0_0;
    VAR status: ost$status);

    VAR
      display_string: string (osc$max_string_size);

    status.normal := TRUE;
    display_string (1, * ) := ' ';

    clp$put_display (display_control, 'Label_0_0', clc$trim, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$put_partial_display (display_control, '  Access Code - ', clc$no_trim, amc$start, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

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

    clp$put_partial_display (display_control, '  Owner Id    - ', clc$no_trim, amc$start, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    display_string (1, osc$max_name_size) := p_label_0_0^.owner_id.user;
    display_string (2 + osc$max_name_size, osc$max_name_size) := p_label_0_0^.owner_id.family;

    clp$put_partial_display (display_control, display_string (1, 2 * osc$max_name_size + 1), clc$trim,
          amc$terminate, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$put_display (display_control, '               Dat Dfl Entry', clc$trim, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    display_dfl_entry (display_control, dmc$dat_dfl_index, ^p_label_0_0^.dat_dfl_entry, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

?? NOCOMPILE ??
    clp$put_display (display_control, '         Device Allocation Table Fmd', clc$trim, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    display_stored_fmd (display_control, ^p_label_0_0^.device_allocation_table_fmd, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
?? COMPILE ??

    clp$put_display (display_control, '         Device File List Dfl Entry', clc$trim, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    display_dfl_entry (display_control, dmc$device_file_list_dfl_index, ^p_label_0_0^.
          device_file_list_dfl_entry, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

?? NOCOMPILE ??
    clp$put_display (display_control, '            Device File List Fmd', clc$trim, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    display_stored_fmd (display_control, ^p_label_0_0^.device_file_list_fmd, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
?? COMPILE ??

    clp$put_display (display_control, '             Directory Dfl Entry', clc$trim, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    display_dfl_entry (display_control, dmc$directory_dfl_index, ^p_label_0_0^.directory_dfl_entry, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

?? NOCOMPILE ??
    clp$put_display (display_control, '               Directory Fmd', clc$trim, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    display_stored_fmd (display_control, ^p_label_0_0^.directory_fmd, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
?? COMPILE ??

  PROCEND display_label_0_0;

?? TITLE := '  display_dat_header', EJECT ??

  PROCEDURE display_dat_header (VAR display_control: clt$display_control;
        dat_header: dmt$ms_device_alloc_table_head;
    VAR status: ost$status);

    VAR
      aux_string,
      integer_string: ost$string;

    status.normal := TRUE;

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

    clp$put_display (display_control, 'Device Allocation Table Header', clc$trim, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$put_partial_display (display_control, '  Bytes/Dau         - ', clc$no_trim, amc$start, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$convert_integer_to_string (dat_header.bytes_per_dau, 10, FALSE, integer_string, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

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

    clp$put_partial_display (display_control, '  Bytes/Mau         - ', clc$no_trim, amc$start, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$convert_integer_to_string (dat_header.bytes_per_mau, 10, FALSE, integer_string, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

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

    clp$put_partial_display (display_control, '  Daus/Position     - ', clc$no_trim, amc$start, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$convert_integer_to_string (dat_header.daus_per_position, 10, FALSE, integer_string, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

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

    clp$put_partial_display (display_control, '  Maus/Dau          - ', clc$no_trim, amc$start, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$convert_integer_to_string (dat_header.maus_per_dau, 10, FALSE, integer_string, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

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

    clp$put_partial_display (display_control, '  Number Of Entries - ', clc$no_trim, amc$start, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$convert_integer_to_string (dat_header.number_of_entries, 10, FALSE, integer_string, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

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

    clp$put_partial_display (display_control, '  Positions/Device  - ', clc$no_trim, amc$start, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$convert_integer_to_string (dat_header.positions_per_device, 10, FALSE, integer_string, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

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

    clp$put_partial_display (display_control, '  Version Number    - ', clc$no_trim, amc$start, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    CASE dat_header.version_number OF
    = dmc$dat_0_0 =
      clp$put_partial_display (display_control, 'dmc$dat_0_0', clc$trim, amc$terminate, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

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

      clp$put_display (display_control, '    Daus/Allocation Style', clc$trim, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$put_partial_display (display_control, '      A0   - ', clc$no_trim, amc$start, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$convert_integer_to_rjstring (dat_header.daus_per_allocation_style [dmc$a0], 10, FALSE, ' ',
            integer_string.value (1, 6), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

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

      clp$put_partial_display (display_control, '      A1   - ', clc$no_trim, amc$start, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$convert_integer_to_rjstring (dat_header.daus_per_allocation_style [dmc$a1], 10, FALSE, ' ',
            integer_string.value (1, 6), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

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

      clp$put_partial_display (display_control, '      A2   - ', clc$no_trim, amc$start, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$convert_integer_to_rjstring (dat_header.daus_per_allocation_style [dmc$a2], 10, FALSE, ' ',
            integer_string.value (1, 6), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

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

      clp$put_partial_display (display_control, '      A3   - ', clc$no_trim, amc$start, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$convert_integer_to_rjstring (dat_header.daus_per_allocation_style [dmc$a3], 10, FALSE, ' ',
            integer_string.value (1, 6), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

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

      clp$put_partial_display (display_control, '      A4   - ', clc$no_trim, amc$start, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$convert_integer_to_rjstring (dat_header.daus_per_allocation_style [dmc$a4], 10, FALSE, ' ',
            integer_string.value (1, 6), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

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

      clp$put_partial_display (display_control, '      A5   - ', clc$no_trim, amc$start, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$convert_integer_to_rjstring (dat_header.daus_per_allocation_style [dmc$a5], 10, FALSE, ' ',
            integer_string.value (1, 6), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

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

      clp$put_partial_display (display_control, '      A6   - ', clc$no_trim, amc$start, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$convert_integer_to_rjstring (dat_header.daus_per_allocation_style [dmc$a6], 10, FALSE, ' ',
            integer_string.value (1, 6), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

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

      clp$put_partial_display (display_control, '      A7   - ', clc$no_trim, amc$start, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$convert_integer_to_rjstring (dat_header.daus_per_allocation_style [dmc$a7], 10, FALSE, ' ',
            integer_string.value (1, 6), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

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

      clp$put_partial_display (display_control, '      A8   - ', clc$no_trim, amc$start, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$convert_integer_to_rjstring (dat_header.daus_per_allocation_style [dmc$a8], 10, FALSE, ' ',
            integer_string.value (1, 6), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

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

      clp$put_partial_display (display_control, '      Acyl - ', clc$no_trim, amc$start, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$convert_integer_to_rjstring (dat_header.daus_per_allocation_style [dmc$acyl], 10, FALSE, ' ',
            integer_string.value (1, 6), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

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

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

      clp$put_partial_display (display_control, '    Daus available     - ', clc$no_trim, amc$start, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$convert_integer_to_rjstring (dat_header.available, 10, FALSE, ' ', integer_string.value (1, 8),
            status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

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

      clp$put_partial_display (display_control, '    Recovery threshold - ', clc$no_trim, amc$start, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$convert_integer_to_rjstring (dat_header.recovery_threshold, 10, FALSE, ' ', integer_string.value (1,
            8), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

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

      clp$put_partial_display (display_control, '    Warning threshold  - ', clc$no_trim, amc$start, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$convert_integer_to_rjstring (dat_header.warning_threshold, 10, FALSE, ' ', integer_string.value (1,
            8), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$put_partial_display (display_control, integer_string.value (1, 8), clc$no_trim, amc$terminate,
            status);

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

    CASEND;

  PROCEND display_dat_header;
?? TITLE := '  display_dat_entry', EJECT ??

  PROCEDURE display_dat_entry (VAR display_control: clt$display_control;
        dat_index: integer;
        p_dat_entry: ^dmt$ms_device_allocation_unit;
    VAR status: ost$status);

    VAR
       aux_integer_length: integer,
       dfl_index: dmt$device_file_list_index,
       display_string: string (80),
       file_string: string (63),
       flaw_string: string (7),

       integer_string: string (80),

      integer_length: integer,
       mat_flaw_string: string (27),
       mat_string: string (38);


    status.normal := TRUE;

    STRINGREP (integer_string, integer_length, dat_index);

    CASE p_dat_entry^.dau_status OF

    = dmc$dau_usable =
       display_string := '        Usable                                                                  ';

      display_string (1, integer_length) := integer_string;

    = dmc$dau_hardware_flawed =
       display_string := '        Hardware Flawed                                                         ';

      display_string (1, integer_length) := integer_string;

    = dmc$dau_software_flawed =
       display_string := '        Software Flawed                                                         ';

      display_string (1, integer_length) := integer_string;

     = dmc$dau_assigned_to_mainframe, dmc$dau_ass_to_mf_swr_flawed =
       IF p_dat_entry^.dau_status = dmc$dau_ass_to_mf_swr_flawed THEN
         mat_flaw_string := '                     Flawed';
       ELSE
         mat_flaw_string := '                           ';
       IFEND;

       mat_string (1,*) := '        Mfid(login seq, login index) -';

       mat_string (1, integer_length) := integer_string;

       STRINGREP (display_string, integer_length, mat_string: 38,
          p_dat_entry^.mainframe_id.log_in_sequence: 10,
          p_dat_entry^.mainframe_id.log_in_index: 3, mat_flaw_string: 29);


     = dmc$dau_assigned_to_file, dmc$dau_ass_to_file_swr_flawed =
       IF p_dat_entry^.dau_status = dmc$dau_ass_to_file_swr_flawed THEN
         flaw_string := ' Flawed';
       ELSE
         flaw_string := '       ';
       IFEND;

       file_string (1,*) := '        Hash-    Status-';

       file_string (1, integer_length) := integer_string;

      STRINGREP (integer_string, integer_length, p_dat_entry^.file_hash);
       file_string (14, integer_length) := integer_string;

      IF p_dat_entry^.data_status = dmc$dau_data_initialized THEN
         file_string (25, 8) := 'Init    ';

      ELSE
         file_string (25, 8) := 'Not Init';

      IFEND;

      CASE p_dat_entry^.allocation_chain_position OF

      = dmc$first_and_last_allocation =
         file_string (35, 28) := 'First+Last Alloc(Dfl Index)-';

         dfl_index := p_dat_entry^.high_dfl_index * dmc$dfl_index_converter + p_dat_entry^.low_dfl_index;
         STRINGREP (display_string, integer_length, file_string: 63, dfl_index: 8, flaw_string: 9);


      = dmc$first_allocation =
         file_string (35, 28) := 'First Alloc(Next Dau Adrs) -';
         STRINGREP (display_string, integer_length, file_string: 63,

            p_dat_entry^.next_allocation_unit_dau: 8, flaw_string: 9);


      = dmc$middle_allocation =
         file_string (35, 28) := 'Middle Alloc(Next Dau Adrs) -';
         STRINGREP (display_string, integer_length, file_string: 63,
            p_dat_entry^.next_allocation_unit_dau: 8, flaw_string: 9);


      = dmc$last_allocation =
         file_string (35, 28) := 'Last Allocation(Dfl Index) -';

         dfl_index := p_dat_entry^.high_dfl_index * dmc$dfl_index_converter + p_dat_entry^.low_dfl_index;
         STRINGREP (display_string, integer_length, file_string: 63, dfl_index: 8, flaw_string: 9);


      = dmc$part_of_allocation_unit =
         file_string (35, 28) := 'Part of Allocation Unit     ';
         STRINGREP (display_string, integer_length, file_string: 71,
            flaw_string: 9);

      CASEND;

    CASEND;

    clp$put_display (display_control, display_string, clc$trim, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

  PROCEND display_dat_entry;
?? TITLE := '  dmp$display_label', EJECT ??

  PROCEDURE [XDCL, #GATE] dmp$display_label (VAR display_control: clt$display_control;
        recorded_vsn: rmt$recorded_vsn;
    VAR status: ost$status);

    VAR
      p_label: ^dmt$ms_volume_label,
      p_label_header: ^dmt$volume_label_header,
      p_ms_label_0_0: ^dmt$ms_label_0_0,
      p_dat_fat: ^dmt$stored_ms_device_file_fat,
      bytes_per_au: amt$file_byte_address,
      number_of_aus: dmt$dau_address;

    status.normal := TRUE;

    dmp$open_label_r3 (recorded_vsn, p_label, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

  /display_label/
    BEGIN

      RESET p_label;
      NEXT p_label_header IN p_label;
      IF p_label_header = NIL THEN
        osp$set_status_abnormal (dmc$device_manager_ident, dme$no_contig_space_for_file, '', status);
        EXIT /display_label/;
      IFEND;

      display_label_header (display_control, p_label_header, status);
      IF NOT status.normal THEN
        EXIT /display_label/;
      IFEND;

      number_of_aus := 0;

      CASE p_label_header^.version_number OF

      = dmc$ms_label_0_0 =
        NEXT p_ms_label_0_0 IN p_label;
        IF p_ms_label_0_0 = NIL THEN
          osp$set_status_abnormal (dmc$device_manager_ident, dme$no_contig_space_for_file, '', status);
          EXIT /display_label/;
        IFEND;

        display_label_0_0 (display_control, p_ms_label_0_0, status);
        IF NOT status.normal THEN
          EXIT /display_label/;
        IFEND;

        bytes_per_au := p_label_header^.bytes_per_dau * p_ms_label_0_0^.dat_dfl_entry.
              daus_per_allocation_unit;
        number_of_aus := (p_ms_label_0_0^.dat_dfl_entry.fmd_length + bytes_per_au - 1) DIV bytes_per_au;

      = dmc$ms_label_1_0 =
        osp$set_status_abnormal (dmc$device_manager_ident, dme$unsupported_label_version,
          'unsupported label version - DMMDIS3', status);
        EXIT /display_label/;
      ELSE
        osp$set_status_abnormal (dmc$device_manager_ident, dme$unsupported_label_version,
          'unsupported label version - DMMDIS3', status);
        EXIT /display_label/;
      CASEND;

      NEXT p_dat_fat: [1 .. number_of_aus] IN p_label;
      IF p_dat_fat = NIL THEN
        osp$set_status_abnormal (dmc$device_manager_ident, dme$no_contig_space_for_file, '', status);
        EXIT /display_label/;
      IFEND;

      display_fat (display_control, p_dat_fat^, status);
      IF NOT status.normal THEN
        EXIT /display_label/;
      IFEND;

    END /display_label/;

    dmp$close_label_r3 (p_label, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

  PROCEND dmp$display_label;
?? TITLE := '  dmp$display_device_file', EJECT ??

  PROCEDURE [XDCL, #GATE] dmp$display_device_file (VAR display_control: clt$display_control;
        recorded_vsn: rmt$recorded_vsn;
        summary_listing: boolean;
        full_listing: boolean;
        file_index: dmt$device_file_list_index;
    VAR status: ost$status);

    VAR
      p_device_file: ^dmt$ms_device_file_list_table,
      p_dfl_entry: ^dmt$ms_device_file_list_entry,
      previous_status: dmt$dfl_entry_flags,
      previous_count: integer,
      integer_string: string (osc$max_string_size),
      type_index: gft$file_kind,
      flag_index: dmt$dfl_entry_flags,
      integer_length: integer,
      duplicate_entry_string: string (32),
      summary_string: string (80),
      dfl_index: dmt$device_file_list_index,
      file_kind_count: array [gft$file_kind] of integer,
      file_flag_count: array [dmt$dfl_entry_flags] of integer,
      mainframe_assigned: dmt$mainframe_assigned;

    status.normal := TRUE;

    dmp$open_dfl_r3 (recorded_vsn, p_device_file, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

  /display_device_file/
    BEGIN

      clp$new_display_page (display_control, status);

      display_device_file_header (display_control, ^p_device_file^.header, recorded_vsn, status);
      IF NOT status.normal THEN
        EXIT /display_device_file/;
      IFEND;

      IF p_device_file^.entries [1].flags = dmc$dfle_available THEN
        previous_status := dmc$dfle_assigned_to_mainframe;
      ELSE
        previous_status := dmc$dfle_available
      IFEND;
      previous_count := 0;
      duplicate_entry_string := '              Duplicate Entry(s)';

      FOR type_index := LOWERVALUE (gft$file_kind) TO UPPERVALUE (gft$file_kind) DO
        file_kind_count [type_index] := 0;
      FOREND;

      FOR flag_index := LOWERVALUE (dmt$dfl_entry_flags) TO UPPERVALUE (dmt$dfl_entry_flags) DO
        file_flag_count [flag_index] := 0;
      FOREND;

    /display_dfl_entries/
      FOR dfl_index := 1 TO p_device_file^.header.number_of_entries DO

        p_dfl_entry := ^p_device_file^.entries [dfl_index];
        file_flag_count [p_dfl_entry^.flags] := file_flag_count [p_dfl_entry^.flags] + 1;

        CASE p_dfl_entry^.flags OF

        = dmc$dfle_available =

          IF previous_status = dmc$dfle_available THEN
            previous_count := previous_count + 1;
            IF (NOT full_listing) AND (file_index = dfl_index) THEN
              display_dfl_entry (display_control, dfl_index, p_dfl_entry, status);
              CYCLE /display_dfl_entries/;
            ELSE
              CYCLE /display_dfl_entries/;
            IFEND;
          IFEND;

          IF (previous_count <> 0) AND (full_listing) THEN
            STRINGREP (integer_string, integer_length, previous_count);
            duplicate_entry_string (8, 6) := '      ';
            duplicate_entry_string (8, integer_length) := integer_string;

            clp$put_display (display_control, duplicate_entry_string, clc$trim, status);
            clp$new_display_line (display_control, 1, status);
          IFEND;

          previous_status := dmc$dfle_available;
          previous_count := 0;

        = dmc$dfle_assigned_to_mainframe =

          IF previous_status = dmc$dfle_assigned_to_mainframe THEN
            IF mainframe_assigned = p_dfl_entry^.mainframe_assigned THEN
              previous_count := previous_count + 1;
              IF (NOT full_listing) AND (file_index = dfl_index) THEN
                display_dfl_entry (display_control, dfl_index, p_dfl_entry, status);
                CYCLE /display_dfl_entries/;
              ELSE
                CYCLE /display_dfl_entries/;
              IFEND;
            IFEND;
          IFEND;

          IF (previous_count <> 0) AND (full_listing) THEN
            STRINGREP (integer_string, integer_length, previous_count);
            duplicate_entry_string (8, 6) := '      ';
            duplicate_entry_string (8, integer_length) := integer_string;

            clp$put_display (display_control, duplicate_entry_string, clc$trim, status);
            clp$new_display_line (display_control, 1, status);
          IFEND;

          previous_status := dmc$dfle_assigned_to_mainframe;
          previous_count := 0;

          mainframe_assigned := p_dfl_entry^.mainframe_assigned;

        = dmc$dfle_assigned_to_file =

          IF (previous_count <> 0) AND (full_listing) THEN
            STRINGREP (integer_string, integer_length, previous_count);
            duplicate_entry_string (8, 6) := '      ';
            duplicate_entry_string (8, integer_length) := integer_string;

            clp$put_display (display_control, duplicate_entry_string, clc$trim, status);
            clp$new_display_line (display_control, 1, status);
          IFEND;

          file_kind_count[p_dfl_entry^.file_kind] := file_kind_count[p_dfl_entry^.file_kind] + 1;
          previous_status := dmc$dfle_assigned_to_file;
          previous_count := 0;
        ELSE;
        CASEND;

        IF (NOT full_listing) AND (file_index = dfl_index) THEN
          display_dfl_entry (display_control, dfl_index, p_dfl_entry, status);
          IF NOT status.normal THEN
            EXIT /display_device_file/;
          IFEND;
        ELSEIF (full_listing) THEN
          display_dfl_entry (display_control, dfl_index, p_dfl_entry, status);
          IF NOT status.normal THEN
            EXIT /display_device_file/;
          IFEND;
        IFEND;

      FOREND /display_dfl_entries/;

      IF (previous_count <> 0) AND (full_listing) THEN
        STRINGREP (integer_string, integer_length, previous_count);
        duplicate_entry_string (8, 6) := '      ';
        duplicate_entry_string (8, integer_length) := integer_string;

        clp$put_display (display_control, duplicate_entry_string, clc$trim, status);
      IFEND;

      IF summary_listing THEN

        clp$new_display_line (display_control, 1, status);
        clp$put_display (display_control, ' Summary:', clc$trim, status);
        clp$new_display_line (display_control, 1, status);

      /file_flag_summary/
        FOR flag_index := LOWERVALUE (dmt$dfl_entry_flags) TO UPPERVALUE (dmt$dfl_entry_flags) DO
          CASE flag_index OF
          = dmc$dfle_available =
            summary_string := '  Number of available entries             -       ';

          = dmc$dfle_assigned_to_mainframe =
            summary_string := '  Number of assigned to mainframe entries -       ';

          = dmc$dfle_assigned_to_file =
            summary_string := '  Number of assigned to file entries      -       ';
          ELSE;
          CASEND;

          STRINGREP (integer_string, integer_length, file_flag_count[flag_index]);
          summary_string (44, integer_length) := integer_string;
          clp$put_display (display_control, summary_string, clc$trim, status);
        FOREND /file_flag_summary/;

        summary_string := '     File Type -                   Number of Entries -             ';

      /assigned_file_summary/
        FOR type_index := LOWERVALUE (gft$file_kind) TO UPPERVALUE (gft$file_kind) DO
          summary_string (55,*) := ' ';
          CASE type_index OF
          = gfc$fk_job_permanent_file =
            summary_string (18, 12) := 'Permanent   ';
          = gfc$fk_device_file =
            summary_string (18, 12) := 'Device      ';
          = gfc$fk_job_local_file =
            summary_string (18, 12) := 'Temp Named  ';
          = gfc$fk_unnamed_file =
            summary_string (18, 12) := 'Temp Unnamed';
          = gfc$fk_global_unnamed =
            summary_string (18, 12) := 'Temp Global ';
          = gfc$fk_catalog =
            summary_string (18, 12) := 'Catalog     ';
          ELSE;
          CASEND;

        STRINGREP (integer_string, integer_length, file_kind_count [type_index]);
        summary_string (55, integer_length) := integer_string;
        clp$put_display (display_control, summary_string, clc$trim, status);
        FOREND /assigned_file_summary/;
      IFEND;

    END /display_device_file/;

    dmp$close_dfl_r3 (p_device_file, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

  PROCEND dmp$display_device_file;
?? TITLE := '  dmp$display_device_space', EJECT ??

  PROCEDURE [XDCL, #GATE] dmp$display_device_space (VAR display_control: clt$display_control;
        recorded_vsn: rmt$recorded_vsn;
    VAR status: ost$status);

    VAR
      initial_contiguous_dau_counts: [XDCL, oss$job_paged_literal, READ]
            array [1 .. contiguous_dau_range_array_size] of contiguous_dau_info :=
            [[1, 4, 0, 0],
            [5, 9, 0, 0],
            [10, 24, 0, 0],
            [25, 49, 0, 0],
            [50, 99, 0, 0],
            [100, 999, 0, 0],
            [1000, osc$max_integer, 0, 0]];

    VAR
      assigned_dfle_file_counts: array [gft$file_kind] of integer,
      available_percentage: real,
      contiguous_dau_counts: array [1 .. contiguous_dau_range_array_size] of contiguous_dau_info,
      contiguous_dau_max: integer,
      contiguous_index: integer,
      dau_status: dmt$dau_status,
      dau_status_counts: array [dmt$dau_status] of integer,
      dfle_flag: dmt$dfl_entry_flags,
      dfle_flag_counts: array [dmt$dfl_entry_flags] of integer,
      file_kind: gft$file_kind,
      line: string (osc$max_string_size),
      line_length: integer,
      total_available_daus: integer;

{  Initialize all counts to zero.

    FOR file_kind := LOWERVALUE (gft$file_kind) TO UPPERVALUE (gft$file_kind) DO
      assigned_dfle_file_counts [file_kind] := 0;
    FOREND;

    FOR dau_status := LOWERVALUE (dmt$dau_status) TO UPPERVALUE (dmt$dau_status) DO
      dau_status_counts [dau_status] := 0;
    FOREND;

    FOR dfle_flag := LOWERVALUE (dmt$dfl_entry_flags) TO UPPERVALUE (dmt$dfl_entry_flags) DO
      dfle_flag_counts [dfle_flag] := 0;
    FOREND;

    contiguous_dau_counts := initial_contiguous_dau_counts;

{  Accumulate and display DAT totals for device.

    accumulate_dat_info (recorded_vsn, display_control, dau_status_counts, contiguous_dau_counts,
          contiguous_dau_max, total_available_daus, status);
    IF status.normal = FALSE THEN
      RETURN;
    IFEND;

    display_line ('  Usable DAT entries - ', dau_status_counts [dmc$dau_usable], display_control, status);
    display_line ('  DAT entries assigned to files - ', dau_status_counts [dmc$dau_assigned_to_file],
          display_control, status);
    display_line ('  DAT entries assigned to mainframe - ', dau_status_counts [dmc$dau_assigned_to_mainframe],
          display_control, status);
    display_line ('  Hardware flawed DAT entries - ', dau_status_counts [dmc$dau_hardware_flawed],
          display_control, status);
    display_line ('  Software flawed DAT entries - ', dau_status_counts [dmc$dau_software_flawed],
          display_control, status);
    display_line ('  Assigned to mf - software flawed - ', dau_status_counts [dmc$dau_ass_to_mf_swr_flawed],
          display_control, status);
    display_line ('  Assigned to file - software flawed - ', dau_status_counts
          [dmc$dau_ass_to_file_swr_flawed], display_control, status);

    clp$new_display_line (display_control, 1, status);
    STRINGREP (line, line_length, 'Distribution of Contiguous Available Allocation Units (DAUs)');
    clp$put_partial_display (display_control, line (1, line_length), clc$trim, amc$terminate, status);
    clp$new_display_line (display_control, 1, status);
    STRINGREP (line, line_length, '     Range     Occurrences   Total DAUs   % of Available DAUs');
    clp$put_partial_display (display_control, line (1, line_length), clc$trim, amc$terminate, status);
    clp$new_display_line (display_control, 1, status);

    FOR contiguous_index := LOWERBOUND(contiguous_dau_counts) TO UPPERBOUND(contiguous_dau_counts) DO
      IF contiguous_index < UPPERBOUND(contiguous_dau_counts) THEN
        available_percentage := $REAL(contiguous_dau_counts [contiguous_index].total_daus * 100) /
              $REAL(total_available_daus);
        STRINGREP (line, line_length, ' ', contiguous_dau_counts [contiguous_index].low:4, ' ..',
              contiguous_dau_counts [contiguous_index].high:4,
              contiguous_dau_counts [contiguous_index].occurrences:10,
              contiguous_dau_counts [contiguous_index].total_daus:13,
              available_percentage:16:1, '%');
        clp$put_partial_display (display_control, line (1, line_length), clc$trim, amc$terminate, status);
      ELSE
        available_percentage := $REAL(contiguous_dau_counts [contiguous_index].total_daus * 100) /
              $REAL(total_available_daus);
        STRINGREP (line, line_length, '    >', contiguous_dau_counts [contiguous_index].low:7,
              contiguous_dau_counts [contiguous_index].occurrences:10,
              contiguous_dau_counts [contiguous_index].total_daus:13,
              available_percentage:16:1, '%');
        clp$put_partial_display (display_control, line (1, line_length), clc$trim, amc$terminate, status);
      IFEND;
    FOREND;

    clp$new_display_line (display_control, 1, status);
    STRINGREP (line, line_length, '  Total Available DAUs - ', total_available_daus);
    clp$put_partial_display (display_control, line (1, line_length), clc$trim, amc$terminate, status);

    clp$new_display_line (display_control, 1, status);
    STRINGREP (line, line_length, '  Maximum Contigous DAUs - ', contiguous_dau_max);
    clp$put_partial_display (display_control, line (1, line_length), clc$trim, amc$terminate, status);

{  Accumulate and display information about device files on the device.

    accumulate_device_file_space (recorded_vsn, display_control, dfle_flag_counts,
          assigned_dfle_file_counts, status);
    IF status.normal = FALSE THEN
      RETURN;
    IFEND;

    display_line ('  Device file available - ', dfle_flag_counts [dmc$dfle_available], display_control,
          status);
    display_line ('  Device file assigned to mainframe - ', dfle_flag_counts [dmc$dfle_assigned_to_mainframe],
          display_control, status);
    display_line ('  Device file assigned to files - ', dfle_flag_counts [dmc$dfle_assigned_to_file],
          display_control, status);
    display_line ('      Temporary named files - ', assigned_dfle_file_counts [gfc$fk_job_local_file],
          display_control, status);
    display_line ('      Temporary unnamed files - ', assigned_dfle_file_counts [gfc$fk_job_local_file],
          display_control, status);
    display_line ('      Temporary_global files - ',
          assigned_dfle_file_counts [gfc$fk_global_unnamed],
          display_control, status);
    display_line ('      Permanent files - ',
          assigned_dfle_file_counts [gfc$fk_job_permanent_file], display_control,
          status);
    display_line ('      Device files - ', assigned_dfle_file_counts [gfc$fk_device_file],
          display_control, status);
    display_line ('      Catalogs - ', assigned_dfle_file_counts [gfc$fk_catalog],
          display_control, status);

  PROCEND dmp$display_device_space;
?? TITLE := '  dmp$display_directory', EJECT ??

  PROCEDURE [XDCL, #GATE] dmp$display_directory (VAR display_control: clt$display_control;
        recorded_vsn: rmt$recorded_vsn;
    VAR status: ost$status);

    VAR
      dir_entry: dmt$ms_volume_directory_entry,
      p_directory: ^dmt$ms_volume_directory,
      integer_string: ost$string,
      previous_count: integer,
      integer_length: integer,
      duplicate_entry_string: string (32),
      previous_status: boolean,
      directory_index: dmt$directory_index;

    status.normal := TRUE;

    dmp$open_directory_r3 (recorded_vsn, p_directory, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

  /display_directory/
    BEGIN

      display_directory_header (display_control, p_directory^.header, recorded_vsn, status);
      IF NOT status.normal THEN
        EXIT /display_directory/;
      IFEND;

      previous_count := 0;
      previous_status := FALSE;
      duplicate_entry_string := '             Duplicate Entrie(s)';

    /display_directory_entries/
      FOR directory_index := 1 TO p_directory^.header.number_of_entries DO

        dir_entry := p_directory^.entries [directory_index];

        IF dir_entry.entry_available THEN
          IF previous_status = TRUE THEN;
            previous_count := previous_count + 1;
            CYCLE /display_directory_entries/;
          IFEND;
          previous_status := TRUE;
        IFEND;

        IF previous_count <> 0 THEN
          STRINGREP (integer_string.value, integer_length, previous_count);
          duplicate_entry_string (8,6) := '      ';
          duplicate_entry_string(8,integer_length) := integer_string.value;

          clp$new_display_line (display_control, 1, status);
          clp$put_display(display_control, duplicate_entry_string, clc$trim, status);

          previous_count := 0;
          previous_status := FALSE;
        IFEND;

        clp$convert_integer_to_string (directory_index, 10, FALSE, integer_string, status);
        clp$new_display_line (display_control, 1, status);
        clp$put_partial_display (display_control, integer_string.value (1, integer_string.size), clc$trim,
              amc$start, status);
        clp$put_partial_display (display_control, '. Directory Entry', clc$trim, amc$terminate, status);

        display_directory_entry (display_control, dir_entry, status);
        IF NOT status.normal THEN
          EXIT /display_directory_entries/;
        IFEND;
      FOREND /display_directory_entries/;

      IF previous_count <> 0 THEN
        STRINGREP (integer_string.value, integer_length, previous_count);
        duplicate_entry_string (8,6) := '      ';
        duplicate_entry_string(8,integer_length) := integer_string.value;

        clp$new_display_line (display_control, 1, status);
        clp$put_display(display_control, duplicate_entry_string, clc$trim, status);
      IFEND;
    END /display_directory/;

    dmp$close_directory_r3 (p_directory, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

  PROCEND dmp$display_directory;
?? TITLE := '  dmp$display_dat', EJECT ??

  PROCEDURE [XDCL, #GATE] dmp$display_dat (VAR display_control: clt$display_control;
        recorded_vsn: rmt$recorded_vsn;
    VAR status: ost$status);

    VAR
      p_dat: ^dmt$ms_device_allocation_table,
      p_dat_entry: ^dmt$ms_device_allocation_unit,
      previous_status: dmt$dau_status,
      previous_count: integer,
      integer_string: string (osc$max_string_size),
      integer_length: integer,
      duplicate_entry_string: string (32),
      dat_index: dmt$dau_address,
      date: ost$date,
      time: ost$time,
      title_string: string (80),
      mainframe_id: dmt$mainframe_assigned;

    status.normal := TRUE;

    dmp$open_dat_r3 (recorded_vsn, p_dat, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

  /display_dat/
    BEGIN

      clp$new_display_page (display_control, status);
      IF NOT status.normal THEN
        EXIT /display_dat/;
      IFEND;

      pmp$get_legible_date_time (osc$mdy_date, date, osc$hms_time, time, status);
      IF NOT status.normal THEN
        EXIT /display_dat/;
      IFEND;

      title_string (1, * ) := 'DEVICE ALLOCATION TABLE : ';
      title_string (27, rmc$recorded_vsn_size) := recorded_vsn;
      title_string (34, 8) := date.mdy;
      title_string (41, 8) := time.hms;

      clp$put_display (display_control, title_string, clc$trim, status);
      IF NOT status.normal THEN
        EXIT /display_dat/;
      IFEND;

      display_dat_header (display_control, p_dat^.header, status);
      IF NOT status.normal THEN
        EXIT /display_dat/;
      IFEND;

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

      clp$put_display (display_control, 'Device Allocation Table', clc$trim, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      IF p_dat^.body [0].dau_status = dmc$dau_usable THEN
        previous_status := dmc$dau_hardware_flawed;
      ELSE
        previous_status := dmc$dau_usable;
      IFEND;
      previous_count := 0;
      duplicate_entry_string := '              Duplicate Entry(s)';

    /display_dat_entries/
      FOR dat_index := 0 TO p_dat^.header.number_of_entries - 1 DO

        p_dat_entry := ^p_dat^.body [dat_index];

        CASE p_dat_entry^.dau_status OF
        = dmc$dau_usable =
          IF previous_status = dmc$dau_usable THEN
            previous_count := previous_count + 1;
            CYCLE /display_dat_entries/;
          IFEND;

          IF previous_count <> 0 THEN
            STRINGREP (integer_string, integer_length, previous_count);
            duplicate_entry_string (8, 6) := '      ';
            duplicate_entry_string (8, integer_length) := integer_string;

            clp$put_display (display_control, duplicate_entry_string, clc$trim, status);
            IF NOT status.normal THEN
              EXIT /display_dat/;
            IFEND;
          IFEND;

          previous_status := dmc$dau_usable;
          previous_count := 0;
        = dmc$dau_hardware_flawed =
          IF previous_status = dmc$dau_hardware_flawed THEN
            previous_count := previous_count + 1;
            CYCLE /display_dat_entries/;
          IFEND;

          IF previous_count <> 0 THEN
            STRINGREP (integer_string, integer_length, previous_count);
            duplicate_entry_string (8, 6) := '      ';
            duplicate_entry_string (8, integer_length) := integer_string;

            clp$put_display (display_control, duplicate_entry_string, clc$trim, status);
            IF NOT status.normal THEN
              EXIT /display_dat/;
            IFEND;
          IFEND;

          previous_status := dmc$dau_hardware_flawed;
          previous_count := 0;
        = dmc$dau_software_flawed =
          IF previous_status = dmc$dau_software_flawed THEN
            previous_count := previous_count + 1;
            CYCLE /display_dat_entries/;
          IFEND;

          IF previous_count <> 0 THEN
            STRINGREP (integer_string, integer_length, previous_count);
            duplicate_entry_string (8, 6) := '      ';
            duplicate_entry_string (8, integer_length) := integer_string;

            clp$put_display (display_control, duplicate_entry_string, clc$trim, status);
            IF NOT status.normal THEN
              EXIT /display_dat/;
            IFEND;
          IFEND;

          previous_status := dmc$dau_software_flawed;
          previous_count := 0;
        = dmc$dau_assigned_to_mainframe =
          IF previous_status = dmc$dau_assigned_to_mainframe THEN
            IF mainframe_id = p_dat_entry^.mainframe_id THEN
              previous_count := previous_count + 1;
              CYCLE /display_dat_entries/;
            IFEND;
          IFEND;

          IF previous_count <> 0 THEN
            STRINGREP (integer_string, integer_length, previous_count);
            duplicate_entry_string (8, 6) := '      ';
            duplicate_entry_string (8, integer_length) := integer_string;

            clp$put_display (display_control, duplicate_entry_string, clc$trim, status);
            IF NOT status.normal THEN
              EXIT /display_dat/;
            IFEND;
          IFEND;

          previous_status := dmc$dau_assigned_to_mainframe;
          previous_count := 0;
          mainframe_id := p_dat_entry^.mainframe_id;
        = dmc$dau_assigned_to_file =
          IF previous_count <> 0 THEN
            STRINGREP (integer_string, integer_length, previous_count);
            duplicate_entry_string (8, 6) := '      ';
            duplicate_entry_string (8, integer_length) := integer_string;

            clp$put_display (display_control, duplicate_entry_string, clc$trim, status);
            IF NOT status.normal THEN
              EXIT /display_dat/;
            IFEND;
          IFEND;

          previous_status := dmc$dau_assigned_to_file;
          previous_count := 0;
         = dmc$dau_ass_to_mf_swr_flawed =
           IF previous_status = dmc$dau_ass_to_mf_swr_flawed THEN
             IF mainframe_id = p_dat_entry^.mainframe_id THEN
               previous_count := previous_count + 1;
               CYCLE /display_dat_entries/;
             IFEND;
           IFEND;

           IF previous_count <> 0 THEN
             STRINGREP (integer_string, integer_length, previous_count);
             duplicate_entry_string (8, 6) := '      ';
             duplicate_entry_string (8, integer_length) := integer_string;

             clp$put_display (display_control, duplicate_entry_string, clc$trim, status);
             IF NOT status.normal THEN
               EXIT /display_dat/;
             IFEND;
           IFEND;

           previous_status := dmc$dau_ass_to_mf_swr_flawed;
           previous_count := 0;
           mainframe_id := p_dat_entry^.mainframe_id;
         = dmc$dau_ass_to_file_swr_flawed =
           IF previous_count <> 0 THEN
             STRINGREP (integer_string, integer_length, previous_count);
             duplicate_entry_string (8, 6) := '      ';
             duplicate_entry_string (8, integer_length) := integer_string;

             clp$put_display (display_control, duplicate_entry_string, clc$trim, status);
             IF NOT status.normal THEN
               EXIT /display_dat/;
             IFEND;
           IFEND;

           previous_status := dmc$dau_ass_to_file_swr_flawed;
           previous_count := 0;

        CASEND;

        display_dat_entry (display_control, dat_index, p_dat_entry, status);
        IF NOT status.normal THEN
          EXIT /display_dat/;
        IFEND;
      FOREND /display_dat_entries/;

      IF previous_count <> 0 THEN
        STRINGREP (integer_string, integer_length, previous_count);
        duplicate_entry_string (8, 6) := '      ';
        duplicate_entry_string (8, integer_length) := integer_string;

        clp$put_display (display_control, duplicate_entry_string, clc$trim, status);
        IF NOT status.normal THEN
          EXIT /display_dat/;
        IFEND;
      IFEND;

    END /display_dat/;

    dmp$close_dat_r3 (p_dat, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

  PROCEND dmp$display_dat;
?? TITLE := '  dmp$display_device_log', EJECT ??

  PROCEDURE [XDCL, #GATE] dmp$display_device_log (VAR display_control: clt$display_control;
        recorded_vsn: rmt$recorded_vsn;
    VAR status: ost$status);

    status.normal := TRUE;

  PROCEND dmp$display_device_log;
?? TITLE := '  dmp$display_login_table', EJECT ??

  PROCEDURE [XDCL, #GATE] dmp$display_login_table (VAR display_control: clt$display_control;
        recorded_vsn: rmt$recorded_vsn;
    VAR status: ost$status);

    status.normal := TRUE;

  PROCEND dmp$display_login_table;

?? TITLE := '  [XDCL, #GATE] dmp$display_cylinders', EJECT ??

  PROCEDURE [XDCL, #GATE] dmp$display_cylinders (VAR display_control: clt$display_control;
        recorded_vsn: rmt$recorded_vsn;
    VAR status: ost$status);

{
{  This procedure produces a display of the current state of cylinder allocation on a volume.
{  Information provided is:
{          . some header information (date, time, cylinders per device, etc.)
{          . one line for each cylinder on the device stating the number of the cylinder, the
{              allocation style assigned to the cylinder, whether or not the cylinder is
{              'full', and how the daus are assigned within the cylinder (assigned to file or
{              assigned to mainframe, or flawed)
{          . some summary information indicating the total numbers of daus by assignment, and
{              numbers of cylinders assigned to each allocation style
{

    VAR
      p_dat: ^dmt$ms_device_allocation_table,
      line: string (80),
      l: integer,
      dau_status_counts: dmt$dau_status_counts,
      num_usable: integer,
      num_assigned_file: integer,
      num_assigned_mf: integer,
      num_flawed: integer,
      total_usable: integer,
      total_assigned_file: integer,
      total_assigned_mf: integer,
      total_flawed: integer,
      style_index: dmt$allocation_styles,
      styles_per_device: array [dmt$allocation_styles] of integer,
      date: ost$date,
      time: ost$time,
      cylinder_index: dmt$device_position,
      assigned_style: dmt$allocation_styles;

    status.normal := TRUE;

    FOR style_index := LOWERVALUE (dmt$allocation_styles) TO UPPERVALUE (dmt$allocation_styles) DO
      styles_per_device [style_index] := 0;
    FOREND;

    total_usable := 0;
    total_assigned_file := 0;
    total_assigned_mf := 0;
    total_flawed := 0;

    pmp$get_legible_date_time (osc$mdy_date, date, osc$hms_time, time, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    line (1, * ) := ' CYLINDERS: ';
    line (13, rmc$recorded_vsn_size) := recorded_vsn;
    line (21, 8) := date.mdy;
    line (30, 8) := time.hms;

    clp$new_display_page (display_control, status);
    clp$new_display_line (display_control, 1, status);
    clp$put_display (display_control, line, clc$trim, status);
    clp$new_display_line (display_control, 1, status);

    dmp$open_dat_r3 (recorded_vsn, p_dat, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$put_partial_display (display_control, ' daus/cyl = ', clc$no_trim, amc$start, status);
    STRINGREP (line (1, 10), l, p_dat^.header.daus_per_position);
    clp$put_partial_display (display_control, line (1, l), clc$no_trim, amc$continue, status);
    clp$put_partial_display (display_control, '  cyl/device = ', clc$no_trim, amc$continue, status);
    STRINGREP (line (1, 10), l, p_dat^.header.positions_per_device);
    clp$put_partial_display (display_control, line (1, l), clc$trim, amc$terminate, status);
    clp$new_display_line (display_control, 1, status);

    line (1, * ) := ' CYLINDER ALLOCATION  DAUs  ASSGND ASSGND';
    clp$put_display (display_control, line, clc$trim, status);
    line (1, * ) := '  NUMBER    STYLE    USABLE  FILE    MF   FLAWED';
    clp$put_display (display_control, line, clc$trim, status);
    clp$new_display_line (display_control, 1, status);

{
{  For each cylinder, write a line describing the cylinder's style and how the daus within the
{  cylinder are assigned.
{

  /display_cylinders/
    FOR cylinder_index := 0 TO p_dat^.header.positions_per_device - 1 DO
      line (1, * ) := ' ';
      STRINGREP (line (3, 5), l, cylinder_index);
      dmp$analyze_dat_position (p_dat, cylinder_index, assigned_style, dau_status_counts);

      CASE assigned_style OF
      = dmc$a0 =
        line (9, * ) := 'a0';
      = dmc$a1 =
        line (9, * ) := 'a1';
        line (12, * ) := '*';
      = dmc$a2 =
        line (9, * ) := 'a2';
        line (12, * ) := '**';
      = dmc$a3 =
        line (9, * ) := 'a3';
        line (12, * ) := '***';
      = dmc$a4 =
        line (9, * ) := 'a4';
        line (12, * ) := '****';
      = dmc$a5 =
        line (9, * ) := 'a5';
        line (12, * ) := '*****';
      = dmc$a6 =
        line (9, * ) := 'a6';
        line (12, * ) := '******';
      = dmc$a7 =
        line (9, * ) := 'a7';
        line (12, * ) := '*******';
      = dmc$a8 =
        line (9, * ) := 'a8';
        line (12, * ) := '********';
      = dmc$acyl =
        line (9, * ) := 'cy';
        line (12, * ) := '**********';
      ELSE
        line (12, * ) := 'NO STYLE';
      CASEND;

      styles_per_device [assigned_style] := styles_per_device [assigned_style] + 1;

      num_usable := dau_status_counts [dmc$dau_usable];
      num_assigned_file := dau_status_counts [dmc$dau_assigned_to_file];
      num_assigned_mf := dau_status_counts [dmc$dau_assigned_to_mainframe];
      num_flawed := dau_status_counts [dmc$dau_hardware_flawed] +
                    dau_status_counts [dmc$dau_software_flawed] +
                    dau_status_counts [dmc$dau_ass_to_mf_swr_flawed] +
                    dau_status_counts [dmc$dau_ass_to_file_swr_flawed];

      total_usable := total_usable + num_usable;
      total_assigned_file := total_assigned_file + num_assigned_file;
      total_assigned_mf := total_assigned_mf + num_assigned_mf;
      total_flawed := total_flawed + num_flawed;

      STRINGREP (line (23, 6), l, num_usable);
      STRINGREP (line (30, 6), l, num_assigned_file);
      STRINGREP (line (37, 6), l, num_assigned_mf);
      STRINGREP (line (44, 6), l, num_flawed);

      IF (num_assigned_file = p_dat^.header.daus_per_position) THEN
        line (50, * ) := 'FULL, ASSIGNED TO FILES';
      ELSEIF (num_assigned_mf = p_dat^.header.daus_per_position) THEN
        line (50, * ) := 'FULL, ASSIGNED TO MAINFRAME';
      ELSEIF (num_flawed = p_dat^.header.daus_per_position) THEN
        line (50, * ) := 'FULL, FLAWED';
      ELSEIF (num_usable = 0) THEN
        line (50, * ) := 'FULL, MIXED';
      IFEND;

      clp$put_display (display_control, line, clc$trim, status);

    FOREND /display_cylinders/;

{
{  Write summary (totals) information
{

    clp$new_display_line (display_control, 2, status);

    clp$put_display (display_control, '  TOTAL DAUS ON DEVICE :', clc$trim, status);
    clp$new_display_line (display_control, 1, status);
    line (1, * ) := ' ';
    STRINGREP (line, l, '   usable daus =', total_usable);
    clp$put_display (display_control, line, clc$trim, status);
    line (1, * ) := ' ';
    STRINGREP (line, l, '   daus assigned to file =', total_assigned_file);
    clp$put_display (display_control, line, clc$trim, status);
    line (1, * ) := ' ';
    STRINGREP (line, l, '   daus assigned to mainframe =', total_assigned_mf);
    clp$put_display (display_control, line, clc$trim, status);
    line (1, * ) := ' ';
    STRINGREP (line, l, '   flawed daus =', total_flawed);
    clp$put_display (display_control, line, clc$trim, status);

    clp$new_display_line (display_control, 1, status);
    clp$put_display (display_control, '  TOTAL CYLINDERS BY STYLE :', clc$trim, status);
    clp$new_display_line (display_control, 1, status);

    line (1, * ) := ' ';
    STRINGREP (line, l, '   a0=', styles_per_device [dmc$a0], ' a1=', styles_per_device [dmc$a1], ' a2=',
          styles_per_device [dmc$a2], ' a3=', styles_per_device [dmc$a3], ' a4=', styles_per_device [dmc$a4]);
    clp$put_display (display_control, line, clc$trim, status);

    line (1, * ) := ' ';
    STRINGREP (line, l, '   a5=', styles_per_device [dmc$a5], ' a6=', styles_per_device [dmc$a6], ' a7=',
          styles_per_device [dmc$a7], ' a8=', styles_per_device [dmc$a8], ' cyl=', styles_per_device
          [dmc$acyl]);
    clp$put_display (display_control, line, clc$trim, status);
    clp$new_display_line (display_control, 1, status);

    clp$put_display (display_control, ' END CYLINDERS', clc$trim, status);
    clp$new_display_line (display_control, 1, status);

    dmp$close_dat_r3 (p_dat, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

  PROCEND dmp$display_cylinders;
?? TITLE := '  dmp$reassign_file_r3', EJECT ??
  PROCEDURE [XDCL, #GATE] dmp$reassign_file_r3
    (    ptr: ^cell;
     VAR status: ost$status);

    VAR
      p_fde: gft$file_desc_entry_p,
      sdtxe_p: ^mmt$segment_descriptor_extended,
      system_file_id: gft$system_file_identifier,
      xcb_p: ^ost$execution_control_block;


    pmp$find_executing_task_xcb (xcb_p);
    sdtxe_p := mmp$get_sdtx_entry_p (xcb_p, #SEGMENT(ptr));
    system_file_id := sdtxe_p^.sfid;
    gfp$get_fde_p (system_file_id, p_fde);
    IF p_fde <> NIL THEN
      dmp$reassign_file (system_file_id, p_fde^.eoi_byte_address, status);
    IFEND;

  PROCEND dmp$reassign_file_r3;

MODEND dmm$display_device_files_r3;
