?? NEWTITLE := '  NOS/VE Set Management ' ??
MODULE stm$manage_set_utility;
?? RIGHT := 110 ??

{ PURPOSE:
{   Supports an SCL Utility to manage disk sets.
{
{   This allows the system manager to remove individual volumes from the set instead of
{   remove all inactive or none.

{**** need to also call it from stp$activate_set


?? NEWTITLE := 'Global Declarations Referenced By This Module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc oss$job_paged_literal
*copyc oss$task_private
*copyc ofe$error_codes
*copyc ste$error_condition_codes
*copyc clt$work_area
*copyc ost$date
*copyc ost$status
*copyc ost$time
*copyc pmt$os_name
*copyc stt$set_name
?? POP ??
*copyc fip#addl_initialize
*copyc fip#addl_integer
*copyc fip#addl_rjinteger
*copyc fip#addl_string

*copyc avp$configuration_administrator
*copyc avp$system_operator
*copyc clp$begin_utility
*copyc clp$build_path_subtitle
*copyc clp$build_standard_title
*copyc clp$close_display
*copyc clp$convert_integer_to_string
*copyc clp$count_list_elements
*copyc clp$end_include
*copyc clp$end_utility
*copyc clp$evaluate_parameters
*copyc clp$include_file
*copyc clp$new_display_line
*copyc clp$new_display_page
*copyc clp$open_display_reference
*copyc clp$put_display
*copyc clp$put_partial_display
*copyc clp$reset_for_next_display_page
*copyc clp$right_justify_string
*copyc clp$trimmed_string_size
*copyc cmp$get_unit_number_via_vsn
*copyc mmp$create_scratch_segment
*copyc mmp$delete_scratch_segment
*copyc osp$disestablish_cond_handler
*copyc osp$establish_block_exit_hndlr
*copyc osp$set_status_abnormal
*copyc pmp$convert_binary_unique_name
*copyc stp$get_element_name_via_lun
*copyc stp$r3_get_active_set_list
*copyc stp$r3_get_volumes_in_set
*copyc stp$r3_remove_inactive_members
*copyc amv$nil_file_identifier
*copyc clv$nil_display_control
?? OLDTITLE ??
?? NEWTITLE := 'Global Declarations Referenced By This Module', EJECT ??

  CONST
    c$utility_name = 'MANAGE_SET                     ';

  VAR
    v$active_set_name: stt$set_name := osc$null_name;

  TYPE
    t$display_option = (c$do_recorded_vsn, c$do_element_name, c$do_volume_activity, c$do_volume_kind,
          c$do_avt_index, c$do_internal_vsn, c$do_logical_unit_number, c$do_set_name),
    t$display_options = set of t$display_option,

    t$volume_selection = (c$vs_active_volumes, c$vs_inactive_volumes),
    t$volume_selections = set of t$volume_selection,

    t$volumes_selection = record
      selection: t$volume_selections,
      volumes_p: ^clt$data_value,
    recend;

  TYPE
    t$output_sizes = array [t$display_option] of 0 .. 255;

  VAR
    v$output_sizes: [READ, oss$job_paged_literal] t$output_sizes := [
{ C$DO_RECORDED_VSN          } 6,
{ C$DO_ELEMENT_NAME          } 31,
{ C$DO_VOLUME_ACTIVITY       } 8, {inactive
{ C$DO_VOLUME_KIND           } 13, {master volume / member volume
{ C$DO_AVT_INDEX             } 3,
{ C$DO_INTERNAL_VSN          } 31,
{ C$DO_LOGICAL_UNIT_NUMBER   } 3,
{ C$DO_SET_NAME              } 31];

  VAR
    v$labels: [READ, oss$job_paged_literal] array [t$display_option] of string (27) := [
{ C$DO_RECORDED_VSN          } 'Recorded VSN             : ',
{ C$DO_ELEMENT_NAME          } 'Element Name             : ',
{ C$DO_VOLUME_ACTIVITY       } 'Volume Activity          : ',
{ C$DO_VOLUME_KIND           } 'Volume Kind              : ',
{ C$DO_AVT_INDEX             } 'Active Volume Table Index: ',
{ C$DO_INTERNAL_VSN          } 'Internal VSN             : ',
{ C$DO_LOGICAL_UNIT_NUMBER   } 'Logical Unit Number      : ',
{ C$DO_SET_NAME              } 'Set Name                 : '];

  VAR
    work_area_p: ^clt$work_area;

?? OLDTITLE ??
?? NEWTITLE := 'P$DISPLAY_VOLUME', EJECT ??

  PROCEDURE p$display_volume
    (    display_options: t$display_options;
         volume_selections: t$volumes_selection;
         volume_list_display: boolean;
         output_file: fst$file_reference;
     VAR status: ost$status);

    TYPE
      t$output_kind = (c$ok_single_line_output, c$ok_line_per_volume, c$ok_page_per_volume);

    VAR
      default_ring_attributes: amt$ring_attributes,
      display_control: clt$display_control,
      display_option: t$display_option,
      display_options_count: integer,
      output_size: integer,
      output_kind: t$output_kind,
      i: integer,
      j: integer,
      master_volume_info: stt$volume_info,
      member_volume_list_p: ^stt$volume_list,
      member_volume_info_p: ^stt$volume_info,
      status_p: ^ost$status,
      str: ost$string;

*copy clv$display_variables

?? NEWTITLE := '[inline] F$RVSN_SELECTED', EJECT ??

    FUNCTION [INLINE] f$rvsn_selected
      (    recorded_vsn: rmt$recorded_vsn;
           volumes_p: ^clt$data_value): boolean;

      VAR
        element_value_p: ^clt$data_value,
        value_p: ^clt$data_value;

      IF volumes_p = NIL THEN
        f$rvsn_selected := TRUE;
        RETURN; {----->
      IFEND;

      value_p := volumes_p;
      WHILE (value_p <> NIL) AND (value_p^.kind = clc$list) DO
        element_value_p := value_p^.element_value;
        IF (element_value_p <> NIL) AND (element_value_p^.kind = clc$name) AND
              (element_value_p^.name_value = recorded_vsn) THEN
          f$rvsn_selected := TRUE;
          RETURN; {----->
        IFEND;
        value_p := value_p^.link;
      WHILEND;

      f$rvsn_selected := FALSE;

    FUNCEND f$rvsn_selected;
?? OLDTITLE ??
?? NEWTITLE := 'P$ABORT_HANDLER', EJECT ??

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

      VAR
        ignore_status: ost$status;

      clp$close_display (display_control, ignore_status);

    PROCEND p$abort_handler;

*copy clp$new_page_procedure
?? OLDTITLE ??
?? NEWTITLE := 'PUT_SUBTITLE ', EJECT ??

    PROCEDURE [INLINE] put_subtitle
      (VAR display_control: clt$display_control;
       VAR status: ost$status);

    PROCEND put_subtitle;
?? OLDTITLE ??
?? NEWTITLE := 'P$PUT_VOLUME', EJECT ??

    PROCEDURE p$put_volume
      (    master_volume: boolean;
           volume_info: stt$volume_info;
       VAR str: ost$string;
       VAR display_control: clt$display_control;
       VAR status: ost$status);

      VAR
        display_option: t$display_option,
        element_name: cmt$element_name,
        i: integer,
        local_status: ost$status,
        lun: iot$logical_unit,
        lun_found: boolean,
        name: ost$name;

      element_name := '';
      IF $t$display_options [c$do_element_name, c$do_logical_unit_number] <= display_options THEN
        cmp$get_unit_number_via_vsn (volume_info.recorded_vsn, lun, local_status);
        lun_found := local_status.normal;
        IF lun_found AND (c$do_element_name IN display_options) THEN
          stp$get_element_name_via_lun (lun, element_name, local_status);
        IFEND;
      IFEND;

      CASE output_kind OF
      = c$ok_single_line_output =
{for now, we only output the VSN in the single line output

        i := clp$trimmed_string_size (volume_info.recorded_vsn);
        IF str.size + i + 2 > clv$page_width THEN
          clp$put_display (display_control, str.value (1, str.size), clc$trim, status);
          IF NOT status.normal THEN
            RETURN; {----->
          IFEND;

          fip#addl_initialize (str, '');
        IFEND;
        fip#addl_string (str, volume_info.recorded_vsn (1, i));
        fip#addl_string (str, ', ');

      = c$ok_line_per_volume =
        fip#addl_initialize (str, '');
        FOR display_option := LOWERVALUE (display_option) TO UPPERVALUE (display_option) DO
          IF display_option IN display_options THEN
            CASE display_option OF
            = c$do_recorded_vsn =
              fip#addl_string (str, volume_info.recorded_vsn);

            = c$do_element_name =
              fip#addl_string (str, element_name);

            = c$do_volume_activity =
              IF volume_info.volume_activity.volume_activity_status = stc$active THEN
                fip#addl_string (str, 'Active  ');
              ELSE
                fip#addl_string (str, 'Inactive');
              IFEND;

            = c$do_avt_index =
              IF volume_info.volume_activity.volume_activity_status = stc$active THEN
                fip#addl_rjinteger (str, volume_info.volume_activity.avt_index, 3, ' ', local_status);
              ELSE
                fip#addl_string (str, '   ');
              IFEND;

            = c$do_internal_vsn =
              pmp$convert_binary_unique_name (volume_info.internal_vsn, name, local_status);
              IF NOT local_status.normal THEN
                name := '';
              IFEND;
              fip#addl_string (str, name);

            = c$do_logical_unit_number =
              IF lun_found THEN
                fip#addl_rjinteger (str, lun, 3, ' ', local_status);
              ELSE
                fip#addl_string (str, '   ');
              IFEND;

            = c$do_set_name =
              fip#addl_string (str, volume_info.set_name);

            = c$do_volume_kind =
              IF master_volume THEN
                fip#addl_string (str, 'Master Volume');
              ELSE
                fip#addl_string (str, 'Member Volume');
              IFEND;

            ELSE
            CASEND;
            fip#addl_string (str, '  ');
          IFEND;
        FOREND;

{Cut the trailing '  '
        IF str.size > 2 THEN
          str.size := str.size - 2;
        IFEND;
        clp$put_display (display_control, str.value (1, str.size), clc$trim, status);

      = c$ok_page_per_volume =
        FOR display_option := LOWERVALUE (display_option) TO UPPERVALUE (display_option) DO
          IF display_option IN display_options THEN
            fip#addl_initialize (str, v$labels [display_option]);
            CASE display_option OF
            = c$do_recorded_vsn =
              fip#addl_string (str, volume_info.recorded_vsn);

            = c$do_element_name =
              IF element_name <> '' THEN
                fip#addl_string (str, element_name);
              ELSE
                fip#addl_string (str, '"unspecified value"');
              IFEND;

            = c$do_volume_activity =
              IF volume_info.volume_activity.volume_activity_status = stc$active THEN
                fip#addl_string (str, 'Active  ');
              ELSE
                fip#addl_string (str, 'Inactive');
              IFEND;

            = c$do_avt_index =
              IF volume_info.volume_activity.volume_activity_status = stc$active THEN
                fip#addl_integer (str, volume_info.volume_activity.avt_index, local_status);
              ELSE
                fip#addl_string (str, '"unspecified value"');
              IFEND;

            = c$do_internal_vsn =
              pmp$convert_binary_unique_name (volume_info.internal_vsn, name, local_status);
              IF local_status.normal THEN
                fip#addl_string (str, name);
              ELSE
                fip#addl_string (str, '"unspecified value"');
              IFEND;

            = c$do_logical_unit_number =
              IF lun_found THEN
                fip#addl_integer (str, lun, local_status);
              ELSE
                fip#addl_string (str, '"unspecified value"');
              IFEND;

            = c$do_set_name =
              fip#addl_string (str, volume_info.set_name);

            = c$do_volume_kind =
              IF master_volume THEN
                fip#addl_string (str, 'Master Volume');
              ELSE
                fip#addl_string (str, 'Member Volume');
              IFEND;

            ELSE
            CASEND;

            clp$put_display (display_control, str.value (1, str.size), clc$trim, status);
            IF NOT status.normal THEN
              RETURN; {----->
            IFEND;
          IFEND;
        FOREND;

        IF (display_control.page_format = amc$burstable_form) OR
              (display_control.page_format = amc$non_burstable_form) THEN
          clp$new_display_page (display_control, status);

        ELSE
          clp$new_display_line (display_control, 2, status);
        IFEND;
      CASEND;

    PROCEND p$put_volume;
?? OLDTITLE ??
?? EJECT ??
    stp$r3_get_volumes_in_set (v$active_set_name, master_volume_info, member_volume_list_p, work_area_p,
          status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    display_control := clv$nil_display_control;
    #SPOIL (display_control);
    osp$establish_block_exit_hndlr (^p$abort_handler);

    default_ring_attributes.r1 := #RING (^default_ring_attributes);
    default_ring_attributes.r2 := #RING (^default_ring_attributes);
    default_ring_attributes.r3 := #RING (^default_ring_attributes);
    clp$open_display_reference (output_file, ^clp$new_page_procedure, fsc$list, default_ring_attributes,
          display_control, status);
    IF NOT status.normal THEN
      osp$disestablish_cond_handler;
      RETURN; {----->
    IFEND;

    clv$titles_built := FALSE;
    IF volume_list_display THEN
      clv$command_name := 'DISPLAY_VOLUME_LIST';
    ELSE
      clv$command_name := 'DISPLAY_VOLUME';
    IFEND;

    IF display_control.page_width < clc$narrow_page_width THEN
      clv$page_width := clc$narrow_page_width;
    ELSEIF display_control.page_width > clc$wide_page_width THEN
      clv$page_width := clc$wide_page_width;
    ELSE
      clv$page_width := display_control.page_width;
    IFEND;

{Determine output format
    display_options_count := 0;
    output_size := 0;
    FOR display_option := LOWERVALUE (display_option) TO UPPERVALUE (display_option) DO
      IF display_option IN display_options THEN
        output_size := output_size + v$output_sizes [display_option];
        display_options_count := display_options_count + 1;
      IFEND;
    FOREND;
    output_size := output_size + ((display_options_count - 1) * 2);

    IF volume_list_display THEN
      output_kind := c$ok_single_line_output;
      fip#addl_initialize (str, '');
    ELSEIF output_size <= clv$page_width THEN
      output_kind := c$ok_line_per_volume;
    ELSE
      output_kind := c$ok_page_per_volume;
    IFEND;

    IF (((c$vs_inactive_volumes IN volume_selections.selection) AND
          (master_volume_info.volume_activity.volume_activity_status = stc$inactive))
{    } OR ((c$vs_active_volumes IN volume_selections.selection) AND
          (master_volume_info.volume_activity.volume_activity_status = stc$active)))
{ } AND ((volume_selections.volumes_p = NIL) OR f$rvsn_selected
          (master_volume_info.recorded_vsn, volume_selections.volumes_p)) THEN

      p$put_volume (TRUE {Master} , master_volume_info, str, display_control, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;
    IFEND;


{*** Why the fuck does stp$get_volumes_in_set only return the master volume, when the master volume is
{    not active anymore? (I mean, it still has it in the set table)
{
{    I tried to create a set to see what happens (NTDD11), but then we crashed on ST - VST LOST DATA
{    see anad on other session

    IF member_volume_list_p <> NIL THEN
      FOR i := 1 TO UPPERBOUND (member_volume_list_p^) DO
        member_volume_info_p := ^member_volume_list_p^ [i];
        IF (((c$vs_inactive_volumes IN volume_selections.selection) AND
              (member_volume_info_p^.volume_activity.volume_activity_status = stc$inactive))
{        } OR ((c$vs_active_volumes IN volume_selections.selection) AND
              (member_volume_info_p^.volume_activity.volume_activity_status = stc$active)))
{     } AND ((volume_selections.volumes_p = NIL) OR f$rvsn_selected
              (member_volume_info_p^.recorded_vsn, volume_selections.volumes_p)) THEN

          p$put_volume (FALSE {Member} , member_volume_info_p^, str, display_control, status);
          IF NOT status.normal THEN
            RETURN; {----->
          IFEND;
        IFEND;
      FOREND;
    IFEND;

    IF (output_kind = c$ok_single_line_output) AND (str.size > 0) THEN
{remove trailing ", "
      str.size := str.size - 2;
      clp$put_display (display_control, str.value (1, str.size), clc$trim, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;
    IFEND;

    IF display_control.file_id <> amv$nil_file_identifier THEN
      IF status.normal THEN
        status_p := ^status;
      ELSE
        PUSH status_p;
      IFEND;
      clp$close_display (display_control, status_p^);
    IFEND;

    osp$disestablish_cond_handler;

  PROCEND p$display_volume;
?? OLDTITLE ??
?? NEWTITLE := 'P$_DELETE_INACTIVE_VOLUME', EJECT ??

  PROCEDURE p$_delete_inactive_volume
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{ PROCEDURE delete_inactive_volume (
{   recorded_vsn, rvsn: any of
{       key
{         all
{       keyend
{       list of name 1..6
{     anyend = $required
{   status)

?? PUSH (LISTEXT := ON) ??
?? FMT (FORMAT := OFF) ??

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 3] of clt$pdt_parameter_name,
      parameters: array [1 .. 2] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 1] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$list_type_qualifier_v2,
          element_type_spec: record
            header: clt$type_specification_header,
            qualifier: clt$name_type_qualifier,
          recend,
        recend,
      recend,
      type2: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [104, 3, 3, 9, 51, 8, 2],
    clc$command, 3, 2, 1, 0, 0, 0, 2, ''], [
    ['RECORDED_VSN                   ',clc$nominal_entry, 1],
    ['RVSN                           ',clc$abbreviation_entry, 1],
    ['STATUS                         ',clc$nominal_entry, 2]],
    [
{ PARAMETER 1
    [1, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 85, clc$required_parameter,
  0, 0],
{ PARAMETER 2
    [3, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$union_type], [[clc$keyword_type, clc$list_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['ALL                            ', clc$nominal_entry, clc$normal_usage_entry, 1]]
      ],
    21, [[1, 0, clc$list_type], [5, 1, clc$max_list_size, 0, FALSE, FALSE],
        [[1, 0, clc$name_type], [1, 6]]
      ]
    ],
{ PARAMETER 2
    [[1, 0, clc$status_type]]];

?? FMT (FORMAT := ON) ??
?? POP ??

    CONST
      p$recorded_vsn = 1,
      p$status = 2;

    VAR
      pvt: array [1 .. 2] of clt$parameter_value;

    VAR
      i: integer,
      members_to_remove: stt$inactive_members_to_remove,
      value_p: ^clt$data_value;

    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    members_to_remove.kind := stc$imtr_remove_none;
    IF pvt [p$recorded_vsn].value^.kind = clc$keyword THEN
      members_to_remove.kind := stc$imtr_remove_all_inactive;
    ELSE
      i := clp$count_list_elements (pvt [p$recorded_vsn].value);
      members_to_remove.kind := stc$imtr_remove_vsn_list;
      PUSH members_to_remove.vsn_list_p: [1 .. i];

      i := 1;
      value_p := pvt [p$recorded_vsn].value;
      WHILE (value_p <> NIL) AND (value_p^.kind = clc$list) DO
        IF (value_p^.element_value <> NIL) AND (value_p^.element_value^.kind = clc$name) THEN
          members_to_remove.vsn_list_p^ [i] := value_p^.element_value^.name_value;
        ELSE
          members_to_remove.vsn_list_p^ [i] := '';
        IFEND;
        i := i + 1;

        value_p := value_p^.link;
      WHILEND;
    IFEND;

    stp$r3_remove_inactive_members (members_to_remove, v$active_set_name, status);

  PROCEND p$_delete_inactive_volume;
?? OLDTITLE ??
?? NEWTITLE := 'P$_DISPLAY_ACTIVE_SET', EJECT ??

  PROCEDURE p$_display_active_set
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{ PROCEDURE display_active_set (
{   output, o: file = $output
{   status)

?? PUSH (LISTEXT := ON) ??
?? FMT (FORMAT := OFF) ??

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 3] of clt$pdt_parameter_name,
      parameters: array [1 .. 2] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
        default_value: string (7),
      recend,
      type2: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [104, 2, 24, 10, 43, 37, 924],
    clc$command, 3, 2, 0, 0, 0, 0, 2, ''], [
    ['O                              ',clc$abbreviation_entry, 1],
    ['OUTPUT                         ',clc$nominal_entry, 1],
    ['STATUS                         ',clc$nominal_entry, 2]],
    [
{ PARAMETER 1
    [2, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_default_parameter, 0, 7],
{ PARAMETER 2
    [3, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$file_type],
    '$output'],
{ PARAMETER 2
    [[1, 0, clc$status_type]]];

?? FMT (FORMAT := ON) ??
?? POP ??

    CONST
      p$output = 1,
      p$status = 2;

    VAR
      pvt: array [1 .. 2] of clt$parameter_value;

    VAR
      active_set_list_p: ^stt$set_list,
      default_ring_attributes: amt$ring_attributes,
      display_control: clt$display_control,
      status_p: ^ost$status,
      i: integer;

*copy clv$display_variables
?? NEWTITLE := 'P$ABORT_HANDLER', EJECT ??

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

      VAR
        ignore_status: ost$status;

      clp$close_display (display_control, ignore_status);

    PROCEND p$abort_handler;

*copy clp$new_page_procedure
?? TITLE := 'put_subtitle ', EJECT ??

    PROCEDURE [INLINE] put_subtitle
      (VAR display_control: clt$display_control;
       VAR status: ost$status);

    PROCEND put_subtitle;
?? OLDTITLE ??
?? EJECT ??
    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    display_control := clv$nil_display_control;
    #SPOIL (display_control);
    osp$establish_block_exit_hndlr (^p$abort_handler);

    default_ring_attributes.r1 := #RING (^default_ring_attributes);
    default_ring_attributes.r2 := #RING (^default_ring_attributes);
    default_ring_attributes.r3 := #RING (^default_ring_attributes);
    clp$open_display_reference (pvt [p$output].value^.file_value^, ^clp$new_page_procedure, fsc$list,
          default_ring_attributes, display_control, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    clv$titles_built := FALSE;
    clv$command_name := 'DISPLAY_ACTIVE_SETS';

    IF display_control.page_width < clc$narrow_page_width THEN
      clv$page_width := clc$narrow_page_width;
    ELSEIF display_control.page_width > clc$wide_page_width THEN
      clv$page_width := clc$wide_page_width;
    ELSE
      clv$page_width := display_control.page_width;
    IFEND;

    stp$r3_get_active_set_list (active_set_list_p, work_area_p, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF active_set_list_p = NIL THEN
      clp$put_display (display_control, 'No Sets defines on current Mainframe', clc$no_trim, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;
    ELSE
      FOR i := 1 TO UPPERBOUND (active_set_list_p^) DO
        clp$put_display (display_control, active_set_list_p^ [i], clc$trim, status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
      FOREND;
    IFEND;

    IF display_control.file_id <> amv$nil_file_identifier THEN
      IF status.normal THEN
        status_p := ^status;
      ELSE
        PUSH status_p;
      IFEND;
      clp$close_display (display_control, status_p^);
    IFEND;

    osp$disestablish_cond_handler;

  PROCEND p$_display_active_set;
?? OLDTITLE ??
?? NEWTITLE := 'P$_DISPLAY_VOLUME', EJECT ??

  PROCEDURE p$_display_volume
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{ PROCEDURE p$_display_volume (
{   volume, v, volume_selection, vs: any of
{       key
{         (active_volume, active_volumes, av)
{         (inactive_volume, inactive_volumes, iv)
{         all
{       keyend
{       list of name 1..6
{     anyend = inactive_volume
{   display_option, display_options, do: list of key
{       (recorded_vsn, rvsn)
{       (element_name, en)
{       (volume_activity, va)
{       (volume_kind, vk)
{     advanced_key
{       (avt_index, ai)
{       (internal_vsn, ivsn)
{       (logical_unit_number, lun)
{       (set_name, sn)
{     keyend = (recorded_vsn, volume_activity, volume_kind)
{   output, o: file = $output
{   status)

?? PUSH (LISTEXT := ON) ??
?? FMT (FORMAT := OFF) ??

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 10] of clt$pdt_parameter_name,
      parameters: array [1 .. 4] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 7] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$list_type_qualifier_v2,
          element_type_spec: record
            header: clt$type_specification_header,
            qualifier: clt$name_type_qualifier,
          recend,
        recend,
        default_value: string (15),
      recend,
      type2: record
        header: clt$type_specification_header,
        qualifier: clt$list_type_qualifier_v2,
        element_type_spec: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 16] of clt$keyword_specification,
        recend,
        default_value: string (44),
      recend,
      type3: record
        header: clt$type_specification_header,
        default_value: string (7),
      recend,
      type4: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [104, 3, 2, 12, 33, 33, 262],
    clc$command, 10, 4, 0, 0, 0, 0, 4, ''], [
    ['DISPLAY_OPTION                 ',clc$nominal_entry, 2],
    ['DISPLAY_OPTIONS                ',clc$alias_entry, 2],
    ['DO                             ',clc$abbreviation_entry, 2],
    ['O                              ',clc$abbreviation_entry, 3],
    ['OUTPUT                         ',clc$nominal_entry, 3],
    ['STATUS                         ',clc$nominal_entry, 4],
    ['V                              ',clc$alias_entry, 1],
    ['VOLUME                         ',clc$nominal_entry, 1],
    ['VOLUME_SELECTION               ',clc$alias_entry, 1],
    ['VS                             ',clc$abbreviation_entry, 1]],
    [
{ PARAMETER 1
    [8, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 307,
  clc$optional_default_parameter, 0, 15],
{ PARAMETER 2
    [1, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 615,
  clc$optional_default_parameter, 0, 44],
{ PARAMETER 3
    [5, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_default_parameter, 0, 7],
{ PARAMETER 4
    [6, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$union_type], [[clc$keyword_type, clc$list_type],
    FALSE, 2],
    266, [[1, 0, clc$keyword_type], [7], [
      ['ACTIVE_VOLUME                  ', clc$nominal_entry, clc$normal_usage_entry, 1],
      ['ACTIVE_VOLUMES                 ', clc$alias_entry, clc$normal_usage_entry, 1],
      ['ALL                            ', clc$nominal_entry, clc$normal_usage_entry, 3],
      ['AV                             ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
      ['INACTIVE_VOLUME                ', clc$nominal_entry, clc$normal_usage_entry, 2],
      ['INACTIVE_VOLUMES               ', clc$alias_entry, clc$normal_usage_entry, 2],
      ['IV                             ', clc$abbreviation_entry, clc$normal_usage_entry, 2]]
      ],
    21, [[1, 0, clc$list_type], [5, 1, clc$max_list_size, 0, FALSE, FALSE],
        [[1, 0, clc$name_type], [1, 6]]
      ]
    ,
    'inactive_volume'],
{ PARAMETER 2
    [[1, 0, clc$list_type], [599, 1, clc$max_list_size, 0, FALSE, FALSE],
      [[1, 0, clc$keyword_type], [16], [
      ['AI                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 5],
      ['AVT_INDEX                      ', clc$nominal_entry, clc$advanced_usage_entry, 5],
      ['ELEMENT_NAME                   ', clc$nominal_entry, clc$normal_usage_entry, 2],
      ['EN                             ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
      ['INTERNAL_VSN                   ', clc$nominal_entry, clc$advanced_usage_entry, 6],
      ['IVSN                           ', clc$abbreviation_entry, clc$advanced_usage_entry, 6],
      ['LOGICAL_UNIT_NUMBER            ', clc$nominal_entry, clc$advanced_usage_entry, 7],
      ['LUN                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 7],
      ['RECORDED_VSN                   ', clc$nominal_entry, clc$normal_usage_entry, 1],
      ['RVSN                           ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
      ['SET_NAME                       ', clc$nominal_entry, clc$advanced_usage_entry, 8],
      ['SN                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 8],
      ['VA                             ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
      ['VK                             ', clc$abbreviation_entry, clc$normal_usage_entry, 4],
      ['VOLUME_ACTIVITY                ', clc$nominal_entry, clc$normal_usage_entry, 3],
      ['VOLUME_KIND                    ', clc$nominal_entry, clc$normal_usage_entry, 4]]
      ]
    ,
    '(recorded_vsn, volume_activity, volume_kind)'],
{ PARAMETER 3
    [[1, 0, clc$file_type],
    '$output'],
{ PARAMETER 4
    [[1, 0, clc$status_type]]];

?? FMT (FORMAT := ON) ??
?? POP ??

    CONST
      p$volume = 1,
      p$display_option = 2,
      p$output = 3,
      p$status = 4;

    VAR
      pvt: array [1 .. 4] of clt$parameter_value;

    VAR
      display_options: t$display_options,
      volume_selections: t$volumes_selection;

?? NEWTITLE := 'P$EVALUATE_DISPLAY_OPTIONS', EJECT ??

    PROCEDURE p$evaluate_display_options
      (    data_value_p: ^clt$data_value;
       VAR display_options: t$display_options);

      VAR
        value_p: ^clt$data_value,
        element_p: ^clt$data_value;

      display_options := $t$display_options [];
      value_p := data_value_p;
      WHILE (value_p <> NIL) AND (value_p^.kind = clc$list) DO
        element_p := value_p^.element_value;
        IF (element_p <> NIL) AND (element_p^.kind = clc$keyword) THEN
          IF element_p^.keyword_value = 'RECORDED_VSN' THEN
            display_options := display_options + $t$display_options [c$do_recorded_vsn];
          ELSEIF element_p^.keyword_value = 'ELEMENT_NAME' THEN
            display_options := display_options + $t$display_options [c$do_element_name];
          ELSEIF element_p^.keyword_value = 'VOLUME_ACTIVITY' THEN
            display_options := display_options + $t$display_options [c$do_volume_activity];
          ELSEIF element_p^.keyword_value = 'AVT_INDEX' THEN
            display_options := display_options + $t$display_options [c$do_avt_index];
          ELSEIF element_p^.keyword_value = 'INTERNAL_VSN' THEN
            display_options := display_options + $t$display_options [c$do_internal_vsn];
          ELSEIF element_p^.keyword_value = 'LOGICAL_UNIT_NUMBER' THEN
            display_options := display_options + $t$display_options [c$do_logical_unit_number];
          ELSEIF element_p^.keyword_value = 'SET_NAME' THEN
            display_options := display_options + $t$display_options [c$do_set_name];
          ELSEIF element_p^.keyword_value = 'VOLUME_KIND' THEN
            display_options := display_options + $t$display_options [c$do_volume_kind];
          IFEND;
        IFEND;
        value_p := value_p^.link;
      WHILEND;

    PROCEND p$evaluate_display_options;
?? OLDTITLE ??
?? EJECT ??
    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    p$evaluate_display_options (pvt [p$display_option].value, display_options);

    IF pvt [p$volume].value^.kind = clc$keyword THEN
      IF pvt [p$volume].value^.keyword_value = 'ACTIVE_VOLUME' THEN
        volume_selections.selection := $t$volume_selections [c$vs_active_volumes];
      ELSEIF pvt [p$volume].value^.keyword_value = 'INACTIVE_VOLUME' THEN
        volume_selections.selection := $t$volume_selections [c$vs_inactive_volumes];
      ELSE
        volume_selections.selection := -$t$volume_selections [];
      IFEND;
      volume_selections.volumes_p := NIL;
    ELSE
      volume_selections.selection := -$t$volume_selections [];
      volume_selections.volumes_p := pvt [p$volume].value;
    IFEND;

    p$display_volume (display_options, volume_selections, FALSE {not list display} ,
          pvt [p$output].value^.file_value^, status);

  PROCEND p$_display_volume;
?? OLDTITLE ??
?? NEWTITLE := 'P$_DISPLAY_VOLUME_LIST', EJECT ??

  PROCEDURE p$_display_volume_list
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{ PROCEDURE p$_display_volume_list (
{   volume_selection, vs: key
{       (active_volume, active_volumes, av)
{       (inactive_volume, inactive_volumes, iv)
{       all
{     keyend = inactive_volume
{   output, o: file = $output
{   status)

?? PUSH (LISTEXT := ON) ??
?? FMT (FORMAT := OFF) ??

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 5] of clt$pdt_parameter_name,
      parameters: array [1 .. 3] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 7] of clt$keyword_specification,
        default_value: string (15),
      recend,
      type2: record
        header: clt$type_specification_header,
        default_value: string (7),
      recend,
      type3: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [104, 3, 2, 14, 16, 56, 402],
    clc$command, 5, 3, 0, 0, 0, 0, 3, ''], [
    ['O                              ',clc$abbreviation_entry, 2],
    ['OUTPUT                         ',clc$nominal_entry, 2],
    ['STATUS                         ',clc$nominal_entry, 3],
    ['VOLUME_SELECTION               ',clc$nominal_entry, 1],
    ['VS                             ',clc$abbreviation_entry, 1]],
    [
{ PARAMETER 1
    [4, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 266,
  clc$optional_default_parameter, 0, 15],
{ PARAMETER 2
    [2, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_default_parameter, 0, 7],
{ PARAMETER 3
    [3, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$keyword_type], [7], [
    ['ACTIVE_VOLUME                  ', clc$nominal_entry, clc$normal_usage_entry, 1],
    ['ACTIVE_VOLUMES                 ', clc$alias_entry, clc$normal_usage_entry, 1],
    ['ALL                            ', clc$nominal_entry, clc$normal_usage_entry, 3],
    ['AV                             ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
    ['INACTIVE_VOLUME                ', clc$nominal_entry, clc$normal_usage_entry, 2],
    ['INACTIVE_VOLUMES               ', clc$alias_entry, clc$normal_usage_entry, 2],
    ['IV                             ', clc$abbreviation_entry, clc$normal_usage_entry, 2]]
    ,
    'inactive_volume'],
{ PARAMETER 2
    [[1, 0, clc$file_type],
    '$output'],
{ PARAMETER 3
    [[1, 0, clc$status_type]]];

?? FMT (FORMAT := ON) ??
?? POP ??

    CONST
      p$volume_selection = 1,
      p$output = 2,
      p$status = 3;

    VAR
      pvt: array [1 .. 3] of clt$parameter_value;

    VAR
      display_options: t$display_options,
      volume_selections: t$volumes_selection;

    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    display_options := $t$display_options [c$do_recorded_vsn];
    volume_selections.volumes_p := NIL;
    IF pvt [p$volume_selection].value^.keyword_value = 'ACTIVE_VOLUME' THEN
      volume_selections.selection := $t$volume_selections [c$vs_active_volumes];
    ELSEIF pvt [p$volume_selection].value^.keyword_value = 'INACTIVE_VOLUME' THEN
      volume_selections.selection := $t$volume_selections [c$vs_inactive_volumes];
    ELSE
      volume_selections.selection := -$t$volume_selections [];
    IFEND;

    p$display_volume (display_options, volume_selections, TRUE {volume list display} ,
          pvt [p$output].value^.file_value^, status);

  PROCEND p$_display_volume_list;
?? OLDTITLE ??
?? NEWTITLE := 'P$_QUIT', EJECT ??

  PROCEDURE p$_quit
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{ PROCEDURE quit (
{   status)

?? PUSH (LISTEXT := ON) ??
?? FMT (FORMAT := OFF) ??

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 1] of clt$pdt_parameter_name,
      parameters: array [1 .. 1] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [104, 2, 19, 21, 14, 25, 906],
    clc$command, 1, 1, 0, 0, 0, 0, 1, ''], [
    ['STATUS                         ',clc$nominal_entry, 1]],
    [
{ PARAMETER 1
    [1, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$status_type]]];

?? FMT (FORMAT := ON) ??
?? POP ??

    CONST
      p$status = 1;

    VAR
      pvt: array [1 .. 1] of clt$parameter_value;

    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    clp$end_include (c$utility_name, status);

  PROCEND p$_quit;
?? OLDTITLE ??
?? NEWTITLE := '[xdcl] STP$_MANAGE_SET_UTILITY', EJECT ??

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

{ PROCEDURE manage_set_utility (
{   set_name, sn: name = $required
{   input, i: any of
{       key
{         command
{       keyend
{       file
{     anyend = $optional
{   status)

?? PUSH (LISTEXT := ON) ??
?? FMT (FORMAT := OFF) ??

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 5] of clt$pdt_parameter_name,
      parameters: array [1 .. 3] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
        qualifier: clt$name_type_qualifier,
      recend,
      type2: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 1] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
        recend,
      recend,
      type3: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [104, 2, 27, 14, 47, 55, 61],
    clc$command, 5, 3, 1, 0, 0, 0, 3, ''], [
    ['I                              ',clc$abbreviation_entry, 2],
    ['INPUT                          ',clc$nominal_entry, 2],
    ['SET_NAME                       ',clc$nominal_entry, 1],
    ['SN                             ',clc$abbreviation_entry, 1],
    ['STATUS                         ',clc$nominal_entry, 3]],
    [
{ PARAMETER 1
    [3, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 5, clc$required_parameter, 0
  , 0],
{ PARAMETER 2
    [2, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 67, clc$optional_parameter,
  0, 0],
{ PARAMETER 3
    [5, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$name_type], [1, osc$max_name_size]],
{ PARAMETER 2
    [[1, 0, clc$union_type], [[clc$file_type, clc$keyword_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['COMMAND                        ', clc$nominal_entry, clc$normal_usage_entry, 1]]
      ],
    3, [[1, 0, clc$file_type]]
    ],
{ PARAMETER 3
    [[1, 0, clc$status_type]]];

?? FMT (FORMAT := ON) ??
?? POP ??

    CONST
      p$set_name = 1,
      p$input = 2,
      p$status = 3;

    VAR
      pvt: array [1 .. 3] of clt$parameter_value;

{ table n=v$manage_set_commands t=command sn=oss$job_paged_literal
{ command n=(display_active_set, display_active_sets, disas) p=p$_display_active_set cm=local
{ command n=(display_volume, display_volumes, disv) p=p$_display_volume cm=local
{ command n=(display_volume_list, disvl) p=p$_display_volume_list cm=local
{ command n=(delete_inactive_volume, delete_inactive_volumes, deliv) p=p$_delete_inactive_volume cm=local
{ command n=(quit, qui) p=p$_quit cm=local
{ tablend

?? PUSH (LISTEXT := ON) ??

    VAR
      v$manage_set_commands: [STATIC, READ, oss$job_paged_literal] ^clt$command_table :=
            ^v$manage_set_commands_entries,

      v$manage_set_commands_entries: [STATIC, READ, oss$job_paged_literal] array [1 .. 13] of
            clt$command_table_entry := [
            {} ['DELETE_INACTIVE_VOLUME         ', clc$nominal_entry, clc$normal_usage_entry, 4,
            clc$automatically_log, clc$linked_call, ^p$_delete_inactive_volume],
            {} ['DELETE_INACTIVE_VOLUMES        ', clc$alias_entry, clc$normal_usage_entry, 4,
            clc$automatically_log, clc$linked_call, ^p$_delete_inactive_volume],
            {} ['DELIV                          ', clc$abbreviation_entry, clc$normal_usage_entry, 4,
            clc$automatically_log, clc$linked_call, ^p$_delete_inactive_volume],
            {} ['DISAS                          ', clc$abbreviation_entry, clc$normal_usage_entry, 1,
            clc$automatically_log, clc$linked_call, ^p$_display_active_set],
            {} ['DISPLAY_ACTIVE_SET             ', clc$nominal_entry, clc$normal_usage_entry, 1,
            clc$automatically_log, clc$linked_call, ^p$_display_active_set],
            {} ['DISPLAY_ACTIVE_SETS            ', clc$alias_entry, clc$normal_usage_entry, 1,
            clc$automatically_log, clc$linked_call, ^p$_display_active_set],
            {} ['DISPLAY_VOLUME                 ', clc$nominal_entry, clc$normal_usage_entry, 2,
            clc$automatically_log, clc$linked_call, ^p$_display_volume],
            {} ['DISPLAY_VOLUMES                ', clc$alias_entry, clc$normal_usage_entry, 2,
            clc$automatically_log, clc$linked_call, ^p$_display_volume],
            {} ['DISPLAY_VOLUME_LIST            ', clc$nominal_entry, clc$normal_usage_entry, 3,
            clc$automatically_log, clc$linked_call, ^p$_display_volume_list],
            {} ['DISV                           ', clc$abbreviation_entry, clc$normal_usage_entry, 2,
            clc$automatically_log, clc$linked_call, ^p$_display_volume],
            {} ['DISVL                          ', clc$abbreviation_entry, clc$normal_usage_entry, 3,
            clc$automatically_log, clc$linked_call, ^p$_display_volume_list],
            {} ['QUI                            ', clc$abbreviation_entry, clc$normal_usage_entry, 5,
            clc$automatically_log, clc$linked_call, ^p$_quit],
            {} ['QUIT                           ', clc$nominal_entry, clc$normal_usage_entry, 5,
            clc$automatically_log, clc$linked_call, ^p$_quit]];

?? POP ??

    VAR
      utility_attributes: array [1 .. 3] of clt$utility_attribute;

?? NEWTITLE := 'P$ABORT_HANDLER', EJECT ??

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

      p$delete_work_area (work_area_p);

    PROCEND p$abort_handler;
?? OLDTITLE ??
?? NEWTITLE := '[inline] P$CREATE_WORK_AREA', EJECT ??

    PROCEDURE [INLINE] p$create_work_area
      (VAR work_area_p: ^clt$work_area;
       VAR status: ost$status);

      VAR
        segment_pointer: amt$segment_pointer;

      mmp$create_scratch_segment (amc$sequence_pointer, mmc$as_sequential, segment_pointer, status);
      IF status.normal THEN
        work_area_p := segment_pointer.sequence_pointer;
      IFEND;

    PROCEND p$create_work_area;
?? OLDTITLE ??
?? NEWTITLE := '[inline] P$DELETE_WORK_AREA', EJECT ??

    PROCEDURE [INLINE] p$delete_work_area
      (VAR work_area_p: ^clt$work_area);

      VAR
        segment_pointer: amt$segment_pointer,
        ignore_status: ost$status;

      segment_pointer.kind := amc$sequence_pointer;
      segment_pointer.sequence_pointer := work_area_p;
      mmp$delete_scratch_segment (segment_pointer, ignore_status);

    PROCEND p$delete_work_area;
?? OLDTITLE ??
?? NEWTITLE := 'P$INIT_UTILITY', EJECT ??

    PROCEDURE p$init_utility
      (    set_name: stt$set_name;
       VAR status: ost$status);

?? NEWTITLE := 'P$VALIDATE_SET_NAME', EJECT ??

      PROCEDURE p$validate_set_name
        (    set_name: stt$set_name;
         VAR status: ost$status);

        VAR
          active_set_list_p: ^stt$set_list,
          i: integer;

        stp$r3_get_active_set_list (active_set_list_p, work_area_p, status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;

        IF active_set_list_p <> NIL THEN

        /validate_set_name/
          FOR i := 1 TO UPPERBOUND (active_set_list_p^) DO
            IF active_set_list_p^ [i] = set_name THEN
              v$active_set_name := active_set_list_p^ [i];
              RETURN; {----->
            IFEND;
          FOREND /validate_set_name/;
        IFEND;

        osp$set_status_abnormal ('ST', ste$bad_set_name, set_name, status);

      PROCEND p$validate_set_name;
?? OLDTITLE ??
?? EJECT ??
      p$create_work_area (work_area_p, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;

      p$validate_set_name (set_name, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;

      utility_attributes [1].key := clc$utility_command_table;
      utility_attributes [1].command_table := v$manage_set_commands;
      utility_attributes [2].key := clc$utility_prompt;
      utility_attributes [2].prompt.value := 'MANS';
      utility_attributes [2].prompt.size := 4;
      utility_attributes [3].key := clc$utility_termination_command;
      utility_attributes [3].termination_command := 'quit';
{     utility_attributes [4].key := clc$utility_function_proc_table;
{     utility_attributes [4].function_processor_table := ;

      clp$begin_utility (c$utility_name, utility_attributes, status);

    PROCEND p$init_utility;
?? OLDTITLE ??
?? EJECT ??
    IF NOT (avp$configuration_administrator () OR avp$system_operator ()) THEN
      osp$set_status_abnormal ('OF', ofe$sou_not_active, 'configuration_administration, system_operation',
            status);
      RETURN; {----->
    IFEND;

    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    work_area_p := NIL;
    p$init_utility (pvt [p$set_name].value^.name_value, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    osp$establish_block_exit_hndlr (^p$abort_handler);

    IF (NOT pvt [p$input].specified) OR (pvt [p$input].value = NIL) THEN
      clp$include_file (clc$current_command_input, {ignore prompt} '', c$utility_name, status);

    ELSEIF pvt [p$input].value^.kind = clc$file THEN
      clp$include_file (pvt [p$input].value^.file_value^, {ignore prompt} '', c$utility_name, status);

    ELSE {keyword command
      clp$include_file (clc$job_command_input, {ignore prompt} '', c$utility_name, status);
    IFEND;
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    clp$end_utility (c$utility_name, status);

    p$delete_work_area (work_area_p);
    osp$disestablish_cond_handler;

  PROCEND stp$_manage_set_utility;
?? OLDTITLE ??
MODEND stm$manage_set_utility;


