?? TITLE := 'NOS/VE Permanent Files : User Interfaces' ??
MODULE pfm$user_ring_request_processor;
?? RIGHT := 110 ??

{ PURPOSE:
{   This module contains the 2dd user interfaces.  If waiting is necessary, it
{   will occur here.

?? NEWTITLE := '  Global Declarations Referenced by this module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc oss$job_paged_literal
*copyc fsc$local
*copyc dfe$error_condition_codes
*copyc dme$tape_errors
*copyc ost$caller_identifier
*copyc pft$object_index
*copyc pft$purge_cycle_options
*copyc pft$wait
?? POP ??
*copyc avp$system_administrator
*copyc bap$process_pt_request
*copyc clp$convert_file_ref_to_string
*copyc clp$evaluate_file_reference
*copyc fsp$path_element
*copyc jmp$system_job
*copyc mmp$create_scratch_segment
*copyc mmp$delete_scratch_segment
*copyc ofp$display_status_message
*copyc ofp$get_display_status_message
*copyc osp$append_status_integer
*copyc osp$append_status_parameter
*copyc osp$clear_wait_message
*copyc osp$enforce_exception_policies
*copyc osp$file_access_condition
*copyc osp$get_current_display_message
*copyc osp$set_status_abnormal
*copyc osp$set_status_condition
*copyc pfp$detach_reserved_cycles
*copyc pfp$find_cycle_array_version_2
*copyc pfp$find_direct_info_record
*copyc pfp$find_directory_array
*copyc pfp$find_file_description
*copyc pfp$find_next_info_record
*copyc pfp$process_unexpected_status
*copyc pfp$r3_attach
*copyc pfp$r3_change
*copyc pfp$r3_change_catalog_flush_opt
*copyc pfp$r3_change_catalog_name
*copyc pfp$r3_change_cycle_damage
*copyc pfp$r3_change_cycle_date_time
*copyc pfp$r3_change_file
*copyc pfp$r3_change_res_to_releasable
*copyc pfp$r3_define
*copyc pfp$r3_define_catalog
*copyc pfp$r3_define_data
*copyc pfp$r3_define_mass_storage_cat
*copyc pfp$r3_delete_all_arch_entries
*copyc pfp$r3_delete_archive_entry
*copyc pfp$r3_delete_catalog_permit
*copyc pfp$r3_delete_permit
*copyc pfp$r3_flush_catalog
*copyc pfp$r3_get_family_set
*copyc pfp$r3_get_item_info
*copyc pfp$r3_get_multi_item_info
*copyc pfp$r3_get_object_information
*copyc pfp$r3_mark_release_candidate
*copyc pfp$r3_permit
*copyc pfp$r3_permit_catalog
*copyc pfp$r3_purge
*copyc pfp$r3_purge_catalog
*copyc pfp$r3_put_archive_entry
*copyc pfp$r3_put_archive_info
*copyc pfp$r3_put_cycle_info
*copyc pfp$r3_put_item_info
*copyc pfp$r3_release_data
*copyc pfp$r3_replace_archive_entry
*copyc pfp$r3_replace_rem_media_fmd
*copyc pfp$r3_resolve_path
*copyc pfp$r3_save_released_file_label
*copyc pfp$r3_utility_attach
*copyc pfp$retrieve_archived_file
*copyc pmp$cause_condition
*copyc pmp$get_job_names
*copyc pmp$long_term_wait
*copyc pmp$wait
*copyc osv$initial_exception_context
*copyc pfv$flush_catalogs
*copyc pfv$space_character
?? TITLE := '  Global Declarations Declared by this module', EJECT ??

  CONST
    include_radix = TRUE,
    one_second = 1000 {milliseconds} ,
    radix = 10,
    ten_seconds = 10 * one_second;

?? TITLE := '[INLINE] f$wait_valid', EJECT ??

  FUNCTION [INLINE] f$wait_valid
    (    wait: pft$wait): boolean;

    f$wait_valid := (wait = pfc$wait) OR (wait = pfc$no_wait);

  FUNCEND f$wait_valid;

?? TITLE := '  [XDCL, #GATE] fsp$change_catalog_flush_option', EJECT ??
*copy fsh$change_catalog_flush_option

  PROCEDURE [XDCL, #GATE] fsp$change_catalog_flush_option
    (    flush_catalogs: boolean;
     VAR status: ost$status);

    pfp$r3_change_catalog_flush_opt (flush_catalogs);
    status.normal := TRUE;
  PROCEND fsp$change_catalog_flush_option;

?? TITLE := '  [XDCL, #GATE] fsp$change_catalog_name', EJECT ??

  PROCEDURE [XDCL, #GATE] fsp$change_catalog_name
    (    catalog_object: fst$file_reference;
         new_catalog_name: pft$name;
     VAR status: ost$status);

    VAR
      context: ^ost$ecp_exception_context,
      evaluated_file_reference: fst$evaluated_file_reference,
      fs_path_size: fst$path_size,
      local_status: ost$status,
      p_fs_path: ^fst$path;

    context := NIL;

    clp$evaluate_file_reference (catalog_object, $clt$file_ref_parsing_options [],
          {resolve_cycle_number} FALSE, evaluated_file_reference, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF evaluated_file_reference.number_of_path_elements < pfc$subcatalog_name_index THEN
      PUSH p_fs_path;
      clp$convert_file_ref_to_string (evaluated_file_reference, {include_open_position} FALSE, p_fs_path^,
            fs_path_size, local_status);
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$path_too_short,
            p_fs_path^ (1, fs_path_size), status);
      osp$append_status_integer (osc$status_parameter_delimiter, pfc$subcatalog_name_index, radix,
            include_radix, status);
      osp$append_status_parameter (osc$status_parameter_delimiter, 'catalog', status);
      RETURN; {----->
    IFEND;

    REPEAT
      pfp$r3_change_catalog_name (evaluated_file_reference, new_catalog_name, status);
      IF status.normal THEN
        RETURN; {----->
      IFEND;

      IF context = NIL THEN
        PUSH context;
        context^ := osv$initial_exception_context;
        context^.file.selector := osc$ecp_evaluated_file_ref;
        context^.file.evaluated_file_reference := evaluated_file_reference;
      IFEND;
      context^.condition_status := status;
      osp$enforce_exception_policies (context^);
      status := context^.condition_status;
    UNTIL status.normal OR (NOT osp$file_access_condition (status)) OR (NOT context^.wait);

  PROCEND fsp$change_catalog_name;
?? TITLE := '  [XDCL, #GATE] fsp$change_cycle_damage', EJECT ??
*copy fsh$change_cycle_damage

  PROCEDURE [XDCL, #GATE] fsp$change_cycle_damage
    (    file: fst$file_reference;
         password: pft$password;
         new_damage_symptoms: fst$cycle_damage_symptoms;
     VAR status: ost$status);

    VAR
      context: ^ost$ecp_exception_context;

    context := NIL;

    REPEAT
      pfp$r3_change_cycle_damage (file, password, new_damage_symptoms, status);
      IF status.normal THEN
        RETURN; {----->
      IFEND;

      IF context = NIL THEN
        PUSH context;
        context^ := osv$initial_exception_context;
        context^.file.selector := osc$ecp_file_reference;
        context^.file.file_reference := ^file;
        context^.password := password;
      IFEND;
      context^.condition_status := status;
      osp$enforce_exception_policies (context^);
      status := context^.condition_status;
    UNTIL status.normal OR (NOT osp$file_access_condition (status)) OR (NOT context^.wait);

  PROCEND fsp$change_cycle_damage;

?? TITLE := '  [XDCL, #GATE] fsp$change_cycle_date_time', EJECT ??
*copy fsh$change_cycle_date_time

  PROCEDURE [XDCL, #GATE] fsp$change_cycle_date_time
    (    file: fst$file_reference;
         password: pft$password;
         p_new_access_date_time: ^fst$date_time;
         p_new_modification_date_time: ^fst$date_time;
     VAR status: ost$status);

    VAR
      context: ^ost$ecp_exception_context;

    context := NIL;

    REPEAT
      pfp$r3_change_cycle_date_time (file, password, p_new_access_date_time, {p_new_creation_date_time} NIL,
            p_new_modification_date_time, status);
      IF status.normal THEN
        RETURN; {----->
      IFEND;

      IF context = NIL THEN
        PUSH context;
        context^ := osv$initial_exception_context;
        context^.file.selector := osc$ecp_file_reference;
        context^.file.file_reference := ^file;
        context^.password := password;
      IFEND;
      context^.condition_status := status;
      osp$enforce_exception_policies (context^);
      status := context^.condition_status;
    UNTIL status.normal OR (NOT osp$file_access_condition (status)) OR (NOT context^.wait);

  PROCEND fsp$change_cycle_date_time;

?? TITLE := '  [XDCL, #GATE] fsp$change_file', EJECT ??
*copy fsh$change_file

  PROCEDURE [XDCL, #GATE] fsp$change_file
    (    file: fst$file_reference;
         password: pft$password;
         file_changes: ^fst$file_changes;
     VAR status: ost$status);

    VAR
      context: ^ost$ecp_exception_context;

    context := NIL;

    REPEAT
      pfp$r3_change_file (file, password, file_changes, status);
      IF status.normal THEN
        RETURN; {----->
      IFEND;

      IF context = NIL THEN
        PUSH context;
        context^ := osv$initial_exception_context;
        context^.file.selector := osc$ecp_file_reference;
        context^.file.file_reference := ^file;
        context^.password := password;
      IFEND;
      context^.condition_status := status;
      osp$enforce_exception_policies (context^);
      status := context^.condition_status;
    UNTIL status.normal OR (NOT osp$file_access_condition (status)) OR (NOT context^.wait);

  PROCEND fsp$change_file;

?? TITLE := '  [XDCL, #GATE] fsp$flush_catalog', EJECT ??
*copy fsh$flush_catalog

  PROCEDURE [XDCL, #GATE] fsp$flush_catalog
    (    catalog_object: fst$file_reference;
     VAR status: ost$status);

    VAR
      context: ^ost$ecp_exception_context,
      evaluated_file_reference: fst$evaluated_file_reference,
      fs_path_size: fst$path_size,
      local_status: ost$status,
      p_fs_path: ^fst$path;

    context := NIL;

    clp$evaluate_file_reference (catalog_object, $clt$file_ref_parsing_options [],
          {resolve_cycle_number} FALSE, evaluated_file_reference, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF evaluated_file_reference.number_of_path_elements < pfc$subcatalog_name_index THEN
      PUSH p_fs_path;
      clp$convert_file_ref_to_string (evaluated_file_reference, {include_open_position} FALSE, p_fs_path^,
            fs_path_size, local_status);
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$path_too_short,
            p_fs_path^ (1, fs_path_size), status);
      osp$append_status_integer (osc$status_parameter_delimiter, pfc$subcatalog_name_index, radix,
            include_radix, status);
      osp$append_status_parameter (osc$status_parameter_delimiter, 'catalog', status);
      RETURN; {----->
    IFEND;

    REPEAT
      pfp$r3_flush_catalog (evaluated_file_reference, status);
      IF status.normal THEN
        RETURN; {----->
      IFEND;

      IF context = NIL THEN
        PUSH context;
        context^ := osv$initial_exception_context;
        context^.file.selector := osc$ecp_evaluated_file_ref;
        context^.file.evaluated_file_reference := evaluated_file_reference;
      IFEND;
      context^.condition_status := status;
      osp$enforce_exception_policies (context^);
      status := context^.condition_status;
    UNTIL status.normal OR (NOT osp$file_access_condition (status)) OR (NOT context^.wait);

  PROCEND fsp$flush_catalog;

?? TITLE := '  [XDCL, #GATE] pfp$attach', EJECT ??
*copy pfh$attach

  PROCEDURE [XDCL, #GATE] pfp$attach
    (    lfn: amt$local_file_name;
         path: pft$path;
         cycle_selector: pft$cycle_selector;
         password: pft$password;
         usage_selections: pft$usage_selections;
         share_selections: pft$share_selections;
         wait: pft$wait;
     VAR status: ost$status);

    CONST
      five_minutes = 5 * 60 * one_second; {milliseconds}

    VAR
      context: ^ost$ecp_exception_context,
      cycle_number: fst$cycle_number,
      local_status: ost$status,
      time_since_last_retrieval: 0 .. fsc$longest_wait_time;

    context := NIL;

    IF f$wait_valid (wait) THEN

    /attach_file/
      REPEAT
        pfp$r3_attach (lfn, path, cycle_selector, password, usage_selections, share_selections, cycle_number,
              status);
        IF status.normal THEN
          RETURN; {----->
        IFEND;

        CASE status.condition OF

        = dme$unable_to_lock_tape_table =
          {
          { An extra wait is done to allow for the server case, where a
          { previous ready task has inhibited the subsequent wait.
          {
          pmp$wait (1, 1);
          pmp$long_term_wait (one_second, one_second);
          CYCLE /attach_file/; {----->

        = pfe$tape_attached_on_client =
          CYCLE /attach_file/; {----->

        ELSE
          ;
        CASEND;
        IF osp$file_access_condition (status) THEN
          IF context = NIL THEN
            PUSH context;
            context^ := osv$initial_exception_context;
            context^.caller_will_retrieve_file := TRUE;
            context^.file.selector := osc$ecp_pf_path;
            context^.file.pf_path := ^path;
            context^.file.cycle_selector := cycle_selector;
            context^.password := password;
            time_since_last_retrieval := 0;
          IFEND;

          IF (status.condition = pfe$cycle_data_resides_offline) THEN
            context^.wait := TRUE;
            IF NOT (fsc$data_retrieval_required IN context^.raised_conditions) THEN
              pmp$cause_condition (osc$data_retrieval_req_cond, ^context {input, output} , local_status);
              IF local_status.normal THEN
                context^.raised_conditions := context^.raised_conditions +
                      $fst$file_access_conditions [fsc$data_retrieval_required]
              IFEND;
            IFEND;

            IF ((time_since_last_retrieval = 0) OR (time_since_last_retrieval >= five_minutes)) THEN
              pfp$retrieve_archived_file (path, cycle_number, password, osc$nowait, local_status);
              IF local_status.normal THEN
                time_since_last_retrieval := 0;
              ELSE
                context^.wait := FALSE;
                status := local_status;
                EXIT /attach_file/; {----->
              IFEND;
            IFEND;
          ELSEIF status.condition = pfe$cycle_busy THEN
            context^.wait := (wait = pfc$wait);
          ELSE
            context^.wait := TRUE;
          IFEND;
          IF context^.wait THEN
            context^.condition_status := status;
            osp$enforce_exception_policies (context^);
            time_since_last_retrieval := time_since_last_retrieval + context^.elapsed_wait_time;
            status := context^.condition_status;
          IFEND;
        IFEND;
      UNTIL status.normal OR (NOT osp$file_access_condition (status)) OR (NOT context^.wait);

    ELSE
      osp$set_status_condition (pfe$bad_wait_option, status);
      osp$append_status_integer (osc$status_parameter_delimiter, $INTEGER (wait), radix, NOT include_radix,
            status);
    IFEND;

  PROCEND pfp$attach;

?? TITLE := '  [XDCL, #GATE] pfp$change', EJECT ??
*copy pfh$change

  PROCEDURE [XDCL, #GATE] pfp$change
    (    path: pft$path;
         cycle_selector: pft$cycle_selector;
         password: pft$password;
         change_list: pft$change_list;
     VAR status: ost$status);

    VAR
      context: ^ost$ecp_exception_context;

    context := NIL;

    REPEAT
      pfp$r3_change (path, cycle_selector, password, change_list, status);
      IF status.normal THEN
        RETURN; {----->
      IFEND;

      IF context = NIL THEN
        PUSH context;
        context^ := osv$initial_exception_context;
        context^.file.selector := osc$ecp_pf_path;
        context^.file.pf_path := ^path;
        context^.file.cycle_selector := cycle_selector;
        context^.password := password;
      IFEND;
      context^.condition_status := status;
      osp$enforce_exception_policies (context^);
      status := context^.condition_status;
    UNTIL status.normal OR (NOT osp$file_access_condition (status)) OR (NOT context^.wait);

  PROCEND pfp$change;

?? TITLE := '  [XDCL, #GATE] pfp$change_res_to_releasable', EJECT ??

  PROCEDURE [XDCL, #GATE] pfp$change_res_to_releasable
    (    path: pft$path;
         cycle_selector: pft$cycle_selector;
     VAR status: ost$status);

    VAR
      context: ^ost$ecp_exception_context;

    context := NIL;

    REPEAT
      pfp$r3_change_res_to_releasable (path, cycle_selector, status);
      IF status.normal THEN
        RETURN; {----->
      IFEND;

      IF context = NIL THEN
        PUSH context;
        context^ := osv$initial_exception_context;
        context^.file.selector := osc$ecp_pf_path;
        context^.file.pf_path := ^path;
        context^.file.cycle_selector := cycle_selector;
      IFEND;
      context^.condition_status := status;
      osp$enforce_exception_policies (context^);
      status := context^.condition_status;
    UNTIL status.normal OR (NOT osp$file_access_condition (status)) OR (NOT context^.wait);

  PROCEND pfp$change_res_to_releasable;

?? TITLE := '  [XDCL, #GATE] pfp$define', EJECT ??
*copy pfh$define

  PROCEDURE [XDCL, #GATE] pfp$define
    (    lfn: amt$local_file_name;
         path: pft$path;
         cycle_selector: pft$cycle_selector;
         password: pft$password;
         retention: pft$retention;
         log: pft$log;
     VAR status: ost$status);

    VAR
      context: ^ost$ecp_exception_context;

    context := NIL;

    REPEAT
      pfp$r3_define (lfn, path, cycle_selector, password, retention, log, status);
      IF status.normal THEN
        RETURN; {----->
      IFEND;

      IF context = NIL THEN
        PUSH context;
        context^ := osv$initial_exception_context;
        context^.file.selector := osc$ecp_pf_path;
        context^.file.pf_path := ^path;
        context^.file.cycle_selector := cycle_selector;
        context^.password := password;
      IFEND;
      context^.condition_status := status;
      osp$enforce_exception_policies (context^);
      status := context^.condition_status;
    UNTIL status.normal OR (NOT osp$file_access_condition (status)) OR (NOT context^.wait);

  PROCEND pfp$define;

?? TITLE := '  [XDCL, #GATE] pfp$define_catalog', EJECT ??
*copy pfh$define_catalog

  PROCEDURE [XDCL, #GATE] pfp$define_catalog
    (    path: pft$path;
     VAR status: ost$status);

    CONST
      minimum_path_length = 3;

    VAR
      context: ^ost$ecp_exception_context;

    context := NIL;

    REPEAT
      pfp$r3_define_catalog (path, status);
      IF status.normal THEN
        RETURN; {----->
      IFEND;

      IF context = NIL THEN
        PUSH context;
        context^ := osv$initial_exception_context;
        context^.file.selector := osc$ecp_pf_path;
        context^.file.pf_path := ^path;
        context^.catalog_object := TRUE;
      IFEND;
      context^.condition_status := status;
      osp$enforce_exception_policies (context^);
      status := context^.condition_status;
    UNTIL status.normal OR (NOT osp$file_access_condition (status)) OR (NOT context^.wait);

  PROCEND pfp$define_catalog;

?? TITLE := '  [XDCL, #GATE] pfp$define_data', EJECT ??
*copy pfh$define_data

  PROCEDURE [XDCL, #GATE] pfp$define_data
    (    lfn: amt$local_file_name;
         path: pft$path;
         cycle_selector: pft$cycle_selector;
         update_cycle_statistics: boolean;
         password_selector: pft$password_selector;
         p_mass_storage_request_info: ^fmt$mass_storage_request_info;
         p_volume_list: ^array [1 .. * ] of rmt$recorded_vsn;
         purge_cycle_options: pft$purge_cycle_options;
         replace_cycle_data: boolean;
         restore_selections: put$restore_data_selections;
         wait_on_volume: boolean;
     VAR mandated_modification_time: {i/o} pft$mandated_modification_time;
     VAR data_residence: pft$data_residence;
     VAR status: ost$status);

    VAR
      context: ^ost$ecp_exception_context;

    context := NIL;

    REPEAT
      pfp$r3_define_data (lfn, path, cycle_selector, update_cycle_statistics, password_selector,
            p_mass_storage_request_info, p_volume_list, purge_cycle_options, replace_cycle_data,
            restore_selections, mandated_modification_time, data_residence, status);
      IF status.normal THEN
        RETURN; {----->
      IFEND;

      IF wait_on_volume THEN
        IF context = NIL THEN
          PUSH context;
          context^ := osv$initial_exception_context;
          context^.file.selector := osc$ecp_pf_path;
          context^.file.pf_path := ^path;
          context^.file.cycle_selector := cycle_selector;
        IFEND;
        IF password_selector.password_specified = pfc$specific_password_option THEN
          context^.password := password_selector.password;
        IFEND;
        context^.condition_status := status;
        osp$enforce_exception_policies (context^);
        status := context^.condition_status;
      IFEND;
    UNTIL status.normal OR (NOT wait_on_volume) OR (NOT osp$file_access_condition (status)) OR
          (NOT context^.wait);

  PROCEND pfp$define_data;

?? TITLE := '  [XDCL, #GATE] pfp$define_mass_storage_catalog', EJECT ??
*copy pfh$define_mass_storage_catalog

  PROCEDURE [XDCL, #GATE] pfp$define_mass_storage_catalog
    (    catalog: pft$path;
         catalog_type: pft$catalog_types;
         p_mass_storage_request_info: ^fmt$mass_storage_request_info;
     VAR status: ost$status);

    VAR
      context: ^ost$ecp_exception_context;

    context := NIL;

    REPEAT
      pfp$r3_define_mass_storage_cat (catalog, catalog_type, p_mass_storage_request_info, status);
      IF status.normal THEN
        RETURN; {----->
      IFEND;

      IF context = NIL THEN
        PUSH context;
        context^ := osv$initial_exception_context;
        context^.file.selector := osc$ecp_pf_path;
        context^.file.pf_path := ^catalog;
        context^.catalog_object := TRUE;
      IFEND;
      context^.condition_status := status;
      osp$enforce_exception_policies (context^);
      status := context^.condition_status;
    UNTIL status.normal OR (NOT osp$file_access_condition (status)) OR (NOT context^.wait);

  PROCEND pfp$define_mass_storage_catalog;

?? TITLE := '  [XDCL, #GATE] pfp$delete_all_archive_entries', EJECT ??
*copy pfh$delete_all_archive_entries

  PROCEDURE [XDCL, #GATE] pfp$delete_all_archive_entries
    (    path: pft$path;
         cycle_selector: pft$cycle_selector;
     VAR status: ost$status);

    VAR
      context: ^ost$ecp_exception_context;

    context := NIL;

    REPEAT
      pfp$r3_delete_all_arch_entries (path, cycle_selector, status);
      IF status.normal THEN
        RETURN; {----->
      IFEND;

      IF context = NIL THEN
        PUSH context;
        context^ := osv$initial_exception_context;
        context^.file.selector := osc$ecp_pf_path;
        context^.file.pf_path := ^path;
        context^.file.cycle_selector := cycle_selector;
      IFEND;
      context^.condition_status := status;
      osp$enforce_exception_policies (context^);
      status := context^.condition_status;
    UNTIL status.normal OR (NOT osp$file_access_condition (status)) OR (NOT context^.wait);

  PROCEND pfp$delete_all_archive_entries;

?? TITLE := '  [XDCL, #GATE] pfp$delete_archive_entry', EJECT ??
*copy pfh$delete_archive_entry

  PROCEDURE [XDCL, #GATE] pfp$delete_archive_entry
    (    path: pft$path;
         cycle_selector: pft$cycle_selector;
         archive_identification: pft$archive_identification;
     VAR status: ost$status);

    VAR
      context: ^ost$ecp_exception_context;

    context := NIL;

    REPEAT
      pfp$r3_delete_archive_entry (path, cycle_selector, archive_identification, status);
      IF status.normal THEN
        RETURN; {----->
      IFEND;

      IF context = NIL THEN
        PUSH context;
        context^ := osv$initial_exception_context;
        context^.file.selector := osc$ecp_pf_path;
        context^.file.pf_path := ^path;
        context^.file.cycle_selector := cycle_selector;
      IFEND;
      context^.condition_status := status;
      osp$enforce_exception_policies (context^);
      status := context^.condition_status;
    UNTIL status.normal OR (NOT osp$file_access_condition (status)) OR (NOT context^.wait);

  PROCEND pfp$delete_archive_entry;

?? TITLE := '  [XDCL, #GATE] pfp$delete_catalog_permit', EJECT ??
*copy pfh$delete_catalog_permit

  PROCEDURE [XDCL, #GATE] pfp$delete_catalog_permit
    (    path: pft$path;
         group: pft$group;
     VAR status: ost$status);

    VAR
      context: ^ost$ecp_exception_context;

    context := NIL;

    REPEAT
      pfp$r3_delete_catalog_permit (path, group, status);
      IF status.normal THEN
        RETURN; {----->
      IFEND;

      IF context = NIL THEN
        PUSH context;
        context^ := osv$initial_exception_context;
        context^.file.selector := osc$ecp_pf_path;
        context^.file.pf_path := ^path;
      IFEND;
      context^.condition_status := status;
      osp$enforce_exception_policies (context^);
      status := context^.condition_status;
    UNTIL status.normal OR (NOT osp$file_access_condition (status)) OR (NOT context^.wait);

  PROCEND pfp$delete_catalog_permit;

?? TITLE := '  [XDCL, #GATE] pfp$delete_cycle_data', EJECT ??
*copy pfh$delete_cycle_data

  PROCEDURE [XDCL, #GATE] pfp$delete_cycle_data
    (    path: pft$path;
         cycle_selector: pft$cycle_selector;
         password: pft$password;
         purge_cycle_options: pft$purge_cycle_options;
     VAR status: ost$status);

    VAR
      context: ^ost$ecp_exception_context;

    context := NIL;

    REPEAT
      pfp$r3_purge (path, cycle_selector, password, purge_cycle_options, status);
      IF status.normal THEN
        RETURN; {----->
      IFEND;

      IF context = NIL THEN
        PUSH context;
        context^ := osv$initial_exception_context;
        context^.file.selector := osc$ecp_pf_path;
        context^.file.pf_path := ^path;
        context^.file.cycle_selector := cycle_selector;
        context^.password := password;
      IFEND;
      context^.condition_status := status;
      osp$enforce_exception_policies (context^);
      status := context^.condition_status;
    UNTIL status.normal OR (NOT osp$file_access_condition (status)) OR (NOT context^.wait);

  PROCEND pfp$delete_cycle_data;

?? TITLE := '  [XDCL, #GATE] pfp$delete_permit', EJECT ??
*copy pfh$delete_permit

  PROCEDURE [XDCL, #GATE] pfp$delete_permit
    (    path: pft$path;
         group: pft$group;
     VAR status: ost$status);

    VAR
      context: ^ost$ecp_exception_context;

    context := NIL;

    REPEAT
      pfp$r3_delete_permit (path, group, status);
      IF status.normal THEN
        RETURN; {----->
      IFEND;

      IF context = NIL THEN
        PUSH context;
        context^ := osv$initial_exception_context;
        context^.file.selector := osc$ecp_pf_path;
        context^.file.pf_path := ^path;
      IFEND;
      context^.condition_status := status;
      osp$enforce_exception_policies (context^);
      status := context^.condition_status;
    UNTIL status.normal OR (NOT osp$file_access_condition (status)) OR (NOT context^.wait);

  PROCEND pfp$delete_permit;

?? TITLE := '  [XDCL, #GATE] pfp$get_family_set', EJECT ??

  PROCEDURE [XDCL, #GATE] pfp$get_family_set
    (    family_name: ost$name;
     VAR set_name: stt$set_name;
     VAR status: ost$status);

    VAR
      context: ^ost$ecp_exception_context;

    context := NIL;

    REPEAT
      pfp$r3_get_family_set (family_name, set_name, status);
      IF status.normal THEN
        RETURN; {----->
      IFEND;

      IF context = NIL THEN
        PUSH context;
        context^ := osv$initial_exception_context;
        context^.file.selector := osc$ecp_file_reference;
        context^.file.file_reference := ^family_name;
      IFEND;
      context^.condition_status := status;
      osp$enforce_exception_policies (context^);
      status := context^.condition_status;
    UNTIL status.normal OR (NOT osp$file_access_condition (status)) OR (NOT context^.wait);

  PROCEND pfp$get_family_set;

?? TITLE := '  [XDCL, #GATE] pfp$get_item_info', EJECT ??
*copy pfh$get_item_info

  PROCEDURE [XDCL, #GATE] pfp$get_item_info
    (    path: pft$path;
         group: pft$group;
         catalog_info_selections: pft$catalog_info_selections;
         file_info_selections: pft$file_info_selections;
     VAR p_info: pft$p_info;
     VAR status: ost$status);

    VAR
      context: ^ost$ecp_exception_context;

    context := NIL;

    REPEAT
      pfp$r3_get_item_info (path, group, catalog_info_selections, file_info_selections, p_info, status);
      IF status.normal THEN
        RETURN; {----->
      IFEND;

      IF context = NIL THEN
        PUSH context;
        context^ := osv$initial_exception_context;
        context^.file.selector := osc$ecp_pf_path;
        context^.file.pf_path := ^path;
      IFEND;
      context^.condition_status := status;
      osp$enforce_exception_policies (context^);
      status := context^.condition_status;
    UNTIL status.normal OR (NOT osp$file_access_condition (status)) OR (NOT context^.wait);

  PROCEND pfp$get_item_info;

?? TITLE := '  [XDCL, #GATE] pfp$get_multi_item_info', EJECT ??
*copy pfh$get_multi_item_info

  PROCEDURE [XDCL, #GATE] pfp$get_multi_item_info
    (    path: pft$path;
         group: pft$group;
         catalog_info_selections: pft$catalog_info_selections;
         file_info_selections: pft$file_info_selections;
     VAR p_info: pft$p_info;
     VAR status: ost$status);

    VAR
      context: ^ost$ecp_exception_context;

    context := NIL;

    REPEAT
      pfp$r3_get_multi_item_info (path, group, catalog_info_selections, file_info_selections,
            {p_cycle_reservation_criteria} NIL, p_info, status);
      IF status.normal THEN
        RETURN; {----->
      IFEND;

      IF context = NIL THEN
        PUSH context;
        context^ := osv$initial_exception_context;
        context^.file.selector := osc$ecp_pf_path;
        context^.file.pf_path := ^path;
      IFEND;
      context^.condition_status := status;
      osp$enforce_exception_policies (context^);
      status := context^.condition_status;
    UNTIL status.normal OR (NOT osp$file_access_condition (status)) OR (NOT context^.wait);

  PROCEND pfp$get_multi_item_info;

?? TITLE := '  [XDCL, #GATE] pfp$get_object_information', EJECT ??
*copy pfh$get_object_information

  PROCEDURE [XDCL, #GATE] pfp$get_object_information
    (    file_reference: fst$file_reference;
         information_request: fst$goi_information_request;
         p_validation_criteria: {i/o^} ^fst$goi_validation_criteria;
     VAR p_object_information: {i/o} ^SEQ ( * );
     VAR status: ost$status);

    VAR
      evaluated_file_reference: fst$evaluated_file_reference;

    evaluate_file_reference (file_reference, {command_file_reference_allowed} TRUE, evaluated_file_reference,
          status);
    IF status.normal THEN
      pfp$r3_get_object_information (evaluated_file_reference, information_request, p_validation_criteria,
            p_object_information, status);
    IFEND;

  PROCEND pfp$get_object_information;

?? TITLE := '  [XDCL, #GATE] pfp$get_reserved_item_info', EJECT ??
*copy pfh$get_reserved_item_info

  PROCEDURE [XDCL, #GATE] pfp$get_reserved_item_info
    (    path: pft$path;
         group: pft$group;
         catalog_info_selections: pft$catalog_info_selections;
         file_info_selections: pft$file_info_selections;
         p_cycle_reservation_criteria: ^pft$cycle_reservation_criteria;
     VAR p_info: pft$p_info;
     VAR status: ost$status);

    VAR
      context: ^ost$ecp_exception_context,
      local_status: ost$status,
      message_displayed: boolean,
      original_display_message: oft$display_message;

    message_displayed := FALSE;

    context := NIL;

    REPEAT
      pfp$r3_get_multi_item_info (path, group, catalog_info_selections, file_info_selections,
            p_cycle_reservation_criteria, p_info, status);
      IF status.normal THEN
        RETURN; {----->
      IFEND;

      IF status.condition = pfe$reserved_cycle_table_locked THEN
        IF NOT message_displayed THEN
          message_displayed := TRUE;
          osp$get_current_display_message (original_display_message);
        IFEND;
        ofp$display_status_message (' Waiting for Reserved Cycle Table.', local_status);
        pmp$long_term_wait (ten_seconds, ten_seconds);
      ELSE
        IF context = NIL THEN
          PUSH context;
          context^ := osv$initial_exception_context;
          context^.file.selector := osc$ecp_pf_path;
          context^.file.pf_path := ^path;
        IFEND;
        context^.condition_status := status;
        osp$enforce_exception_policies (context^);
        status := context^.condition_status;
      IFEND;
    UNTIL status.normal OR (NOT osp$file_access_condition (status)) OR (NOT context^.wait);

    IF NOT status.normal THEN
      REPEAT
        pfp$detach_reserved_cycles (local_status);
        IF NOT local_status.normal THEN
          IF context = NIL THEN
            PUSH context;
            context^ := osv$initial_exception_context;
            context^.file.selector := osc$ecp_pf_path;
            context^.file.pf_path := ^path;
          IFEND;
          context^.condition_status := local_status;
          osp$enforce_exception_policies (context^);
          local_status := context^.condition_status;
        IFEND;
      UNTIL local_status.normal OR (NOT osp$file_access_condition (local_status)) OR (NOT context^.wait);
    IFEND;

    IF message_displayed THEN
      osp$clear_wait_message (original_display_message, message_displayed);
    IFEND;

  PROCEND pfp$get_reserved_item_info;

?? TITLE := '  [XDCL, #GATE] pfp$mark_release_candidate', EJECT ??
*copy pfh$mark_release_candidate

  PROCEDURE [XDCL, #GATE] pfp$mark_release_candidate
    (    path: pft$path;
         cycle_selector: pft$cycle_selector;
         password: pft$password;
         archive_identification: pft$archive_identification;
     VAR status: ost$status);

    VAR
      caller_id: ost$caller_identifier,
      context: ^ost$ecp_exception_context;

    #CALLER_ID (caller_id);
    context := NIL;

    REPEAT
      pfp$r3_mark_release_candidate (path, cycle_selector, password, caller_id, archive_identification,
            status);
      IF status.normal THEN
        RETURN; {----->
      IFEND;

      IF context = NIL THEN
        PUSH context;
        context^ := osv$initial_exception_context;
        context^.file.selector := osc$ecp_pf_path;
        context^.file.pf_path := ^path;
        context^.file.cycle_selector := cycle_selector;
        context^.password := password;
      IFEND;
      context^.condition_status := status;
      osp$enforce_exception_policies (context^);
      status := context^.condition_status;
    UNTIL status.normal OR (NOT osp$file_access_condition (status)) OR (NOT context^.wait);

  PROCEND pfp$mark_release_candidate;

?? TITLE := '  [XDCL, #GATE] pfp$permit', EJECT ??
*copy pfh$permit

  PROCEDURE [XDCL, #GATE] pfp$permit
    (    path: pft$path;
         group: pft$group;
         permit_selections: pft$permit_selections;
         share_requirements: pft$share_requirements;
         application_info: pft$application_info;
     VAR status: ost$status);

    VAR
      context: ^ost$ecp_exception_context;

    context := NIL;

    REPEAT
      pfp$r3_permit (path, group, permit_selections, share_requirements, application_info, status);
      IF status.normal THEN
        RETURN; {----->
      IFEND;

      IF context = NIL THEN
        PUSH context;
        context^ := osv$initial_exception_context;
        context^.file.selector := osc$ecp_pf_path;
        context^.file.pf_path := ^path;
      IFEND;
      context^.condition_status := status;
      osp$enforce_exception_policies (context^);
      status := context^.condition_status;
    UNTIL status.normal OR (NOT osp$file_access_condition (status)) OR (NOT context^.wait);

  PROCEND pfp$permit;

?? TITLE := '  [XDCL, #GATE] pfp$permit_catalog', EJECT ??
*copy pfh$permit_catalog

  PROCEDURE [XDCL, #GATE] pfp$permit_catalog
    (    path: pft$path;
         group: pft$group;
         permit_selections: pft$permit_selections;
         share_requirements: pft$share_requirements;
         application_info: pft$application_info;
     VAR status: ost$status);

    VAR
      context: ^ost$ecp_exception_context;

    context := NIL;

    REPEAT
      pfp$r3_permit_catalog (path, group, permit_selections, share_requirements, application_info, status);
      IF status.normal THEN
        RETURN; {----->
      IFEND;

      IF context = NIL THEN
        PUSH context;
        context^ := osv$initial_exception_context;
        context^.file.selector := osc$ecp_pf_path;
        context^.file.pf_path := ^path;
      IFEND;
      context^.condition_status := status;
      osp$enforce_exception_policies (context^);
      status := context^.condition_status;
    UNTIL status.normal OR (NOT osp$file_access_condition (status)) OR (NOT context^.wait);

  PROCEND pfp$permit_catalog;

?? TITLE := '  [XDCL, #GATE] pfp$purge', EJECT ??
*copy pfh$purge

  PROCEDURE [XDCL, #GATE] pfp$purge
    (    path: pft$path;
         cycle_selector: pft$cycle_selector;
         password: pft$password;
     VAR status: ost$status);

    VAR
      context: ^ost$ecp_exception_context,
      purge_cycle_options: pft$purge_cycle_options;

    context := NIL;
    purge_cycle_options.enforce_password_validation := TRUE;
    purge_cycle_options.enforce_ring_validation := TRUE;
    purge_cycle_options.preserve_cycle_entry := FALSE;

    REPEAT
      pfp$r3_purge (path, cycle_selector, password, purge_cycle_options, status);
      IF status.normal THEN
        RETURN; {----->
      IFEND;

      IF context = NIL THEN
        PUSH context;
        context^ := osv$initial_exception_context;
        context^.file.selector := osc$ecp_pf_path;
        context^.file.pf_path := ^path;
        context^.file.cycle_selector := cycle_selector;
        context^.password := password;
      IFEND;
      context^.condition_status := status;
      osp$enforce_exception_policies (context^);
      status := context^.condition_status;
    UNTIL status.normal OR (NOT osp$file_access_condition (status)) OR (NOT context^.wait);

  PROCEND pfp$purge;

?? TITLE := '  [XDCL, #GATE] pfp$purge_catalog', EJECT ??
*copy pfh$purge_catalog

  PROCEDURE [XDCL, #GATE] pfp$purge_catalog
    (    path: pft$path;
     VAR status: ost$status);

    VAR
      context: ^ost$ecp_exception_context;

    context := NIL;

    REPEAT
      pfp$r3_purge_catalog (path, pfc$only_if_empty, status);
      IF status.normal THEN
        RETURN; {----->
      IFEND;

      IF context = NIL THEN
        PUSH context;
        context^ := osv$initial_exception_context;
        context^.file.selector := osc$ecp_pf_path;
        context^.file.pf_path := ^path;
      IFEND;
      context^.condition_status := status;
      osp$enforce_exception_policies (context^);
      status := context^.condition_status;
    UNTIL status.normal OR (NOT osp$file_access_condition (status)) OR (NOT context^.wait);

  PROCEND pfp$purge_catalog;

?? TITLE := '  [XDCL, #GATE] pfp$purge_catalog_contents', EJECT ??
*copy pfh$purge_catalog_contents

  PROCEDURE [XDCL, #GATE] pfp$purge_catalog_contents
    (    catalog_path: pft$path;
         purge_catalog: boolean;
     VAR status: ost$status);

    CONST
      minimum_path_length = pfc$master_catalog_name_index;

    VAR
      context: ^ost$ecp_exception_context,
      found: boolean,
      group: pft$group,
      last_catalog_index: pft$catalog_path_index,
      local_status: ost$status,
      object_index: pft$object_index,
      p_catalog_directory_array: pft$p_directory_array,
      p_catalog_info: pft$p_info,
      p_catalog_info_record: pft$p_info_record,
      p_new_path: ^pft$path,
      path_index: pft$file_path_index,
      segment_pointer: amt$segment_pointer,
      space_index: 1 .. osc$max_name_size + 1;

?? NEWTITLE := '    delete_file_contents', EJECT ??

    PROCEDURE delete_file_contents
      (    file_path: pft$path;
           directory_entry: pft$directory_array_entry;
           p_catalog_info_record: {input^} pft$p_info_record;
           purge_catalog: boolean;
       VAR status: ost$status);

      VAR
        cycle_index: pft$cycle_index,
        cycle_selector: pft$cycle_selector,
        p_cycle_array: ^pft$cycle_array_version_2,
        p_file_description: pft$p_file_description,
        p_file_info_record: pft$p_info_record,
        purge_cycle_options: pft$purge_cycle_options;

      pfp$find_direct_info_record (^p_catalog_info_record^.body, directory_entry.info_offset,
            p_file_info_record, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;

      pfp$find_cycle_array_version_2 (p_file_info_record, p_cycle_array, status);
      IF (NOT status.normal) OR (p_cycle_array = NIL) THEN
        RETURN; {----->
      IFEND;

      pfp$find_file_description (p_file_info_record, p_file_description, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;

      cycle_selector.cycle_option := pfc$specific_cycle;
      purge_cycle_options.enforce_password_validation := TRUE;
      purge_cycle_options.enforce_ring_validation := TRUE;
      purge_cycle_options.preserve_cycle_entry := FALSE;

      FOR cycle_index := 1 TO UPPERBOUND (p_cycle_array^) DO
        cycle_selector.cycle_number := p_cycle_array^ [cycle_index].cycle_number;
        IF purge_catalog THEN
          pfp$r3_purge (file_path, cycle_selector, p_file_description^.password, purge_cycle_options, status);
          status.normal := status.normal OR osp$file_access_condition (status);
        ELSE
          pfp$purge (file_path, cycle_selector, p_file_description^.password, status);
          IF NOT status.normal THEN
            RETURN; {----->
          IFEND;
        IFEND;
      FOREND;

    PROCEND delete_file_contents;

?? OLDTITLE, EJECT ??

    status.normal := TRUE;

    context := NIL;

    last_catalog_index := UPPERBOUND (catalog_path);
    IF last_catalog_index < minimum_path_length THEN
      #SCAN (pfv$space_character, catalog_path [pfc$family_name_index], space_index, found);
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$path_too_short,
            catalog_path [pfc$family_name_index] (1, space_index - 1), status);
      osp$append_status_integer (osc$status_parameter_delimiter, minimum_path_length, radix, include_radix,
            status);
      osp$append_status_parameter (osc$status_parameter_delimiter, 'catalog', status);
      RETURN; {----->
    ELSEIF (last_catalog_index = minimum_path_length) AND purge_catalog THEN
      osp$set_status_condition (pfe$cannot_purge_master_catalog, status);
      RETURN; {----->
    IFEND;

    mmp$create_scratch_segment (amc$sequence_pointer, mmc$as_random, segment_pointer, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

  /segment_created/
    BEGIN
      p_catalog_info := segment_pointer.sequence_pointer;
      RESET p_catalog_info;

      PUSH p_new_path: [1 .. last_catalog_index + 1];
      FOR path_index := 1 TO last_catalog_index DO
        p_new_path^ [path_index] := catalog_path [path_index];
      FOREND;

      group.group_type := pfc$public;
      IF purge_catalog THEN
        pfp$r3_get_multi_item_info (catalog_path, group, $pft$catalog_info_selections
              [pfc$catalog_directory, pfc$catalog_description], $pft$file_info_selections
              [pfc$file_directory, pfc$file_description, pfc$file_cycles_version_2],
              {p_cycle_reservation_criteria} NIL, p_catalog_info, status);
        IF NOT status.normal THEN
          status.normal := osp$file_access_condition (status);
          EXIT /segment_created/; {----->
        IFEND;
      ELSE
        REPEAT
          pfp$get_multi_item_info (catalog_path, group, $pft$catalog_info_selections
                [pfc$catalog_directory, pfc$catalog_description],
                $pft$file_info_selections [pfc$file_directory, pfc$file_description,
                pfc$file_cycles_version_2], p_catalog_info, status);
          IF NOT status.normal THEN
            IF context = NIL THEN
              PUSH context;
              context^ := osv$initial_exception_context;
              context^.file.selector := osc$ecp_pf_path;
              context^.file.pf_path := ^catalog_path;
            IFEND;
            context^.condition_status := status;
            osp$enforce_exception_policies (context^);
            status := context^.condition_status;
          IFEND;
        UNTIL status.normal OR (NOT osp$file_access_condition (status)) OR (NOT context^.wait);

        IF NOT status.normal THEN
          EXIT /segment_created/; {----->
        IFEND;
      IFEND;

      RESET p_catalog_info;
      pfp$find_next_info_record (p_catalog_info, p_catalog_info_record, status);
      IF NOT status.normal THEN
        EXIT /segment_created/; {----->
      IFEND;

      pfp$find_directory_array (p_catalog_info_record, p_catalog_directory_array, status);
      IF NOT status.normal THEN
        EXIT /segment_created/; {----->
      IFEND;

      IF p_catalog_directory_array <> NIL THEN
        FOR object_index := LOWERBOUND (p_catalog_directory_array^)
              TO UPPERBOUND (p_catalog_directory_array^) DO
          p_new_path^ [last_catalog_index + 1] := p_catalog_directory_array^ [object_index].name;
          IF p_catalog_directory_array^ [object_index].name_type = pfc$file_name THEN
            delete_file_contents (p_new_path^, p_catalog_directory_array^ [object_index],
                  p_catalog_info_record, purge_catalog, status);
            IF NOT status.normal THEN
              EXIT /segment_created/; {----->
            IFEND;
          ELSEIF p_catalog_directory_array^ [object_index].name_type = pfc$catalog_name THEN
            pfp$purge_catalog_contents (p_new_path^, {purge_catalog} TRUE, status);
            IF NOT status.normal THEN
              EXIT /segment_created/; {----->
            IFEND;
          IFEND;
        FOREND;
      IFEND;
    END /segment_created/;

    IF status.normal THEN
      mmp$delete_scratch_segment (segment_pointer, local_status);
      pfp$process_unexpected_status (local_status);
    ELSE
      mmp$delete_scratch_segment (segment_pointer, local_status);
      RETURN; {----->
    IFEND;

    IF purge_catalog THEN
      pfp$r3_purge_catalog (catalog_path, pfc$catalog_and_contents, status);
    IFEND;

  PROCEND pfp$purge_catalog_contents;

?? TITLE := '  [XDCL, #GATE] pfp$put_archive_entry', EJECT ??
*copy pfh$put_archive_entry

  PROCEDURE [XDCL, #GATE] pfp$put_archive_entry
    (    path: pft$path;
         cycle_selector: pft$cycle_selector;
         p_archive_array_entry: pft$p_archive_array_entry;
         p_amd: pft$p_amd;
     VAR status: ost$status);

    VAR
      context: ^ost$ecp_exception_context;

    context := NIL;

    REPEAT
      pfp$r3_put_archive_entry (path, cycle_selector, p_archive_array_entry, p_amd, status);
      IF status.normal THEN
        RETURN; {----->
      IFEND;

      IF context = NIL THEN
        PUSH context;
        context^ := osv$initial_exception_context;
        context^.file.selector := osc$ecp_pf_path;
        context^.file.pf_path := ^path;
        context^.file.cycle_selector := cycle_selector;
      IFEND;
      context^.condition_status := status;
      osp$enforce_exception_policies (context^);
      status := context^.condition_status;
    UNTIL status.normal OR (NOT osp$file_access_condition (status)) OR (NOT context^.wait);

  PROCEND pfp$put_archive_entry;

?? TITLE := '  [XDCL, #GATE] pfp$put_archive_info', EJECT ??
*copy pfh$put_archive_info

  PROCEDURE [XDCL, #GATE] pfp$put_archive_info
    (    path: pft$path;
         cycle_selector: pft$cycle_selector;
         p_cycle_info_record: pft$p_info_record;
     VAR status: ost$status);

    VAR
      context: ^ost$ecp_exception_context;

    context := NIL;

    REPEAT
      pfp$r3_put_archive_info (path, cycle_selector, p_cycle_info_record, status);
      IF status.normal THEN
        RETURN; {----->
      IFEND;

      IF context = NIL THEN
        PUSH context;
        context^ := osv$initial_exception_context;
        context^.file.selector := osc$ecp_pf_path;
        context^.file.pf_path := ^path;
        context^.file.cycle_selector := cycle_selector;
      IFEND;
      context^.condition_status := status;
      osp$enforce_exception_policies (context^);
      status := context^.condition_status;
    UNTIL status.normal OR (NOT osp$file_access_condition (status)) OR (NOT context^.wait);

  PROCEND pfp$put_archive_info;

?? TITLE := '  [XDCL, #GATE] pfp$put_cycle_info', EJECT ??
*copy pfh$put_cycle_info

  PROCEDURE [XDCL, #GATE] pfp$put_cycle_info
    (    path: pft$path;
         cycle_selector: pft$cycle_selector;
         password_selector: pft$password_selector;
         cycle_array_entry: pft$cycle_array_entry_version_2;
     VAR status: ost$status);

    VAR
      context: ^ost$ecp_exception_context;

    context := NIL;

    REPEAT
      pfp$r3_put_cycle_info (path, cycle_selector, password_selector, cycle_array_entry, status);
      IF status.normal THEN
        RETURN; {----->
      IFEND;

      IF context = NIL THEN
        PUSH context;
        context^ := osv$initial_exception_context;
        context^.file.selector := osc$ecp_pf_path;
        context^.file.pf_path := ^path;
        context^.file.cycle_selector := cycle_selector;
      IFEND;
      IF password_selector.password_specified = pfc$specific_password_option THEN
        context^.password := password_selector.password;
      IFEND;
      context^.condition_status := status;
      osp$enforce_exception_policies (context^);
      status := context^.condition_status;
    UNTIL status.normal OR (NOT osp$file_access_condition (status)) OR (NOT context^.wait);

  PROCEND pfp$put_cycle_info;

?? TITLE := '  [XDCL, #GATE] pfp$put_item_info', EJECT ??
*copy pfh$put_item_info

  PROCEDURE [XDCL, #GATE] pfp$put_item_info
    (    path: pft$path;
         p_info_record: pft$p_info_record;
         restore_archive_information: boolean;
         cycle_selection_criteria: put$selection_criteria;
         backup_file_version: pft$backup_file_version;
     VAR all_permits_restored: boolean;
     VAR status: ost$status);

    VAR
      context: ^ost$ecp_exception_context;

    context := NIL;

    REPEAT
      pfp$r3_put_item_info (path, p_info_record, restore_archive_information, cycle_selection_criteria,
            backup_file_version, all_permits_restored, status);
      IF status.normal THEN
        RETURN; {----->
      IFEND;

      IF context = NIL THEN
        PUSH context;
        context^ := osv$initial_exception_context;
        context^.file.selector := osc$ecp_pf_path;
        context^.file.pf_path := ^path;
        context^.catalog_object := TRUE;
      IFEND;
      context^.condition_status := status;
      osp$enforce_exception_policies (context^);
      status := context^.condition_status;
    UNTIL status.normal OR (NOT osp$file_access_condition (status)) OR (NOT context^.wait);

  PROCEND pfp$put_item_info;

?? TITLE := '  [XDCL, #GATE] pfp$release_data', EJECT ??
*copy pfh$release_data

  PROCEDURE [XDCL, #GATE] pfp$release_data
    (    path: pft$path;
         cycle_selector: pft$cycle_selector;
         password: pft$password;
     VAR status: ost$status);

    VAR
      context: ^ost$ecp_exception_context;

    context := NIL;

    REPEAT
      pfp$r3_release_data (path, cycle_selector, password, {p_release_data_info} NIL, status);
      IF status.normal THEN
        RETURN; {----->
      IFEND;

      IF context = NIL THEN
        PUSH context;
        context^ := osv$initial_exception_context;
        context^.file.selector := osc$ecp_pf_path;
        context^.file.pf_path := ^path;
        context^.file.cycle_selector := cycle_selector;
        context^.password := password;
      IFEND;
      context^.condition_status := status;
      osp$enforce_exception_policies (context^);
      status := context^.condition_status;
    UNTIL status.normal OR (NOT osp$file_access_condition (status)) OR (NOT context^.wait);

  PROCEND pfp$release_data;

?? TITLE := '  [XDCL, #GATE] pfp$replace_archive_entry', EJECT ??
*copy pfh$replace_archive_entry

  PROCEDURE [XDCL, #GATE] pfp$replace_archive_entry
    (    path: pft$path;
         cycle_selector: pft$cycle_selector;
         archive_identification: pft$archive_identification;
         p_archive_array_entry: pft$p_archive_array_entry;
         p_amd: pft$p_amd;
     VAR status: ost$status);

    VAR
      context: ^ost$ecp_exception_context;

    context := NIL;

    REPEAT
      pfp$r3_replace_archive_entry (path, cycle_selector, archive_identification, p_archive_array_entry,
            p_amd, status);
      IF status.normal THEN
        RETURN; {----->
      IFEND;

      IF context = NIL THEN
        PUSH context;
        context^ := osv$initial_exception_context;
        context^.file.selector := osc$ecp_pf_path;
        context^.file.pf_path := ^path;
        context^.file.cycle_selector := cycle_selector;
      IFEND;
      context^.condition_status := status;
      osp$enforce_exception_policies (context^);
      status := context^.condition_status;
    UNTIL status.normal OR (NOT osp$file_access_condition (status)) OR (NOT context^.wait);

  PROCEND pfp$replace_archive_entry;

?? TITLE := '  [XDCL, #GATE] pfp$replace_rem_media_fmd', EJECT ??
*copy pfh$replace_rem_media_fmd

  PROCEDURE [XDCL, #GATE] pfp$replace_rem_media_fmd
    (    path: pft$path;
         cycle_selector: pft$cycle_selector;
         password_selector: pft$password_selector;
         replace_existing_rem_media_fmd: boolean;
         p_file_media_descriptor: ^SEQ ( * );
     VAR status: ost$status);

    VAR
      context: ^ost$ecp_exception_context;

    context := NIL;

    REPEAT
      pfp$r3_replace_rem_media_fmd (path, cycle_selector, password_selector, replace_existing_rem_media_fmd,
           p_file_media_descriptor, status);
      IF status.normal THEN
        RETURN; {----->
      IFEND;

      IF context = NIL THEN
        PUSH context;
        context^ := osv$initial_exception_context;
        context^.file.selector := osc$ecp_pf_path;
        context^.file.pf_path := ^path;
        context^.file.cycle_selector := cycle_selector;
      IFEND;
      IF password_selector.password_specified = pfc$specific_password_option THEN
        context^.password := password_selector.password;
      IFEND;
      context^.condition_status := status;
      osp$enforce_exception_policies (context^);
      status := context^.condition_status;
    UNTIL status.normal OR (NOT osp$file_access_condition (status)) OR (NOT context^.wait);

  PROCEND pfp$replace_rem_media_fmd;

?? TITLE := '  [XDCL, #GATE] pfp$resolve_path', EJECT ??

  PROCEDURE [XDCL, #GATE] pfp$resolve_path
    (    path: pft$path;
     VAR cycle_reference: {i/o} fst$cycle_reference;
     VAR path_resolution: fst$path_resolution;
     VAR status: ost$status);

    pfp$r3_resolve_path (path, cycle_reference, path_resolution, status);

  PROCEND pfp$resolve_path;

?? TITLE := '  [XDCL, #GATE] pfp$save_released_file_label', EJECT ??
*copy pfh$save_released_file_label

  PROCEDURE [XDCL, #GATE] pfp$save_released_file_label
    (    path: pft$path;
         cycle_selector: pft$cycle_selector;
         update_cycle_statistics: boolean;
         password_selector: pft$password_selector;
         p_file_label_container: fmt$p_file_label;
     VAR status: ost$status);

    VAR
      context: ^ost$ecp_exception_context;

    context := NIL;

    REPEAT
      pfp$r3_save_released_file_label (path, cycle_selector, update_cycle_statistics, password_selector,
            p_file_label_container, status);
      IF status.normal THEN
        RETURN; {----->
      IFEND;

      IF context = NIL THEN
        PUSH context;
        context^ := osv$initial_exception_context;
        context^.file.selector := osc$ecp_pf_path;
        context^.file.pf_path := ^path;
        context^.file.cycle_selector := cycle_selector;
      IFEND;
      IF password_selector.password_specified = pfc$specific_password_option THEN
        context^.password := password_selector.password;
      IFEND;
      context^.condition_status := status;
      osp$enforce_exception_policies (context^);
      status := context^.condition_status;
    UNTIL status.normal OR (NOT osp$file_access_condition (status)) OR (NOT context^.wait);

  PROCEND pfp$save_released_file_label;

?? TITLE := '  [XDCL, #GATE] pfp$utility_attach', EJECT ??
*copy pfh$utility_attach

  PROCEDURE [XDCL, #GATE] pfp$utility_attach
    (    lfn: amt$local_file_name;
         path: pft$path;
         cycle_selector: pft$cycle_selector;
         password: pft$password;
         usage_selections: pft$usage_selections;
         share_selections: pft$share_selections;
         wait: pft$wait;
         allowed_cycle_damage_symptoms: fst$cycle_damage_symptoms;
     VAR cycle_damage_symptoms: fst$cycle_damage_symptoms;
     VAR cycle_number: fst$cycle_number;
     VAR status: ost$status);

    VAR
      context: ^ost$ecp_exception_context;

    context := NIL;

    IF f$wait_valid (wait) THEN

      REPEAT
        pfp$r3_utility_attach (lfn, path, cycle_selector, password, usage_selections, share_selections,
              allowed_cycle_damage_symptoms, cycle_damage_symptoms, cycle_number, status);
        IF status.normal THEN
          RETURN; {----->
        IFEND;

        IF context = NIL THEN
          PUSH context;
          context^ := osv$initial_exception_context;
          context^.allowed_access_conditions := $fst$file_access_conditions
                [fsc$catalog_media_missing, fsc$catalog_volume_unavailable, fsc$file_server_inactive];
          IF wait = pfc$wait THEN
            context^.allowed_access_conditions := context^.allowed_access_conditions +
                  $fst$file_access_conditions [fsc$cycle_busy];
          IFEND;
          context^.file.selector := osc$ecp_pf_path;
          context^.file.pf_path := ^path;
          context^.file.cycle_selector := cycle_selector;
          context^.password := password;
          IF status.condition = pfe$cycle_busy THEN
            context^.wait := (wait = pfc$wait);
          IFEND;
        IFEND;
        context^.condition_status := status;
        osp$enforce_exception_policies (context^);
        status := context^.condition_status;
      UNTIL status.normal OR (NOT osp$file_access_condition (status)) OR (NOT context^.wait);

    ELSE
      osp$set_status_condition (pfe$bad_wait_option, status);
      osp$append_status_integer (osc$status_parameter_delimiter, $INTEGER (wait), radix, NOT include_radix,
            status);
    IFEND;

  PROCEND pfp$utility_attach;

?? TITLE := '  evaluate_file_reference', EJECT ??

  PROCEDURE evaluate_file_reference
    (    file_reference: fst$file_reference;
         command_file_reference_allowed: boolean;
     VAR evaluated_file_reference: fst$evaluated_file_reference;
     VAR status: ost$status);

    VAR
      process_pt_results: bat$process_pt_results;

    clp$evaluate_file_reference (file_reference, $clt$file_ref_parsing_options [clc$command_file_ref_allowed],
          {resolve_cycle_number} FALSE, evaluated_file_reference, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    { Return permanent file path if alias & resolve temporary files.

    IF (fsp$path_element (^evaluated_file_reference, 1) ^ = fsc$local) THEN
      bap$process_pt_request ($bat$process_pt_work_list [], {local_file_name} osc$null_name,
            evaluated_file_reference, process_pt_results, status);
    IFEND;

  PROCEND evaluate_file_reference;

MODEND pfm$user_ring_request_processor;
