?? TITLE := 'NOS/VE Permanent Files : Find Information', EJECT ??
MODULE pfm$find_information;
?? RIGHT := 110 ??

{ PURPOSE:
{   This module contains the procedures to parse the information returned by
{   the permanent file 'get info' routines.
{
{ NOTE:
{   Because these requests run in the user's ring, the pointer provided is not
{   validated.  If the pointer is bad, a condition will occur in the user's
{   ring.

?? NEWTITLE := '  Global Declarations Referenced by this module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc i#current_sequence_position
*copyc pfe$error_condition_codes
*copyc pfe$external_archive_conditions
*copyc pfe$internal_error_conditions
*copyc ost$status
*copyc pft$array_index
*copyc pft$catalog_media_description
*copyc pft$cycle_array_version_2
*copyc pft$cycle_selector
*copyc pft$file_media_description
*copyc pft$p_amd
*copyc pft$p_archive_array_entry
*copyc pft$p_cycle_array
*copyc pft$p_cycle_directory_array
*copyc pft$p_directory_array
*copyc pft$p_info
*copyc pft$p_log_array
*copyc pft$p_permit_array
*copyc pft$permit_array
?? POP ??
*copyc clp$validate_name
*copyc osp$append_status_integer
*copyc osp$set_status_abnormal
*copyc osp$set_status_condition
*copyc osp$verify_system_privilege
*copyc pfp$convert_archive_ident
?? TITLE := '[inline] p$find_archive_info', EJECT ??

  PROCEDURE [INLINE] p$find_next_info_record
    (VAR p_info: pft$p_info;
     VAR p_info_record: pft$p_info_record;
     VAR status: ost$status);

    VAR
      local_p_info: pft$p_info,
      p_cell: ^cell;

    local_p_info := p_info;
    NEXT p_info_record: [[REP 1 OF cell]] IN local_p_info;
    IF p_info_record <> NIL THEN
      IF (p_info_record^.record_type < LOWERVALUE (pft$info_record_type)) OR
            (p_info_record^.record_type > UPPERVALUE (pft$info_record_type)) OR
            (p_info_record^.body_size < LOWERVALUE (pft$info_record_body_size)) OR
            (p_info_record^.body_size > UPPERVALUE (pft$info_record_body_size)) THEN
        osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$bad_info_record_format, '', status);
      ELSE
        NEXT p_info_record: [[REP p_info_record^.body_size OF cell]] IN p_info;
        IF p_info_record = NIL THEN
          osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$bad_info_record_format, '', status);
        IFEND;
      IFEND;
    ELSE
      NEXT p_cell IN local_p_info;
      IF (p_cell = NIL) OR (#SIZE (local_p_info^) = 1) THEN
        osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$unknown_info_record, '', status);
      ELSE
        osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$bad_info_record_format, '', status);
      IFEND;
    IFEND;

  PROCEND p$find_next_info_record;

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

  PROCEDURE [XDCL, #GATE] pfp$find_archive_info
    (    p_cycle_info_record: pft$p_info_record;
     VAR p_archive_info_record: pft$p_info_record;
     VAR status: ost$status);

    find_record (p_cycle_info_record, pfc$archive_info_record, p_archive_info_record, status);
    IF (NOT status.normal) AND (status.condition = pfe$unknown_info_record) THEN
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$unknown_archive_info, '', status);
    IFEND;

  PROCEND pfp$find_archive_info;

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

  PROCEDURE [XDCL, #GATE] pfp$find_catalog_description
    (    p_catalog_group_record: pft$p_info_record;
     VAR p_catalog_description: pft$p_catalog_description;
     VAR status: ost$status);

    VAR
      p_catalog_desc_record_body: pft$p_info;

    find_record_body (p_catalog_group_record, pfc$catalog_description_record, p_catalog_desc_record_body,
          status);
    IF status.normal THEN
      NEXT p_catalog_description IN p_catalog_desc_record_body;
      IF p_catalog_description = NIL THEN
        osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$bad_info_record_format, '', status);
      IFEND;
    IFEND;

  PROCEND pfp$find_catalog_description;

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

  PROCEDURE [XDCL, #GATE] pfp$find_catalog_media
    (    p_catalog_group_info_record: pft$p_info_record;
     VAR p_catalog_media_description: pft$p_catalog_media_description;
     VAR p_catalog_fmd: ^SEQ ( * );
     VAR status: ost$status);

    VAR
      fmd_size: pft$info_record_body_size,
      p_catalog_media_record_body: pft$p_info;

    find_record_body (p_catalog_group_info_record, pfc$catalog_media_record, p_catalog_media_record_body,
          status);
    IF status.normal THEN
      NEXT p_catalog_media_description IN p_catalog_media_record_body;
      IF (p_catalog_media_description = NIL) THEN
        osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$bad_info_record_format,
              'Catalog media description', status);
      ELSEIF p_catalog_media_description^.catalog_type = pfc$external_catalog THEN
        fmd_size := #SIZE (p_catalog_media_record_body^) - i#current_sequence_position (
              p_catalog_media_record_body);
        NEXT p_catalog_fmd: [[REP fmd_size OF cell]] IN p_catalog_media_record_body;
        IF p_catalog_fmd = NIL THEN
          osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$bad_info_record_format,
                'Catalog media ', status);
        IFEND;

      ELSE { internal catalog
        p_catalog_fmd := NIL;
      IFEND;
    ELSE
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$unknown_catalog_media, '', status);
    IFEND;

  PROCEND pfp$find_catalog_media;

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

  PROCEDURE [XDCL, #GATE] pfp$find_cycle_array
    (    p_file_group_info_record: pft$p_info_record;
     VAR p_cycle_array: pft$p_cycle_array;
     VAR status: ost$status);

    VAR
      body_size: pft$info_record_body_size,
      entry_size: pft$info_record_body_size,
      p_cycle_array_record_body: pft$p_info;

    find_record_body (p_file_group_info_record, pfc$cycle_array_record, p_cycle_array_record_body, status);
    IF status.normal THEN
      body_size := #SIZE (p_cycle_array_record_body^);
      entry_size := #SIZE (pft$cycle_array_entry);
      IF body_size > 1 THEN
        IF body_size MOD entry_size = 0 THEN
          NEXT p_cycle_array: [1 .. (body_size DIV entry_size)] IN p_cycle_array_record_body;
        ELSE
          osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$bad_info_record_format, '', status);
        IFEND;
      ELSE
        p_cycle_array := NIL;
      IFEND;
    IFEND;

  PROCEND pfp$find_cycle_array;

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

  PROCEDURE [XDCL, #GATE] pfp$find_cycle_array_extended
    (    p_file_group_info_record: pft$p_info_record;
     VAR p_cycle_array_extended_record: pft$p_info_record;
     VAR status: ost$status);

    find_record (p_file_group_info_record, pfc$cycle_array_extended_record, p_cycle_array_extended_record,
          status);
    IF NOT status.normal THEN
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$unknown_cycle_array, '', status);
    IFEND;

  PROCEND pfp$find_cycle_array_extended;

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

  PROCEDURE [XDCL, #GATE] pfp$find_cycle_array_version_2
    (    p_file_group_info_record: pft$p_info_record;
     VAR p_cycle_array: ^pft$cycle_array_version_2;
     VAR status: ost$status);

    VAR
      body_size: pft$info_record_body_size,
      entry_size: pft$info_record_body_size,
      p_cycle_array_record_body: pft$p_info;

    find_record_body (p_file_group_info_record, pfc$cycle_array_version_2_rec, p_cycle_array_record_body,
          status);
    IF status.normal THEN
      body_size := #SIZE (p_cycle_array_record_body^);
      entry_size := #SIZE (pft$cycle_array_entry_version_2);
      IF body_size > 1 THEN
        IF body_size MOD entry_size = 0 THEN
          NEXT p_cycle_array: [1 .. (body_size DIV entry_size)] IN p_cycle_array_record_body;
        ELSE
          osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$bad_info_record_format, '', status);
        IFEND;
      ELSE
        p_cycle_array := NIL;
      IFEND;
    IFEND;

  PROCEND pfp$find_cycle_array_version_2;

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

  PROCEDURE [XDCL, #GATE] pfp$find_cycle_directory
    (    p_cycle_array_extended_record: pft$p_info_record;
     VAR p_cycle_directory_array: pft$p_cycle_directory_array;
     VAR status: ost$status);

    VAR
      body_size: pft$info_record_body_size,
      entry_size: pft$info_record_body_size,
      p_cycle_directory_record_body: pft$p_info;

    find_record_body (p_cycle_array_extended_record, pfc$cycle_directory_record,
          p_cycle_directory_record_body, status);
    IF status.normal THEN
      body_size := #SIZE (p_cycle_directory_record_body^);
      entry_size := #SIZE (pft$cycle_directory_array_entry);
      IF body_size > 1 THEN
        IF body_size MOD entry_size = 0 THEN
          NEXT p_cycle_directory_array: [1 .. (body_size DIV entry_size)] IN p_cycle_directory_record_body;
        ELSE
          osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$bad_info_record_format, '', status);
        IFEND;
      ELSE
        p_cycle_directory_array := NIL;
      IFEND;
    IFEND;

  PROCEND pfp$find_cycle_directory;

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

  PROCEDURE [XDCL, #GATE] pfp$find_cycle_entry
    (    p_cycle_array: pft$p_cycle_array;
         cycle_selector: pft$cycle_selector;
     VAR cycle_index: pft$array_index;
     VAR status: ost$status);

    check_cycle_selector (cycle_selector, status);
    IF status.normal THEN
      CASE cycle_selector.cycle_option OF
      = pfc$lowest_cycle =
        find_lowest_cycle (p_cycle_array, cycle_index);
      = pfc$highest_cycle =
        find_highest_cycle (p_cycle_array, cycle_index);
      = pfc$specific_cycle =
        find_specific_cycle (p_cycle_array, cycle_selector.cycle_number, cycle_index, status);
      ELSE
      CASEND;
    IFEND;

  PROCEND pfp$find_cycle_entry;

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

  PROCEDURE [XDCL, #GATE] pfp$find_cycle_entry_version_2
    (    p_cycle_array: ^pft$cycle_array_version_2;
         cycle_selector: pft$cycle_selector;
     VAR cycle_index: pft$array_index;
     VAR status: ost$status);

    check_cycle_selector (cycle_selector, status);
    IF status.normal THEN
      CASE cycle_selector.cycle_option OF
      = pfc$lowest_cycle =
        find_lowest_cycle_version_2 (p_cycle_array, cycle_index);
      = pfc$highest_cycle =
        find_highest_cycle_version_2 (p_cycle_array, cycle_index);
      = pfc$specific_cycle =
        find_specific_cycle_version_2 (p_cycle_array, cycle_selector.cycle_number, cycle_index, status);
      ELSE
      CASEND;
    IFEND;

  PROCEND pfp$find_cycle_entry_version_2;

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

  PROCEDURE [XDCL, #GATE] pfp$find_cycle_label
    (    p_cycle_info_record: pft$p_info_record;
     VAR p_cycle_label: ^SEQ ( * );
     VAR status: ost$status);

    find_record_body (p_cycle_info_record, pfc$cycle_label_record, p_cycle_label, status);
    IF NOT status.normal THEN
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$unknown_cycle_label, '', status);
    IFEND;

  PROCEND pfp$find_cycle_label;

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

  PROCEDURE [XDCL, #GATE] pfp$find_cycle_media
    (    p_cycle_info_record: pft$p_info_record;
     VAR p_cycle_media_description: pft$p_file_media_description;
     VAR status: ost$status);

    VAR
      fmd_size: pft$info_record_body_size,
      p_cycle_media_record_body: pft$p_info;

    find_record_body (p_cycle_info_record, pfc$cycle_media_record, p_cycle_media_record_body, status);
    IF status.normal THEN
      NEXT p_cycle_media_description: [[REP 1 OF cell]] IN p_cycle_media_record_body;
      IF (p_cycle_media_description = NIL) THEN
        osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$bad_info_record_format,
              'Cycle media description', status);
      ELSE
        fmd_size := #SIZE (p_cycle_media_record_body^) - i#current_sequence_position (
              p_cycle_media_record_body) + 1;
        RESET p_cycle_media_record_body;
        NEXT p_cycle_media_description: [[REP fmd_size OF cell]] IN p_cycle_media_record_body;
        IF p_cycle_media_description = NIL THEN
          osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$bad_info_record_format, 'Cycle media ',
                status);
        IFEND;
      IFEND;
    ELSE
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$unknown_cycle_media, '', status);
    IFEND;

  PROCEND pfp$find_cycle_media;

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

  PROCEDURE [XDCL, #GATE] pfp$find_direct_info_record
    (    p_info: pft$p_info;
         info_offset: pft$info_offset;
     VAR p_info_record: pft$p_info_record;
     VAR status: ost$status);

    VAR
      info_size: pft$info_record_body_size,
      local_p_info: pft$p_info,
      p_skipped_info: pft$p_info;

    status.normal := TRUE;

    local_p_info := p_info;
    RESET local_p_info;
    info_size := #SIZE (local_p_info^);
    IF (info_offset < 0) OR (info_offset > info_size) THEN
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$info_offset_range_error, '', status);
      osp$append_status_integer (osc$status_parameter_delimiter, info_offset, 10, FALSE, status);
      osp$append_status_integer (osc$status_parameter_delimiter, 0, 10, FALSE, status);
      osp$append_status_integer (osc$status_parameter_delimiter, info_size, 10, FALSE, status);
    ELSE
      IF info_offset <> 0 THEN
        NEXT p_skipped_info: [[REP info_offset OF cell]] IN local_p_info;
      IFEND;
      p$find_next_info_record (local_p_info, p_info_record, status);
    IFEND;

  PROCEND pfp$find_direct_info_record;

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

  PROCEDURE [XDCL, #GATE] pfp$find_directory_array
    (    p_info_record: pft$p_info_record;
     VAR p_directory_array: pft$p_directory_array;
     VAR status: ost$status);

    VAR
      body_size: pft$info_record_body_size,
      entry_size: pft$info_record_body_size,
      p_directory_record_body: pft$p_info;

    find_record_body (p_info_record, pfc$directory_array_record, p_directory_record_body, status);
    IF status.normal THEN
      body_size := #SIZE (p_directory_record_body^);
      entry_size := #SIZE (pft$directory_array_entry);
      IF body_size > 1 THEN
        IF body_size MOD entry_size = 0 THEN
          NEXT p_directory_array: [1 .. (body_size DIV entry_size)] IN p_directory_record_body;
        ELSE
          osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$bad_info_record_format, '', status);
        IFEND;
      ELSE
        p_directory_array := NIL;
      IFEND;
    IFEND;

  PROCEND pfp$find_directory_array;

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

  PROCEDURE [XDCL, #GATE] pfp$find_file_description
    (    p_file_group_info_record: pft$p_info_record;
     VAR p_file_description: pft$p_file_description;
     VAR status: ost$status);

    VAR
      p_file_description_record_body: pft$p_info;

    find_record_body (p_file_group_info_record, pfc$file_description_record, p_file_description_record_body,
          status);
    IF status.normal THEN
      NEXT p_file_description IN p_file_description_record_body;
      IF (p_file_description = NIL) THEN
        osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$bad_info_record_format, '', status);
      IFEND;
    IFEND;

  PROCEND pfp$find_file_description;

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

  PROCEDURE [XDCL, #GATE] pfp$find_log_array
    (    p_file_group_info_record: pft$p_info_record;
     VAR p_log_array: pft$p_log_array;
     VAR status: ost$status);

    VAR
      body_size: pft$info_record_body_size,
      entry_size: pft$info_record_body_size,
      p_log_array_record_body: pft$p_info;

    find_record_body (p_file_group_info_record, pfc$log_array_record, p_log_array_record_body, status);
    IF status.normal THEN
      body_size := #SIZE (p_log_array_record_body^);
      entry_size := #SIZE (pft$log_array_entry);
      IF body_size > 1 THEN
        IF body_size MOD entry_size = 0 THEN
          NEXT p_log_array: [1 .. (body_size DIV entry_size)] IN p_log_array_record_body;
        ELSE
          osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$bad_info_record_format, '', status);
        IFEND;
      ELSE
        p_log_array := NIL;
      IFEND;
    IFEND;

  PROCEND pfp$find_log_array;

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

  PROCEDURE [XDCL, #GATE] pfp$find_next_archive_entry
    (    archive_identification: pft$archive_identification;
     VAR p_info: pft$p_info;
     VAR p_info_record: pft$p_info_record;
     VAR p_archive_array_entry: pft$p_archive_array_entry;
     VAR p_amd: pft$p_amd;
     VAR status: ost$status);

    VAR
      found: boolean,
      local_archive_identification: pft$archive_identification;

    status.normal := TRUE;
    found := FALSE;
    local_archive_identification := archive_identification;

    pfp$convert_archive_ident (archive_identification, local_archive_identification, status);

    IF status.normal THEN

    /find_matching_archive_entry/
      REPEAT
        p$find_next_info_record (p_info, p_info_record, status);
        IF status.normal THEN
          find_archive_entry (p_info_record, p_archive_array_entry, p_amd, status);
          IF p_archive_array_entry = NIL THEN
            EXIT /find_matching_archive_entry/; {----->
          IFEND;
          IF local_archive_identification.application_identifier = osc$null_name THEN
            found := TRUE;
            EXIT /find_matching_archive_entry/; {----->
          IFEND;
          IF p_archive_array_entry^.archive_identification.application_identifier =
                local_archive_identification.application_identifier THEN
            IF local_archive_identification.media_identifier.media_device_class = osc$null_name THEN
              found := TRUE;
              EXIT /find_matching_archive_entry/; {----->
            IFEND;
            IF p_archive_array_entry^.archive_identification.media_identifier.media_device_class =
                  local_archive_identification.media_identifier.media_device_class THEN
              IF local_archive_identification.media_identifier.media_volume_identifier = '' THEN
                found := TRUE;
                EXIT /find_matching_archive_entry/; {----->
              IFEND;
              IF p_archive_array_entry^.archive_identification.media_identifier.media_volume_identifier =
                    local_archive_identification.media_identifier.media_volume_identifier THEN
                found := TRUE;
                EXIT /find_matching_archive_entry/; {----->
              IFEND;
            IFEND;
          IFEND;
        IFEND;
      UNTIL NOT status.normal;

      IF status.normal AND (NOT found) THEN
        osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$unknown_archive_application,
              archive_identification.application_identifier, status);
      IFEND;
    IFEND;

  PROCEND pfp$find_next_archive_entry;

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

  PROCEDURE [XDCL, #GATE] pfp$find_next_info_record
    (VAR p_info: pft$p_info;
     VAR p_info_record: pft$p_info_record;
     VAR status: ost$status);

    status.normal := TRUE;
    p$find_next_info_record (p_info, p_info_record, status);

  PROCEND pfp$find_next_info_record;

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

  PROCEDURE [XDCL, #GATE] pfp$find_permit_array
    (    p_info_record: pft$p_info_record;
     VAR p_permit_array: pft$p_permit_array;
     VAR status: ost$status);

    VAR
      body_size: pft$info_record_body_size,
      entry_size: pft$info_record_body_size,
      p_permit_array_record_body: pft$p_info;

    find_record_body (p_info_record, pfc$permit_array_record, p_permit_array_record_body, status);
    IF status.normal THEN
      body_size := #SIZE (p_permit_array_record_body^);
      entry_size := #SIZE (pft$permit_array_entry);
      IF body_size > 1 THEN
        IF body_size MOD entry_size = 0 THEN
          NEXT p_permit_array: [1 .. (body_size DIV entry_size)] IN p_permit_array_record_body;
        ELSE
          osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$bad_info_record_format, '', status);
        IFEND;
      ELSE
        p_permit_array := NIL;
      IFEND;
    IFEND;

  PROCEND pfp$find_permit_array;

?? TITLE := '  [XDCL] pfp$locate_group_info_record', EJECT ??

  PROCEDURE [XDCL] pfp$locate_group_info_record
    (    p_info_record: {input^} ^pft$info_record;
     VAR p_group_info_record: ^pft$info_record;
     VAR status: ost$status);

    VAR
      group_info_record_found: boolean,
      info_record_type: pft$info_record_type,
      p_info: ^pft$info;

    osp$verify_system_privilege;
    p_group_info_record := p_info_record;

    CASE p_group_info_record^.record_type OF
    = pfc$item_info_record =
      p_info := ^p_group_info_record^.body;
      RESET p_info;
      REPEAT
        p$find_next_info_record (p_info, p_group_info_record, status);
        IF status.normal THEN
          info_record_type := p_group_info_record^.record_type;
          group_info_record_found := (info_record_type = pfc$file_group_record) OR
                (info_record_type = pfc$catalog_group_record);
        IFEND;
      UNTIL NOT status.normal OR group_info_record_found;

    = pfc$catalog_group_record, pfc$file_group_record =
      status.normal := TRUE;

    ELSE
      osp$set_status_condition (pfe$bad_info_record_format, status);
    CASEND;
  PROCEND pfp$locate_group_info_record;

?? TITLE := '  check_cycle_selector', EJECT ??

  PROCEDURE check_cycle_selector
    (    cycle_selector: pft$cycle_selector;
     VAR status: ost$status);

    status.normal := TRUE;
    CASE cycle_selector.cycle_option OF
    = pfc$lowest_cycle, pfc$highest_cycle =
      status.normal := TRUE;

    = pfc$specific_cycle =
      IF (cycle_selector.cycle_number >= pfc$minimum_cycle_number) AND
            (cycle_selector.cycle_number <= pfc$maximum_cycle_number) THEN
        status.normal := TRUE;
      ELSE
        osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$bad_cycle_number, '', status);
        osp$append_status_integer (osc$status_parameter_delimiter, cycle_selector.cycle_number, 10, FALSE,
              status);
      IFEND;

    ELSE
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$bad_cycle_option, '', status);
      osp$append_status_integer (osc$status_parameter_delimiter, $INTEGER (cycle_selector.cycle_option), 10,
            FALSE, status);
    CASEND;
  PROCEND check_cycle_selector;

?? TITLE := '  find_archive_entry', EJECT ??

  PROCEDURE find_archive_entry
    (    p_info_record: pft$p_info_record;
     VAR p_archive_array_entry: pft$p_archive_array_entry;
     VAR p_amd: pft$p_amd;
     VAR status: ost$status);

    VAR
      body_size: pft$info_record_body_size,
      entry_size: pft$info_record_body_size,
      p_record_body: pft$p_info;

    p_archive_array_entry := NIL;
    p_amd := NIL;

    find_record_body (p_info_record, pfc$archive_array_entry_record, p_record_body, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    body_size := #SIZE (p_record_body^);
    entry_size := #SIZE (pft$archive_array_entry);
    IF body_size > 1 THEN
      IF body_size = entry_size THEN
        NEXT p_archive_array_entry IN p_record_body;
      ELSE
        osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$bad_info_record_format, 'ARCHIVE_ENTRY',
              status);
        RETURN; {----->
      IFEND;
    ELSE
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$unknown_archive_entry, '', status);
      RETURN; {----->
    IFEND;

    find_record_body (p_info_record, pfc$archive_amd_record, p_record_body, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    body_size := #SIZE (p_record_body^);
    IF body_size > 1 THEN
      NEXT p_amd: [[REP body_size OF cell]] IN p_record_body;
      IF p_amd = NIL THEN
        osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$bad_info_record_format, '', status);
      IFEND;
    ELSE
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$unknown_archive_media_desc, '', status);
    IFEND;

  PROCEND find_archive_entry;

?? TITLE := '  find_highest_cycle', EJECT ??

  PROCEDURE find_highest_cycle
    (    p_cycle_array: pft$p_cycle_array;
     VAR highest_cycle_index: pft$array_index);

    VAR
      cycle_index: pft$array_index,
      highest_cycle_number: fst$cycle_number;

    highest_cycle_number := pfc$minimum_cycle_number;

    FOR cycle_index := 1 TO UPPERBOUND (p_cycle_array^) DO
      IF p_cycle_array^ [cycle_index].cycle_number >= highest_cycle_number THEN
        highest_cycle_number := p_cycle_array^ [cycle_index].cycle_number;
        highest_cycle_index := cycle_index;
      IFEND;
    FOREND;
  PROCEND find_highest_cycle;

?? TITLE := '  find_highest_cycle_version_2', EJECT ??

  PROCEDURE find_highest_cycle_version_2
    (    p_cycle_array: ^pft$cycle_array_version_2;
     VAR highest_cycle_index: pft$array_index);

    VAR
      cycle_index: pft$array_index,
      highest_cycle_number: fst$cycle_number;

    highest_cycle_number := pfc$minimum_cycle_number;

    FOR cycle_index := 1 TO UPPERBOUND (p_cycle_array^) DO
      IF p_cycle_array^ [cycle_index].cycle_number >= highest_cycle_number THEN
        highest_cycle_number := p_cycle_array^ [cycle_index].cycle_number;
        highest_cycle_index := cycle_index;
      IFEND;
    FOREND;

  PROCEND find_highest_cycle_version_2;

?? TITLE := '  find_lowest_cycle', EJECT ??

  PROCEDURE find_lowest_cycle
    (    p_cycle_array: pft$p_cycle_array;
     VAR lowest_cycle_index: pft$array_index);

    VAR
      cycle_index: pft$array_index,
      lowest_cycle_number: fst$cycle_number;

    lowest_cycle_number := pfc$maximum_cycle_number;

    FOR cycle_index := 1 TO UPPERBOUND (p_cycle_array^) DO
      IF p_cycle_array^ [cycle_index].cycle_number <= lowest_cycle_number THEN
        lowest_cycle_number := p_cycle_array^ [cycle_index].cycle_number;
        lowest_cycle_index := cycle_index;
      IFEND;
    FOREND;
  PROCEND find_lowest_cycle;

?? TITLE := '  find_lowest_cycle_version_2', EJECT ??

  PROCEDURE find_lowest_cycle_version_2
    (    p_cycle_array: ^pft$cycle_array_version_2;
     VAR lowest_cycle_index: pft$array_index);

    VAR
      cycle_index: pft$array_index,
      lowest_cycle_number: fst$cycle_number;

    lowest_cycle_number := pfc$maximum_cycle_number;

    FOR cycle_index := 1 TO UPPERBOUND (p_cycle_array^) DO
      IF p_cycle_array^ [cycle_index].cycle_number <= lowest_cycle_number THEN
        lowest_cycle_number := p_cycle_array^ [cycle_index].cycle_number;
        lowest_cycle_index := cycle_index;
      IFEND;
    FOREND;

  PROCEND find_lowest_cycle_version_2;

?? TITLE := '  find_record', EJECT ??

  PROCEDURE find_record
    (    p_info_record: pft$p_info_record;
         record_type: pft$info_record_type;
     VAR p_found_record: pft$p_info_record;
     VAR status: ost$status);

    VAR
      p_info: pft$p_info,
      p_next_info_record: pft$p_info_record;

    status.normal := TRUE;
    p_info := ^p_info_record^.body;
    RESET p_info;

    REPEAT
      p$find_next_info_record (p_info, p_next_info_record, status);
    UNTIL NOT status.normal OR (p_next_info_record^.record_type = record_type);

    IF status.normal THEN
      p_found_record := p_next_info_record;
    IFEND;
  PROCEND find_record;

?? TITLE := '  find_record_body', EJECT ??

  PROCEDURE find_record_body
    (    p_info_record: pft$p_info_record;
         record_type: pft$info_record_type;
     VAR p_record_body: pft$p_info;
     VAR status: ost$status);

    VAR
      p_info: pft$p_info,
      p_next_info_record: pft$p_info_record;

    status.normal := TRUE;
    p_info := ^p_info_record^.body;
    RESET p_info;

    REPEAT
      p$find_next_info_record (p_info, p_next_info_record, status);
    UNTIL NOT status.normal OR (p_next_info_record^.record_type = record_type);

    IF status.normal THEN
      p_record_body := ^p_next_info_record^.body;
      RESET p_record_body;
    IFEND;

  PROCEND find_record_body;

?? TITLE := '  find_specific_cycle', EJECT ??

  PROCEDURE find_specific_cycle
    (    p_cycle_array: pft$p_cycle_array;
         cycle_number: fst$cycle_number;
     VAR specific_cycle_index: pft$array_index;
     VAR status: ost$status);

    VAR
      cycle_index: pft$array_index;

    FOR cycle_index := 1 TO UPPERBOUND (p_cycle_array^) DO
      IF p_cycle_array^ [cycle_index].cycle_number = cycle_number THEN
        specific_cycle_index := cycle_index;
        status.normal := TRUE;
        RETURN; {----->
      IFEND;
    FOREND;

    osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$unknown_cycle, '', status);
    osp$append_status_integer (osc$status_parameter_delimiter, cycle_number, 10, FALSE, status);
  PROCEND find_specific_cycle;

?? TITLE := '  find_specific_cycle_version_2', EJECT ??

  PROCEDURE find_specific_cycle_version_2
    (    p_cycle_array: ^pft$cycle_array_version_2;
         cycle_number: fst$cycle_number;
     VAR specific_cycle_index: pft$array_index;
     VAR status: ost$status);

    VAR
      cycle_index: pft$array_index;

    FOR cycle_index := 1 TO UPPERBOUND (p_cycle_array^) DO
      IF p_cycle_array^ [cycle_index].cycle_number = cycle_number THEN
        specific_cycle_index := cycle_index;
        status.normal := TRUE;
        RETURN; {----->
      IFEND;
    FOREND;

    osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$unknown_cycle, '', status);
    osp$append_status_integer (osc$status_parameter_delimiter, cycle_number, 10, FALSE, status);

  PROCEND find_specific_cycle_version_2;

?? OLDTITLE, SKIP := 2 ??
MODEND pfm$find_information;
