?? RIGHT := 110 ??
*copyc osd$default_pragmats
?? NEWTITLE := ' NOS/VE Backup/Restore Utilities:  crack_values ', EJECT ??
MODULE pum$crack_values;
{
{  This module contains to crack common parameters on backup and
{  restore subcommands.
{
?? NEWTITLE := '   Global Declarations', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc pus$literals
*copyc fsc$local
*copyc pud$cycle_reference
*copyc rmd$volume_declarations
*copyc cle$ecc_file_reference
*copyc cle$ecc_miscellaneous
*copyc cle$ecc_parameter_list
*copyc cle$ecc_proc_declaration
*copyc pue$error_condition_codes
*copyc amt$local_file_name
*copyc clt$file_reference
*copyc clt$value
*copyc ost$date_time
*copyc ost$name
*copyc ost$status
*copyc pft$array_index
*copyc pft$cycle_selector
*copyc pft$password
*copyc pft$path
*copyc put$user_range_list
?? POP ??
*copyc clp$convert_cyc_ref_to_cyc_sel
*copyc clp$convert_str_to_path_handle
*copyc clp$get_fs_path_elements
*copyc clp$get_parameter
*copyc clp$get_path_description
*copyc clp$get_set_count
*copyc clp$get_value
*copyc clp$test_range
*copyc fsp$convert_fs_structure_to_pf
*copyc fsp$evaluate_file_reference
*copyc osp$append_status_integer
*copyc osp$append_status_parameter
*copyc osp$set_status_abnormal
*copyc pmp$get_user_identification
?? TITLE := '    [XDCL] pup$crack_backup_file ', EJECT ??

  PROCEDURE [XDCL] pup$crack_backup_file
    (    file: fst$file_reference;
     VAR backup_file_phn: fst$path_handle_name;
     VAR status: ost$status);

{ The purpose of this routine is to crack a refernece of the type
{     <file>
{ Here the utility is only interested in obtaining an lfn, and does not
{ retain the path.
{ No file position may be specified.

    VAR
      evaluated_file_reference: fst$evaluated_file_reference;

    clp$convert_str_to_path_handle (file, FALSE {NOT delete_allowed} , FALSE {NOT resolve_path} , FALSE
          {NOT include_open_pos_in_handle} , backup_file_phn, evaluated_file_reference, status);
    IF status.normal THEN
      IF evaluated_file_reference.path_handle_info.path_handle.open_position.specified THEN
        osp$set_status_abnormal (puc$pf_utility_id, pue$unexpected_file_position, 'BACKUP_FILE', status);
      IFEND;
    IFEND;
  PROCEND pup$crack_backup_file;
?? TITLE := '    [XDCL] pup$crack_boolean ', EJECT ??

  PROCEDURE [XDCL] pup$crack_boolean
    (    parameter_name: string ( * );
     VAR boolean_value: boolean;
     VAR status: ost$status);

    VAR
      value: clt$value;

    boolean_value := TRUE;
    clp$get_value (parameter_name, 1, 1, clc$low, value, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    boolean_value := value.bool.value;
  PROCEND pup$crack_boolean;

?? TITLE := '    [XDCL] pup$crack_catalog ', EJECT ??

  PROCEDURE [XDCL] pup$crack_catalog
    (    parameter_name: string ( * );
     VAR path_container: clt$path_container;
     VAR p_path: ^pft$path;
     VAR status: ost$status);

{ The purpose of this routine is to crack a reference of the type
{     < catalog>
{ Callers are responsible for validating the length of the path returned.
{ No file position or cycle selector may be specified.
{

    VAR
      cycle_selector: pft$cycle_selector,
      cycle_selector_specified: boolean,
      value: clt$value;

    clp$get_value (parameter_name, 1, 1, clc$low, value, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    IF value.kind = clc$unknown_value THEN
      p_path := NIL;
      RETURN;
    IFEND;
    crack_path (value, parameter_name, pfc$family_name_index,
          $put$cycle_reference_selections [puc$cycle_omitted], path_container, p_path,
          cycle_selector_specified, cycle_selector, status);
  PROCEND pup$crack_catalog;
?? TITLE := '    [XDCL] pup$crack_file ', EJECT ??

  PROCEDURE [XDCL] pup$crack_file
    (    parameter_name: string ( * );
     VAR file_lfn: amt$local_file_name;
     VAR status: ost$status);

{ The purpose of this routine is to crack a refernece of the type
{     <file>
{ Here the utilities is only interested in obtaining a lfn, and does not
{ retain the path.
{ No file position may be specified.

    VAR
      cycle_selector: clt$cycle_selector,
      file_reference: clt$file_reference,
      open_position: clt$open_position,
      p_path: ^pft$path,
      path_container: clt$path_container,
      value: clt$value;

    clp$get_value (parameter_name, 1, 1, clc$low, value, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    IF value.kind = clc$unknown_value THEN
      p_path := NIL;
      RETURN;
    IFEND;
    clp$get_path_description (value.file, file_reference, path_container, p_path, cycle_selector,
          open_position, status);
    IF status.normal THEN
      IF open_position.specified THEN
        osp$set_status_abnormal (puc$pf_utility_id, pue$unexpected_file_position, parameter_name, status);
      ELSE
        file_lfn := value.file.local_file_name;
      IFEND;
    IFEND;
  PROCEND pup$crack_file;
?? TITLE := '    [XDCL] pup$crack_file_reference ', EJECT ??

  PROCEDURE [XDCL] pup$crack_file_reference
    (    parameter_name: string ( * );
     VAR lfn: amt$local_file_name;
     VAR status: ost$status);

{ The purpose of this routine is to crack a reference of the type
{     < file reference>
{ All defaulting of file position and dealing of a path (if specified)
{ will be handled by the BAM file routines.
{

    VAR
      value: clt$value;

    clp$get_value (parameter_name, 1, 1, clc$low, value, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    lfn := value.file.local_file_name;
  PROCEND pup$crack_file_reference;
?? TITLE := '    [XDCL] pup$crack_name_list ', EJECT ??

  PROCEDURE [XDCL] pup$crack_name_list
    (    parameter_name: string ( * );
     VAR name_list_container: SEQ (REP 20 of ost$name);
     VAR p_name_list: ^array [1 .. * ] of ost$name;
     VAR status: ost$status);

    VAR
      i: integer,
      number_of_names: 0 .. clc$max_value_sets,
      p_name_list_container: ^SEQ (REP 20 of ost$name),
      value: clt$value;

    clp$get_set_count (parameter_name, number_of_names, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    p_name_list := NIL;
    IF number_of_names > 0 THEN
      IF number_of_names > (#SIZE (name_list_container) DIV #SIZE (ost$name)) THEN
        osp$set_status_abnormal (puc$pf_utility_id, cle$too_many_values, parameter_name, status);
        RETURN;
      ELSE
        p_name_list_container := ^name_list_container;
        RESET p_name_list_container;
        NEXT p_name_list: [1 .. number_of_names] IN p_name_list_container;
      IFEND;
    IFEND;
    FOR i := 1 TO number_of_names DO
      clp$get_value (parameter_name, i, 1, clc$low, value, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      p_name_list^ [i] := value.name.value;
    FOREND;
  PROCEND pup$crack_name_list;
?? TITLE := '    [XDCL] pup$crack_password ', EJECT ??

  PROCEDURE [XDCL] pup$crack_password
    (    parameter_name: string ( * );
     VAR password: pft$password;
     VAR status: ost$status);

{  This routine defaults a password if it was not specified.

    VAR
      value: clt$value;

    clp$get_value (parameter_name, 1, 1, clc$low, value, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    IF value.name.value = 'NONE' THEN
      password := osc$null_name;
    ELSE
      password := value.name.value;
    IFEND;
  PROCEND pup$crack_password;
?? TITLE := '    [XDCL] pup$crack_permanent_file ', EJECT ??

  PROCEDURE [XDCL] pup$crack_permanent_file
    (    parameter_name: string ( * );
         allowed_cycle_references: put$cycle_reference_selections;
     VAR path_container: clt$path_container;
     VAR p_path: ^pft$path;
     VAR cycle_selector_specified: boolean;
     VAR cycle_selector: pft$cycle_selector;
     VAR status: ost$status);

{ The purpose of this routine is to crack a reference of the type
{     < file>
{ Here the utility needs the path, and cycle selector.
{ No file position may be specified.
{ The path must contain at least pfc$master_catalog_name_index + 1
{ number of names.
{

    VAR
      value: clt$value;


    clp$get_value (parameter_name, 1, 1, clc$low, value, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    IF value.kind = clc$unknown_value THEN
      p_path := NIL;
      RETURN;
    IFEND;

    crack_path (value, parameter_name, pfc$master_catalog_name_index + 1, allowed_cycle_references,
          path_container, p_path, cycle_selector_specified, cycle_selector, status);
  PROCEND pup$crack_permanent_file;

?? TITLE := '    [XDCL] pup$crack_pf_file_reference ', EJECT ??

  PROCEDURE [XDCL] pup$crack_pf_file_reference
    (    file: fst$file_reference;
         allowed_cycle_references: put$cycle_reference_selections;
         parameter_name: string(*);
     VAR path_container: clt$path_container;
     VAR p_path: ^pft$path;
     VAR cycle_selector_specified: boolean;
     VAR cycle_selector: pft$cycle_selector;
     VAR status: ost$status);

{ The purpose of this routine is to crack a reference of the type
{     < file>
{ Here the utility needs the path, and cycle selector.
{ No file position may be specified.
{ The path must contain at least pfc$master_catalog_name_index + 1
{ number of names.
{

    VAR
      cl_cycle_selector: clt$cycle_selector,
      evaluated_file_reference: fst$evaluated_file_reference,
      maximum_path_elements_allowed: integer,
      p_path_container: ^clt$path_container;

    status.normal := TRUE;
    fsp$evaluate_file_reference (file, FALSE {NOT command_file_reference_allowed} , evaluated_file_reference,
          status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    IF parameter_name = 'CATALOG' THEN
      maximum_path_elements_allowed := pfc$master_catalog_name_index;
    ELSE
      maximum_path_elements_allowed := pfc$master_catalog_name_index + 1;
    IFEND;

    p_path_container := ^path_container;
    RESET p_path_container;
    NEXT p_path: [1 .. evaluated_file_reference.number_of_path_elements] IN p_path_container;
    fsp$convert_fs_structure_to_pf (evaluated_file_reference, p_path);

    IF p_path^ [1] = fsc$local THEN
      osp$set_status_abnormal (puc$pf_utility_id, cle$not_permitted_on_loc_file, 'backup or restore', status);
    ELSE
      IF (UPPERBOUND (p_path^)) < maximum_path_elements_allowed THEN
        osp$set_status_abnormal (puc$pf_utility_id, pue$path_too_short, parameter_name, status);
        osp$append_status_parameter (osc$status_parameter_delimiter, p_path^ [1], status);
      ELSEIF evaluated_file_reference.path_handle_info.path_handle.open_position.specified THEN
        osp$set_status_abnormal (puc$pf_utility_id, pue$unexpected_file_position, 'FILE', status);
      ELSE
        clp$convert_cyc_ref_to_cyc_sel (evaluated_file_reference.cycle_reference, cl_cycle_selector);
        verify_cycle_selection (parameter_name, allowed_cycle_references, cl_cycle_selector, status);
        IF status.normal THEN
          cycle_selector_specified := cl_cycle_selector.specification <> clc$cycle_omitted;
          IF cycle_selector_specified THEN
            cycle_selector := cl_cycle_selector.value;
          IFEND;
        IFEND;
      IFEND;
    IFEND;

  PROCEND pup$crack_pf_file_reference;
?? TITLE := '    [XDCL] pup$crack_user_range_list ', EJECT ??

  PROCEDURE [XDCL] pup$crack_user_range_list
    (    parameter_name: string ( * );
     VAR uncracked_parameter: ost$string;
     VAR list_container: put$user_range_list_container;
     VAR p_user_range_list: ^put$user_range_list;
     VAR status: ost$status);

    VAR
      all_specified: boolean,
      default_names: [STATIC, READ, pus$literals] array [clt$low_or_high] of ost$name :=
            [puc$default_low_name, puc$default_high_name],
      number_of_ranges_specified: 0 .. clc$max_value_sets,
      p_list_container: ^put$user_range_list_container,
      range_element: clt$low_or_high,
      user_range_index: 1 .. clc$max_value_sets,
      value: clt$value;

    clp$get_parameter (parameter_name, uncracked_parameter, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    check_first_value_for_all (parameter_name, number_of_ranges_specified, all_specified, status);
    IF (NOT status.normal) OR all_specified THEN
      p_user_range_list := NIL;
      RETURN;
    IFEND;

    p_list_container := ^list_container;
    RESET p_list_container;
    NEXT p_user_range_list: [1 .. number_of_ranges_specified] IN p_list_container;

    FOR user_range_index := 1 TO number_of_ranges_specified DO
      FOR range_element := clc$low TO clc$high DO
        clp$get_value (parameter_name, user_range_index, 1, range_element, value, status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;
        IF value.kind <> clc$file_value THEN
          osp$set_status_abnormal (puc$pf_utility_id, cle$all_must_be_used_alone, parameter_name, status);
          RETURN;
        IFEND;
        get_user_path (parameter_name, value, default_names [range_element],
              p_user_range_list^ [user_range_index] [range_element], status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;
      FOREND;
      {Verify that the low user is not greater alphabetically than the high
      IF (p_user_range_list^ [user_range_index] [clc$low] [pfc$family_name_index] >
            p_user_range_list^ [user_range_index] [clc$high] [pfc$family_name_index]) OR
            ((p_user_range_list^ [user_range_index] [clc$low] [pfc$family_name_index] =
            p_user_range_list^ [user_range_index] [clc$high] [pfc$family_name_index]) AND
            (p_user_range_list^ [user_range_index] [clc$low] [pfc$master_catalog_name_index] >
            p_user_range_list^ [user_range_index] [clc$high] [pfc$master_catalog_name_index])) THEN
        osp$set_status_abnormal (puc$pf_utility_id, cle$low_greater_than_high, parameter_name, status);
        RETURN;
      IFEND;
    FOREND;
  PROCEND pup$crack_user_range_list;

?? TITLE := '    [XDCL] pup$determine_if_all_selected ', EJECT ??

  PROCEDURE [XDCL] pup$determine_if_all_selected
    (    name_list: array [1 .. * ] of ost$name;
         parameter_name: string ( * );
     VAR all_selected: boolean;
     VAR status: ost$status);

    VAR
      i: integer;

    status.normal := TRUE;
    all_selected := name_list [1] = 'ALL';
    IF all_selected AND (UPPERBOUND (name_list) > 1) THEN
      osp$set_status_abnormal (puc$pf_utility_id, cle$all_must_be_used_alone, parameter_name, status);
      RETURN;
    IFEND;

    FOR i := 2 TO UPPERBOUND (name_list) DO
      IF name_list [i] = 'ALL' THEN
        osp$set_status_abnormal (puc$pf_utility_id, cle$all_must_be_used_alone, parameter_name, status);
        RETURN;
      IFEND;
    FOREND;
  PROCEND pup$determine_if_all_selected;

?? TITLE := '    [XDCL] pup$determine_if_none_selected ', EJECT ??

  PROCEDURE [XDCL] pup$determine_if_none_selected
    (    name_list: array [1 .. * ] of ost$name;
         parameter_name: string ( * );
     VAR none_selected: boolean;
     VAR status: ost$status);

    VAR
      i: integer;

    status.normal := TRUE;
    none_selected := name_list [1] = 'NONE';
    IF none_selected AND (UPPERBOUND (name_list) > 1) THEN
      osp$set_status_abnormal (puc$pf_utility_id, cle$none_must_be_used_alone, parameter_name, status);
      RETURN;
    IFEND;

    FOR i := 2 TO UPPERBOUND (name_list) DO
      IF name_list [i] = 'NONE' THEN
        osp$set_status_abnormal (puc$pf_utility_id, cle$none_must_be_used_alone, parameter_name, status);
        RETURN;
      IFEND;
    FOREND;
  PROCEND pup$determine_if_none_selected;
?? TITLE := '    check_first_value_for_all ', EJECT ??

  PROCEDURE check_first_value_for_all
    (    parameter_name: string ( * );
     VAR number_of_value_sets: 0 .. clc$max_value_sets;
     VAR all_specified: boolean;
     VAR status: ost$status);

    VAR
      range_specified: boolean,
      value: clt$value;

    all_specified := FALSE;
    clp$get_set_count (parameter_name, number_of_value_sets, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    clp$get_value (parameter_name, 1, 1, clc$low, value, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    IF (value.kind = clc$name_value) AND (value.name.value = 'ALL') THEN
      IF number_of_value_sets > 1 THEN
        osp$set_status_abnormal (puc$pf_utility_id, cle$all_must_be_used_alone, parameter_name, status);
      ELSE
        clp$test_range (parameter_name, 1, 1, range_specified, status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;
        all_specified := NOT range_specified;
        IF range_specified THEN
          osp$set_status_abnormal (puc$pf_utility_id, cle$all_must_be_used_alone, parameter_name, status);
        IFEND;
      IFEND;
    IFEND;
  PROCEND check_first_value_for_all;
?? TITLE := '    convert_cycle_selector ', EJECT ??

  PROCEDURE convert_cycle_selector
    (    cl_cycle_selector: clt$cycle_selector;
     VAR pu_cycle_selector: put$cycle_reference_options);

    CASE cl_cycle_selector.specification OF
    = clc$cycle_omitted =
      pu_cycle_selector := puc$cycle_omitted;
    = clc$cycle_specified =
      CASE cl_cycle_selector.value.cycle_option OF
      = pfc$lowest_cycle =
        pu_cycle_selector := puc$lowest_cycle;
      = pfc$highest_cycle =
        pu_cycle_selector := puc$highest_cycle;
      = pfc$specific_cycle =
        pu_cycle_selector := puc$specific_cycle;
      ELSE
      CASEND;
    = clc$cycle_next_highest =
      pu_cycle_selector := puc$next_highest_cycle;
    = clc$cycle_next_lowest =
      pu_cycle_selector := puc$next_lowest_cycle;
    ELSE
    CASEND;
  PROCEND convert_cycle_selector;
?? TITLE := '    convert_name_to_month ', EJECT ??

  PROCEDURE convert_name_to_month
    (    month_name: ost$name;
     VAR month_number: 1 .. 12);

    VAR
      names_of_the_month: [STATIC, READ, pus$literals] array [1 .. 12] of ost$name := ['JANUARY', 'FEBRUARY',
            'MARCH', 'APRIL', 'MAY', 'JUNE', 'JULY', 'AUGUST', 'SEPTEMBER', 'OCTOBER', 'NOVEMBER',
            'DECEMBER'];

    FOR month_number := 1 TO 12 DO
      IF names_of_the_month [month_number] = month_name THEN
        RETURN;
      IFEND;
    FOREND;
    month_number := 12;
  PROCEND convert_name_to_month;
?? TITLE := '    crack_path ', EJECT ??

  PROCEDURE crack_path
    (    value: clt$value;
         parameter_name: string ( * );
         minimum_path_length: pft$array_index;
         allowed_cycle_references: put$cycle_reference_selections;
     VAR path_container: clt$path_container;
     VAR p_path: ^pft$path;
     VAR cycle_selector_specified: boolean;
     VAR cycle_selector: pft$cycle_selector;
     VAR status: ost$status);


    VAR
      cl_cycle_selector: clt$cycle_selector,
      evaluated_file_reference: fst$evaluated_file_reference,
      p_path_container: ^clt$path_container;

    status.normal := TRUE;
    clp$get_fs_path_elements (value.file.local_file_name, evaluated_file_reference, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    p_path_container := ^path_container;
    RESET p_path_container;
    NEXT p_path: [1 .. evaluated_file_reference.number_of_path_elements] IN p_path_container;
    fsp$convert_fs_structure_to_pf (evaluated_file_reference, p_path);

    IF p_path^ [1] = fsc$local THEN
      osp$set_status_abnormal (puc$pf_utility_id, cle$not_permitted_on_loc_file, 'backup or restore', status);
    ELSE
      IF (UPPERBOUND (p_path^)) < minimum_path_length THEN
        osp$set_status_abnormal (puc$pf_utility_id, pue$path_too_short, parameter_name, status);
        osp$append_status_parameter (osc$status_parameter_delimiter, p_path^ [1], status);
      ELSEIF evaluated_file_reference.path_handle_info.path_handle.open_position.specified THEN
        osp$set_status_abnormal (puc$pf_utility_id, pue$unexpected_file_position, parameter_name, status);
      ELSE
        clp$convert_cyc_ref_to_cyc_sel (evaluated_file_reference.cycle_reference, cl_cycle_selector);
        verify_cycle_selection (parameter_name, allowed_cycle_references, cl_cycle_selector, status);
        IF status.normal THEN
          cycle_selector_specified := cl_cycle_selector.specification <> clc$cycle_omitted;
          IF cycle_selector_specified THEN
            cycle_selector := cl_cycle_selector.value;
          IFEND;
        IFEND;
      IFEND;
    IFEND;
  PROCEND crack_path;


?? TITLE := '    get_user_path ', EJECT ??

  PROCEDURE get_user_path
    (    parameter_name: string ( * );
         value: clt$value;
         default_user_name: pft$name;
     VAR user_path: put$user_path;
     VAR status: ost$status);

    VAR
      cycle_selector: pft$cycle_selector,
      cycle_selector_specified: boolean,
      p_user_path: ^array [1 .. * ] of pft$name,
      user_path_container: clt$path_container;

    crack_path (value, parameter_name, 1, $put$cycle_reference_selections [puc$cycle_omitted],
          user_path_container, p_user_path, cycle_selector_specified, cycle_selector, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    IF (UPPERBOUND (p_user_path^)) > pfc$master_catalog_name_index THEN
      osp$set_status_abnormal (puc$pf_utility_id, pue$path_too_long, parameter_name, status);
    ELSE { the path is ok to use }
      IF UPPERBOUND (p_user_path^) = pfc$master_catalog_name_index THEN
        user_path := p_user_path^;
      ELSE {default the user name}
        user_path [pfc$family_name_index] := p_user_path^ [pfc$family_name_index];
        user_path [pfc$master_catalog_name_index] := default_user_name;
      IFEND;
    IFEND;
  PROCEND get_user_path;

?? TITLE := '    verify_cycle_selection ', EJECT ??

  PROCEDURE verify_cycle_selection
    (    parameter_name: string ( * );
         allowed_cycle_selections: put$cycle_reference_selections;
         specified_cycle_selection: clt$cycle_selector;
     VAR status: ost$status);

    VAR
      cycle_selector: put$cycle_reference_options,
      cycle_selector_name_table: [STATIC, READ, pus$literals] array [put$cycle_reference_options] of
            ost$name := [' NO CYCLE REFERENCE', ' $LOW', ' $HIGH', ' A SPECIFIC CYCLE NUMBER', ' $NEXT',
            ' $NEXT_LOW'],
      check_set: put$cycle_reference_selections,
      delimiter: char,
      first_element: boolean,
      pu_cycle_selector: put$cycle_reference_options;

    status.normal := TRUE;
    IF allowed_cycle_selections = $put$cycle_reference_selections [] THEN
      osp$set_status_abnormal (puc$pf_utility_id, pue$bad_cycle_selections, parameter_name, status);
      RETURN;
    IFEND;
    convert_cycle_selector (specified_cycle_selection, pu_cycle_selector);
    IF NOT (pu_cycle_selector IN allowed_cycle_selections) THEN
      osp$set_status_abnormal (puc$pf_utility_id, pue$incorrect_cycle_reference,
            cycle_selector_name_table [pu_cycle_selector], status);
      delimiter := osc$status_parameter_delimiter;
      osp$append_status_parameter (delimiter, parameter_name, status);
      check_set := $put$cycle_reference_selections [];
      first_element := TRUE;
      FOR cycle_selector := LOWERVALUE (put$cycle_reference_options)
            TO UPPERVALUE (put$cycle_reference_options) DO
        IF cycle_selector IN allowed_cycle_selections THEN
          check_set := check_set + $put$cycle_reference_selections [cycle_selector];
          IF (check_set = allowed_cycle_selections) AND (NOT first_element) THEN
            delimiter := osc$status_parameter_delimiter;
            osp$append_status_parameter (delimiter, ' or ', status);
          IFEND;
          first_element := FALSE;
          osp$append_status_parameter (delimiter, cycle_selector_name_table [cycle_selector], status);
          delimiter := ',';
        IFEND;
      FOREND;
    IFEND;
  PROCEND verify_cycle_selection;

MODEND pum$crack_values;
