?? LEFT := 1, RIGHT := 110 ??
MODULE stm$display_volume_info;
{this procedure runs in ring 2             }
?? PUSH (LISTEXT := ON) ??
*copyc dmt$internal_vsn
*copyc gft$system_file_identifier
*copyc ost$status
*copyc stt$dm_packet_storage
*copyc stt$member_vsn_list
*copyc stt$number_of_members
?? POP ??
*copyc clp$put_display
*copyc pmp$convert_binary_unique_name
*copyc stp$obtain_master_vst_info
*copyc stp$obtain_member_vst_info
*copyc stp$obtain_vst_header
*copyc stp$open_vst
*copyc stp$return_opened_vst
?? EJECT ??

  PROCEDURE [XDCL, #GATE] stp$display_vol_set_table
    (    volume: rmt$recorded_vsn;
     VAR display_control: clt$display_control;
     VAR status: ost$status);

    VAR
      p_vst: ^stt$vol_set_table,
      sfid: gft$system_file_identifier,
      vst_segment_pointer: mmt$segment_pointer;

    stp$open_vst (volume, FALSE, sfid, vst_segment_pointer, status);
    IF status.normal THEN
      p_vst := vst_segment_pointer.cell_pointer;
      display_vst (display_control, p_vst, status);
      stp$return_opened_vst (sfid, vst_segment_pointer, status);
    IFEND;
  PROCEND stp$display_vol_set_table;
?? EJECT ??

  PROCEDURE display_integer
    (VAR display_control: clt$display_control;
         descriptor: string ( * );
         number: integer);

    VAR
      length: integer,
      display_string: string (80);

    STRINGREP (display_string, length, descriptor, number);
    display_message (display_control, display_string (1, length));
  PROCEND display_integer;
?? EJECT ??

  PROCEDURE display_message
    (VAR display_control: clt$display_control;
         message: string ( * ));

    VAR
      status: ost$status;

    clp$put_display (display_control, message, clc$no_trim, status);
  PROCEND display_message;
?? EJECT ??

  PROCEDURE display_packet_storage
    (VAR display_control: clt$display_control;
         dm_packet_storage: stt$dm_packet_storage);

    IF dm_packet_storage.dm_packet_ever_stored THEN
      display_integer (display_control, 'Device Manager packet length ', dm_packet_storage.dm_packet);
    ELSE
      display_message (display_control, 'NO Device Manager Packet stored');
    IFEND;
  PROCEND display_packet_storage;
?? EJECT ??

  PROCEDURE display_unique_name
    (VAR display_control: clt$display_control;
         ds: string ( * );
         internal_vsn: dmt$internal_vsn);

    VAR
      displayable_name: ost$name,
      display_string: string (80),
      length: integer,
      status: ost$status;

    pmp$convert_binary_unique_name (internal_vsn, displayable_name, status);
    IF status.normal THEN
      STRINGREP (display_string, length, ds, ' ', displayable_name);
      display_message (display_control, display_string (1, length));
    ELSE
      display_message (display_control, ds);
      display_message (display_control, 'Unexpected internal vsn ');
    IFEND;

  PROCEND display_unique_name;
?? EJECT ??

  PROCEDURE display_user_id
    (VAR display_control: clt$display_control;
         user_id: ost$user_identification);

    VAR
      display_string: string (80),
      length: integer;

    STRINGREP (display_string, length, 'Owner ', user_id.family, ' ', user_id.user);
    display_message (display_control, display_string (1, length));
  PROCEND display_user_id;

?? EJECT ??

  PROCEDURE display_vsn_list
    (VAR display_control: clt$display_control;
         p_member_vsn_list: ^stt$member_vsn_list;
         size_of_member_list: stt$number_of_members);

    VAR
      member_vsn_entry: stt$member_vsn_entry,
      mvl_index: integer;

    display_message (display_control, '===  Member vsn list ');

  /loop_through_list/
    FOR mvl_index := 1 TO size_of_member_list DO
      member_vsn_entry := p_member_vsn_list^ [mvl_index];
      IF mvl_index > UPPERBOUND (p_member_vsn_list^) THEN
        display_integer (display_control, 'To many members ', size_of_member_list);
        EXIT /loop_through_list/;
      IFEND;
      IF member_vsn_entry.entry_type = stc$valid THEN
        display_integer (display_control, '--- Member volume index', mvl_index);
        display_message (display_control, member_vsn_entry.member_vsn);
        display_unique_name (display_control, 'Member internal vsn ', member_vsn_entry.member_internal_vsn);
        display_packet_storage (display_control, member_vsn_entry.member_dm_packet_storage);
      IFEND;
    FOREND /loop_through_list/;
  PROCEND display_vsn_list;
?? EJECT ??

  PROCEDURE display_vst
    (VAR display_control: clt$display_control;
         p_vst: ^stt$vol_set_table;
     VAR status: ost$status);

    VAR
      display_string: string (80),
      dm_packet_storage: stt$dm_packet_storage,
      internal_vsn: dmt$internal_vsn,
      length: integer,
      master_vsn: rmt$recorded_vsn,
      new_p_member_vsn_list: ^stt$member_vsn_list,
      p_member_list: ^array [ * ] of stt$member_vsn_entry,
      pf_root_ever_stored: boolean,
      pf_root_locator: stt$pf_root_locator,
      pf_root_size: pft$root_size,
      set_name: stt$set_name,
      set_owner: ost$user_identification,
      size_of_member_list: stt$number_of_members,
      unique_set_name: stt$unique_set_name,
      volume: rmt$recorded_vsn,
      volume_in_set: boolean,
      volume_status_in_set: stt$vol_status_in_set;

    display_message (display_control, '======== Volume Set Table ========');
    stp$obtain_vst_header (p_vst, volume, internal_vsn, volume_in_set, set_name, unique_set_name,
          volume_status_in_set);
    display_message (display_control, volume);
    display_unique_name (display_control, 'Internal vsn ', internal_vsn);
    IF volume_in_set THEN
      display_message (display_control, set_name);
      display_unique_name (display_control, 'Unique set name ', unique_set_name);
      IF volume_status_in_set = stc$member_vol THEN
        display_message (display_control, 'Volume status in set = Member volume');
        stp$obtain_member_vst_info (p_vst, master_vsn, internal_vsn);
        STRINGREP (display_string, length, 'Master_vsn = ', master_vsn);
        display_message (display_control, display_string (1, length));
        display_unique_name (display_control, 'Master internal vsn', internal_vsn);
      ELSE
        display_message (display_control, 'Volume status in set = Master volume');
        PUSH p_member_list: [1 .. 1000];
        stp$obtain_master_vst_info (p_vst, set_owner, dm_packet_storage, p_member_list^, size_of_member_list,
              pf_root_ever_stored, pf_root_size, pf_root_locator);
        display_packet_storage (display_control, dm_packet_storage);
        IF pf_root_ever_stored THEN
          display_integer (display_control, 'PF root size', pf_root_size);
        ELSE
          display_message (display_control, 'PF root not stored');
        IFEND;
        display_user_id (display_control, set_owner);
        IF p_vst^.root_recreated = stc$root_recreated THEN
          display_message (display_control, 'Root recreated ');
        ELSEIF p_vst^.root_recreated = stc$root_not_recreated THEN
          display_message (display_control, 'Root NOT recreated ');
        ELSE
          display_message (display_control, 'Unitialized root_recreated ');
        IFEND;
        display_vsn_list (display_control, p_member_list, size_of_member_list);
      IFEND;
    ELSE
      display_message (display_control, 'Entry type = STC$INVALID ');
    IFEND;
  PROCEND display_vst;

MODEND stm$display_volume_info;
