MODULE stm$display_ast_info;
?? RIGHT := 110 ??

?? NEWTITLE := 'Global Declarations Referenced by This Module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc stt$dm_packet_storage
*copyc stt$mel_index
?? POP ??
*copyc clp$put_display
*copyc pmp$convert_binary_unique_name
*copyc stp$obtain_ast_entry
*copyc stp$obtain_ast_member_list
*copyc stp$obtain_ast_size
?? OLDTITLE ??
?? NEWTITLE := '  [XDCL, #GATE] stp$display_sets', EJECT ??

  PROCEDURE [XDCL, #GATE] stp$display_sets
    (VAR display_control: clt$display_control;
     VAR status: ost$status);

    VAR
      ast_index: stt$ast_index,
      ast_size: integer;

    status.normal := TRUE;
    stp$obtain_ast_size (ast_size);
    FOR ast_index := 1 TO ast_size DO
      display_set_by_index (ast_index, display_control, status);
    FOREND;

  PROCEND stp$display_sets;
?? OLDTITLE ??
?? NEWTITLE := 'display_access_status', EJECT ??

  PROCEDURE display_access_status
    (VAR display_control: clt$display_control;
         access_status: stt$access_status);

    CASE access_status OF
    = stc$allow_access =
      display_message (display_control, 'Access_status = STC$ALLOW_ACCESS');
    = stc$deny_access =
      display_message (display_control, 'Access_status = STC$DENY_ACCESS');
    CASEND;

  PROCEND display_access_status;
?? OLDTITLE ??
?? NEWTITLE := 'display_activity', EJECT ??

  PROCEDURE display_activity
    (VAR display_control: clt$display_control;
         activity: stt$vol_activity_status);

    IF activity = stc$active THEN
      display_message (display_control, 'Set activity = STC$ACTIVE');
    ELSE
      display_message (display_control, 'Set activity = STC$INACTIVE');
    IFEND;

  PROCEND display_activity;
?? OLDTITLE ??
?? NEWTITLE := 'display_integer', 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;
?? OLDTITLE ??
?? NEWTITLE := 'display_member_list', EJECT ??

  PROCEDURE display_member_list
    (VAR display_control: clt$display_control;
         ast_index: stt$ast_index);

    VAR
      mel_index: stt$mel_index,
      member_entry: stt$member_entry,
      member_list_size: integer,
      p_member_list: ^stt$member_entry_list;

    PUSH p_member_list: [1 .. 1000];
    stp$obtain_ast_member_list (ast_index, p_member_list^, member_list_size);
    IF member_list_size = 0 THEN
      display_message (display_control, 'No member volumes ');
    ELSE
      display_integer (display_control, 'Member list size', member_list_size);
      FOR mel_index := 1 TO member_list_size DO
        IF mel_index > UPPERBOUND (p_member_list^) THEN
          display_message (display_control, 'Too many members to display ');
          RETURN; {----->
        IFEND;
        member_entry := p_member_list^ [mel_index];
        IF member_entry.entry_type = stc$valid THEN
          display_integer (display_control, '-------------- Member index ', mel_index);
          display_message (display_control, member_entry.member_vsn);
          display_unique_name (display_control, 'Member internal vsn', member_entry.member_internal_vsn);
          display_activity (display_control, member_entry.member_volume_activity.volume_activity_status);
          IF member_entry.member_volume_activity.volume_activity_status = stc$active THEN
            display_integer (display_control, 'Member avt index',
                  member_entry.member_volume_activity.avt_index);
          IFEND;
          display_packet_storage (display_control, member_entry.member_dm_packet_storage);
        IFEND;
      FOREND;
    IFEND;

  PROCEND display_member_list;
?? OLDTITLE ??
?? NEWTITLE := 'display_message', 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;
?? OLDTITLE ??
?? NEWTITLE := 'display_packet_storage', 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;
?? OLDTITLE ??
?? NEWTITLE := 'display_set_by_index', EJECT ??

  PROCEDURE display_set_by_index
    (    ast_index: stt$ast_index;
     VAR display_control: clt$display_control;
     VAR status: ost$status);

    VAR
      ast_entry: stt$active_set_entry;

    stp$obtain_ast_entry (ast_index, ast_entry, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;
    display_integer (display_control, '==== Active Set Table Index ===', ast_index);
    IF ast_entry.entry_type = stc$valid THEN
      display_message (display_control, ast_entry.set_name);
      display_message (display_control, ast_entry.master_vsn);
      display_unique_name (display_control, 'Unique set name ', ast_entry.unique_set_name);
      display_unique_name (display_control, 'Master internal vsn ', ast_entry.master_internal_vsn);
      display_access_status (display_control, ast_entry.access_status);
      IF ast_entry.master_ever_up THEN
        display_user_id (display_control, ast_entry.set_owner);
        display_integer (display_control, 'Number of jobs using set: ', ast_entry.number_of_jobs_using_set);
        IF ast_entry.pf_root_ever_stored THEN
          display_integer (display_control, 'PF root size: ', ast_entry.pf_root_size);
        ELSE
          display_message (display_control, 'PF root not stored ');
        IFEND;
        display_activity (display_control, ast_entry.master_volume_activity.volume_activity_status);
        IF ast_entry.master_volume_activity.volume_activity_status = stc$active THEN
          display_integer (display_control, 'Master avt index: ', ast_entry.master_volume_activity.avt_index);
        IFEND;
        display_packet_storage (display_control, ast_entry.master_dm_packet_storage);
      ELSE
        display_message (display_control, 'Master never active ');
      IFEND;
      display_member_list (display_control, ast_index);
    IFEND;

  PROCEND display_set_by_index;
?? OLDTITLE ??
?? NEWTITLE := 'display_unique_name', 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;
?? OLDTITLE ??
?? NEWTITLE := 'display_user_id', 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;
?? OLDTITLE ??
MODEND stm$display_ast_info;
