?? RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE SCL Interpreter : Display_File_Attributes Command and $FILE Function' ??
MODULE clm$display_file_attb_command;
?? RIGHT := 110 ??

{
{ PURPOSE:
{   This module contains the processors of the display_file_attributes command and $file function.
{

?? NEWTITLE := 'Global Declarations referenced by this Module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc i#current_sequence_position
*copyc oss$job_paged_literal
*copyc fsc$local
*copyc rmc$unspecified_file_class
*copyc osd$exception_policies
*copyc osd$integer_limits
*copyc ame$attribute_validation_errors
*copyc ame$lfn_program_actions
*copyc ame$ring_validation_errors
*copyc cle$ecc_file_reference
*copyc cle$work_area_overflow
*copyc fse$get_info_validation_errors
*copyc fse$system_conditions
*copyc nfe$ptf_condition_codes
*copyc pfe$error_condition_codes
*copyc pfe$internal_error_conditions
*copyc bat$static_label_attributes
*copyc clt$parameter_list
*copyc fst$cycle_damage_symptoms
*copyc fst$goi_object
*copyc fst$goi_object_information
*copyc fst$path
*copyc ost$caller_identifier
*copyc ost$halfword
?? POP ??
*copyc amp$get_file_attributes
*copyc amp$return
*copyc avp$system_administrator
*copyc bap$get_default_file_attribs
*copyc bap$is_file_registered
*copyc bap$process_pt_request
*copyc clp$build_path_subtitle
*copyc clp$build_standard_title
*copyc clp$close_display
*copyc clp$convert_cyc_ref_to_cyc_sel
*copyc clp$convert_data_to_string
*copyc clp$convert_file_ref_to_string
*copyc clp$convert_integer_to_string
*copyc clp$convert_str_to_path_handle
*copyc clp$convert_string_to_file_ref
*copyc clp$count_list_elements
*copyc clp$evaluate_file_reference
*copyc clp$evaluate_parameters
*copyc clp$find_current_block
*copyc clp$get_fs_path_elements
*copyc clp$get_ultimate_connection
*copyc clp$get_work_area
*copyc clp$get_working_catalog
*copyc clp$horizontal_tab_display
*copyc clp$make_boolean_value
*copyc clp$make_date_time_value
*copyc clp$make_entry_point_ref_value
*copyc clp$make_file_value
*copyc clp$make_integer_value
*copyc clp$make_keyword_value
*copyc clp$make_list_value
*copyc clp$make_name_value
*copyc clp$make_record_value
*copyc clp$make_status_value
*copyc clp$make_string_value
*copyc clp$make_unspecified_value
*copyc clp$new_display_line
*copyc clp$new_display_page
*copyc clp$open_display_reference
*copyc clp$put_data_representation
*copyc clp$put_display
*copyc clp$put_partial_display
*copyc clp$reset_for_next_display_page
*copyc clp$scan_argument_list
*copyc clp$trimmed_string_size
*copyc clp$validate_name
*copyc fsp$adjust_tape_defaults
*copyc fsp$convert_file_contents
*copyc fsp$convert_fs_structure_to_pf
*copyc fsp$determine_global_access
*copyc fsp$expand_file_label
*copyc fsp$file_is_$job_log
*copyc fsp$path_element
*copyc ifp$get_page_length_width
*copyc mmp$create_scratch_segment
*copyc mmp$delete_scratch_segment
*copyc nfp$check_implicit_access
*copyc nfp$perform_implicit_access
*copyc osp$append_status_file
*copyc osp$append_status_parameter
*copyc osp$disestablish_cond_handler
*copyc osp$enforce_exception_policies
*copyc osp$establish_block_exit_hndlr
*copyc osp$file_access_condition
*copyc osp$find_access_condition_entry
*copyc osp$format_message
*copyc osp$format_wait_message
*copyc osp$generate_log_message
*copyc osp$get_status_condition_name
*copyc osp$set_status_abnormal
*copyc osp$set_status_condition
*copyc pfp$get_object_information
*copyc pfp$r3_get_object_information
*copyc pfp$utility_attach
*copyc pmp$compute_date_time
*copyc pmp$convert_binary_unique_name
*copyc pmp$date_time_compare
*copyc pmp$get_compact_date_time
*copyc pmp$get_unique_name
*copyc pmp$get_user_identification
*copyc rmp$get_device_class
*copyc amv$nil_file_identifier
*copyc clv$nil_display_control
*copyc clv$value_descriptors
*copyc fsv$evaluated_file_reference
*copyc osv$initial_exception_context
*copyc osv$lower_to_upper
*copyc osv$upper_to_lower
*copyc pfv$null_unique_name
?? OLDTITLE ??
?? NEWTITLE := 'Global Declarations declared by this Module', EJECT ??

  CONST
    max_access_share_mode_size = 7, {shorten,execute
    max_block_type_size = 16, {system_specified
    max_class_size = 15, {interstate_link,memory_resident
    max_file_contents = 15,
    max_file_organization_size = 18, {indexed_sequential
    max_file_processor = 18,
    max_forced_write_size = 26, {forced_if_structure_change
    max_global_file_position_size = 15, {end_of_key_list
    max_internal_code_size = 13, {ftam2 general
    max_job_file_position_size = 16, {$end_of_key_list
    max_key_type_size = 10, {uncollated
    max_label_type_size = 20, {non_standard_labeled
    max_logging_option_size = 23, {enable_request_recovery
    max_message_control_size = 14, {trivial_errors
    max_mf_attachment_size = 20, {requesting_mainframe
    max_open_position_size = 5, {$asis
    max_page_format_size = 13, {non_burstable
    max_record_type_size = 28, {trailing_character_delimited
    max_tape_density_size = 10, {mt18$38000
    max_write_concurrency_size = 22; {not_attached_for_write

  VAR
    access_share_modes: [STATIC, READ, oss$job_paged_literal] array [fst$file_access_option] of
          string (max_access_share_mode_size) := ['READ', 'SHORTEN', 'APPEND', 'MODIFY', 'EXECUTE'],
    block_types: [STATIC, READ, oss$job_paged_literal] array [amt$block_type] of
          string (max_block_type_size) := ['SYSTEM_SPECIFIED', 'USER_SPECIFIED'],
    class: [STATIC, READ, oss$job_paged_literal] array [rmt$device_class] of string (max_class_size) :=
          ['CONNECTED_FILE', 'INTERSTATE_LINK', 'LOCAL_QUEUE', 'LOG', 'MAGNETIC_TAPE', 'MASS_STORAGE',
          'MEMORY_RESIDENT', 'NETWORK', 'NULL', 'PIPELINE', 'RHFAM', 'TERMINAL'],
    file_organizations: [STATIC, READ, oss$job_paged_literal] array [amt$file_organization] of
          string (max_file_organization_size) := ['SEQUENTIAL', 'BYTE_ADDRESSABLE', 'INDEXED_SEQUENTIAL',
          'DIRECT_ACCESS', 'SYSTEM_KEY'],
    global_file_positions: [STATIC, READ, oss$job_paged_literal] array [amt$file_position] of
          string (max_global_file_position_size) := ['BOI', 'BOP', 'MID_RECORD', 'EOR', 'EOP', 'EOI',
          'END_OF_KEY_LIST'],
    internal_codes: [STATIC, READ, oss$job_paged_literal] array [amt$internal_code] of
          string (max_internal_code_size) := ['A6', 'A8', 'ASCII', 'D64', 'EBCDIC', 'BCD', 'D63', 'FTAM1 IA5',
          'FTAM1 VISIBLE', 'FTAM1 GRAPHIC', 'FTAM1 GENERAL', 'FTAM2 IA5', 'FTAM2 VISIBLE', 'FTAM2 GRAPHIC',
          'FTAM2 GENERAL'],
    job_file_positions: [STATIC, READ, oss$job_paged_literal] array [amt$file_position] of
          string (max_job_file_position_size) := ['$BOI', '$BOP', '$MID_RECORD', '$EOR', '$EOP', '$EOI',
          '$END_OF_KEY_LIST'],
    key_types: [STATIC, READ, oss$job_paged_literal] array [amt$key_type] of string (max_key_type_size) :=
          ['COLLATED', 'INTEGER', 'UNCOLLATED'],
    label_types: [STATIC, READ, oss$job_paged_literal] array [amt$label_type] of
          string (max_label_type_size) := ['LABELED', 'NON_STANDARD_LABELED', 'UNLABELED'],
    logging_possibilities: [STATIC, READ, oss$job_paged_literal] array
          [amc$enable_parcels .. amc$enable_request_recovery] of string (max_logging_option_size) :=
          ['ENABLE_PARCELS', 'ENABLE_MEDIA_RECOVERY', 'ENABLE_REQUEST_RECOVERY'],
    mainframe_attachments: [STATIC, READ, oss$job_paged_literal] array [fst$mf_usage_concurrency_scope] of
          string (max_mf_attachment_size) := ['REQUESTING_MAINFRAME', 'DIFFERENT_MAINFRAME'],
    mainframe_write_concurrencies: [STATIC, READ, oss$job_paged_literal]
          array [fst$mainframe_write_concurrency] of string (max_write_concurrency_size) :=
          ['NOT_ATTACHED_FOR_WRITE', 'SHARED_MEMORY', 'SHARED_MASS_STORAGE'],
    message_controls: [STATIC, READ, oss$job_paged_literal] array [amc$trivial_errors .. amc$statistics] of
          string (max_message_control_size) := ['TRIVIAL_ERRORS', 'MESSAGES', 'STATISTICS'],
    page_formats: [STATIC, READ, oss$job_paged_literal] array [amt$page_format] of
          string (max_page_format_size) := ['CONTINUOUS', 'BURSTABLE', 'NON_BURSTABLE', 'UNTITLED'],
    permit_share_options: [STATIC, READ, oss$job_paged_literal] array [pft$permit_options] of
          string (max_access_share_mode_size) := ['READ', 'SHORTEN', 'APPEND', 'MODIFY', 'EXECUTE', 'CYCLE',
          'CONTROL'],
    record_types: [STATIC, READ, oss$job_paged_literal] array [amt$record_type] of
          string (max_record_type_size) := ['VARIABLE', 'UNDEFINED', 'ANSI_FIXED', 'ANSI_SPANNED',
          'ANSI_VARIABLE', 'TRAILING_CHARACTER_DELIMITED'],
    reserved_file_processors: [STATIC, READ, oss$job_paged_literal] array [1 .. max_file_processor] of
          amt$file_processor := ['ADA', 'APL', 'ASSEMBLER', 'BASIC', 'C', 'COBOL', 'CYBIL', 'DEBUGGER',
          'FORTRAN', 'LISP', 'PASCAL', 'PLI', 'PPU_ASSEMBLER', 'PROLOG', 'SCL', 'SCU', 'VS', 'UNKNOWN'],
    tape_densities: [STATIC, READ, oss$job_paged_literal] array [rmc$200 .. rmc$38000] of
          string (max_tape_density_size) := ['MT9$200', 'MT9$556', 'MT9$800', 'MT9$1600', 'MT9$6250',
          'MT18$38000'];

  VAR
    clv$open_positions: [XDCL, #GATE, READ, oss$job_paged_literal] array [amt$open_position] of
          string (max_open_position_size) := ['$ASIS', '$BOI', '$BOP', '$EOI'];

?? EJECT ??

?? PUSH (LISTEXT := ON) ??
?? FMT (TAB := '=', 40) ??
?? POP ??

  CONST
    access_control_list                = 001,
    account_project                    = 002,
    actual_job_access                  = 003,
    archive_media_information          = 004,
    attached                           = 005,
    attached_external_vsn_list         = 006,
    attached_recorded_vsn_list         = 007,
    attached_transfer_size             = 008,
    attached_vol_overflow_allowed      = 009,
    attached_volume_number             = 010,
    attachment_log                     = 011,
    attachment_logging_selected        = 012,
    attachment_status                  = 013,
    average_record_length              = 014,
    block_type                         = 015,
    character_conversion               = 016,
    collate_table_name                 = 017,
    complete_path                      = 018,
    compression_procedure_name         = 019,
    connected_files                    = 020,
    creation_date_time                 = 021,
    cycle_number                       = 022,
    cycle_path                         = 023,
    data_padding                       = 024,
    device_class                       = 025,
    dynamic_home_block_space           = 026,
    embedded_key                       = 027,
    error_exit_procedure_name          = 028,
    error_limit                        = 029,
    estimated_record_count             = 030,
    exception_conditions               = 031,
    expiration_date                    = 032,
    external_vsn_list                  = 033,
    file_access_procedure_name         = 034,
    file_contents                      = 035,
    file_label_type                    = 036,
    file_limit                         = 037,
    file_organization                  = 038,
    file_previously_opened             = 039,
    file_processor                     = 040,
    forced_write                       = 041,
    hashing_procedure_name             = 042,
    index_levels                       = 043,
    index_padding                      = 044,
    initial_home_block_count           = 045,
    internal_code                      = 046,
    job_file_address                   = 047,
    job_file_position                  = 048,
    job_instances_of_open              = 049,
    job_write_concurrency              = 050,
    key_length                         = 051,
    key_position                       = 052,
    key_type                           = 053,
    last_access_date_time              = 054,
    last_data_modification_time        = 055,
    last_modification_date_time        = 056,
    lifetime                           = 057,
    lifetime_attachment_count          = 058,
    line_number                        = 059,
    loading_factor                     = 060,
    lock_expiration_time               = 061,
    log_residence                      = 062,
    logging_options                    = 063,
    mainframe_attachment               = 064,
    mainframe_write_concurrency        = 065,
    mass_storage_allocation_size       = 066,
    mass_storage_bytes_allocated       = 067,
    mass_storage_class                 = 068,
    mass_storage_free_behind           = 069,
    mass_storage_initial_volume        = 070,
    mass_storage_sequential_access     = 071,
    mass_storage_transfer_size         = 072,
    maximum_block_length               = 073,
    maximum_record_length              = 074,
    message_control                    = 075,
    minimum_block_length               = 076,
    minimum_record_length              = 077,
    object_type                        = 078,
    open_position                      = 079,
    padding_character                  = 080,
    page_format                        = 081,
    page_length                        = 082,
    page_width                         = 083,
    path                               = 084,
    permitted_access                   = 085,
    potential_job_access               = 086,
    preset_value                       = 087,
    private_read                       = 088,
    record_delimiting_character        = 089,
    record_limit                       = 090,
    record_type                        = 091,
    recorded_vsn_list                  = 092,
    records_per_block                  = 093,
    registered                         = 094,
    removable_media_group              = 095,
    retrieve_option                    = 096,
    ring_attributes                    = 097,
    secondary_residence                = 098,
    set_name                           = 099,
    shared_queue                       = 100,
    site_archive_option                = 101,
    site_backup_option                 = 102,
    site_release_option                = 103,
    size                               = 104,
    statement_identifier               = 105,
    tape_density                       = 106,
    unique_data_name                   = 107,
    unique_name                        = 108,
    user_information                   = 109,
    vertical_print_density             = 110,
    volume_overflow_allowed            = 111,

    attribute_key_max                  = 111,
    catalog_attribute_max              = 19,
    cycle_attribute_max                = 106,
    file_attribute_max                 = 11;

?? PUSH (LISTEXT := ON) ??
?? FMT (CLEARTAB := '=', ALL) ??
?? POP ??

  TYPE
    file_attribute_key = 1 .. attribute_key_max,
    file_attribute_keys = set of file_attribute_key,
    object_type_counts = record
      catalog_type: 0 .. catalog_attribute_max,
      file_type: 0 .. file_attribute_max,
      cycle_type: 0 .. cycle_attribute_max,
    recend,
    object_types = (catalog_object_type, cycle_object_type, file_object_type),
    unknown_object_pf_condition = pfe$unknown_cycle .. pfe$unknown_item;

  VAR
    catalog_and_cycle_identity: [READ, oss$job_paged_literal] file_attribute_keys :=
          [complete_path, cycle_path, device_class, lifetime, object_type, path, registered, set_name,
          unique_data_name, unique_name],
    catalog_device_attributes: [READ, oss$job_paged_literal] file_attribute_keys :=
          [exception_conditions, mass_storage_allocation_size, mass_storage_bytes_allocated,
          mass_storage_class, recorded_vsn_list],
    cycle_info: [READ, oss$job_paged_literal] file_attribute_keys :=
          [attachment_status, creation_date_time, exception_conditions, expiration_date,
          last_access_date_time, last_data_modification_time, last_modification_date_time,
          lifetime_attachment_count, mainframe_attachment, mainframe_write_concurrency, potential_job_access,
          retrieve_option, site_archive_option, site_backup_option, site_release_option],
    device_info: [READ, oss$job_paged_literal] file_attribute_keys :=
          [exception_conditions, external_vsn_list, file_label_type, mass_storage_allocation_size,
          mass_storage_bytes_allocated, mass_storage_class, mass_storage_initial_volume,
          mass_storage_transfer_size, maximum_block_length, recorded_vsn_list, removable_media_group,
          shared_queue, tape_density, volume_overflow_allowed],
    file_info: [READ, oss$job_paged_literal] file_attribute_keys :=
          [attachment_log, attachment_logging_selected],
    file_label_attributes: [READ, oss$job_paged_literal] file_attribute_keys :=
          [average_record_length, block_type, character_conversion, collate_table_name,
          compression_procedure_name, data_padding, dynamic_home_block_space, embedded_key,
          estimated_record_count, file_access_procedure_name, file_contents, file_label_type, file_limit,
          file_organization, file_previously_opened, file_processor, forced_write, hashing_procedure_name,
          index_levels, index_padding, initial_home_block_count, internal_code, key_length, key_position,
          key_type, line_number, loading_factor, lock_expiration_time, log_residence, logging_options,
          maximum_block_length, maximum_record_length, minimum_block_length, minimum_record_length,
          padding_character, page_format, page_length, page_width, preset_value, record_delimiting_character,
          record_limit, record_type, records_per_block, ring_attributes, statement_identifier,
          user_information, vertical_print_density],
    job_environment_info: [READ, oss$job_paged_literal] file_attribute_keys :=
          [actual_job_access, attached, attached_external_vsn_list, attached_recorded_vsn_list,
          attached_transfer_size, attached_vol_overflow_allowed, attached_volume_number, connected_files,
          error_exit_procedure_name, error_limit, job_file_address, job_file_position, job_instances_of_open,
          job_write_concurrency, mass_storage_free_behind, mass_storage_sequential_access, message_control,
          open_position, potential_job_access, private_read];

  VAR
    boolean_kind: [READ, oss$job_paged_literal] clt$boolean_kinds := clc$yes_no_boolean,
    file_label_info_request: [oss$job_paged_literal, READ] fst$goi_information_request :=
          [[fsc$specific_depth, 1], [fsc$goi_file_label]],
    initial_information_request: [oss$job_paged_literal, READ] fst$goi_information_request :=
          [[fsc$specific_depth, 1], []],
    null_unique_name: [oss$job_paged_literal, READ] ost$binary_unique_name :=
          [0, 0, 1980, 1, 1, 0, 0, 0, 0, 0],
    unknown_object_pf_conditions: [READ, oss$job_paged_literal] set of unknown_object_pf_condition :=
          [pfe$unknown_cycle, pfe$unknown_item, pfe$unknown_nth_subcatalog];

  CONST
    attribute_category_max = 7,
    nil_object_info_text = 'NEXT of object_information in work_area resulted in a NIL pointer in ' CAT
          'DISPLAY_FILE_ATTRIBUTES',
    old_$file_attb_max = 18;

  VAR
    attb_table_for_$file: [STATIC, READ, oss$job_paged_literal] array [1 .. old_$file_attb_max] of record
      name: ost$name,
      key: amt$file_attribute_keys,
    recend := [
          {} ['APPLICATION_INFORMATION        ', amc$application_info],
          {} ['ASSIGNED                       ', amc$null_attribute],
          {} ['ATTACHED                       ', amc$null_attribute],
          {} ['CATALOG                        ', amc$null_attribute],
          {} ['CYCLE_NUMBER                   ', amc$null_attribute],
          {} ['DEVICE_CLASS                   ', amc$null_attribute],
          {} ['FILE_CONTENTS                  ', amc$file_contents],
          {} ['FILE_LABEL_TYPE                ', amc$label_type],
          {} ['FILE_ORGANIZATION              ', amc$file_organization],
          {} ['FILE_PROCESSOR                 ', amc$file_processor],
          {} ['FILE_STRUCTURE                 ', amc$file_structure],
          {} ['GLOBAL_FILE_POSITION           ', amc$global_file_position],
          {} ['OPENED                         ', amc$null_attribute],
          {} ['OPEN_POSITION                  ', amc$open_position],
          {} ['PERMANENT                      ', amc$null_attribute],
          {} ['SIZE                           ', amc$file_length],
          {} ['TEMPORARY                      ', amc$null_attribute],
          {} ['USER_INFORMATION               ', amc$user_info]];

  VAR

{ The order of the entries in this array correspond to the order of the attribute constants defined above.

    attribute_choices: [STATIC, READ, oss$job_paged_literal] array [1 .. attribute_key_max] of record
      name: ost$name,
      applicable_object_types: set of object_types,
    recend := [
          {} ['ACCESS_CONTROL_LIST            ', [catalog_object_type, file_object_type]],
          {} ['ACCOUNT_PROJECT                ', [catalog_object_type, file_object_type]],
          {} ['ACTUAL_JOB_ACCESS              ', [cycle_object_type]],
          {} ['ARCHIVE_MEDIA_INFORMATION      ', [cycle_object_type]],
          {} ['ATTACHED                       ', [cycle_object_type]],
          {} ['ATTACHED_EXTERNAL_VSN_LIST     ', [cycle_object_type]],
          {} ['ATTACHED_RECORDED_VSN_LIST     ', [cycle_object_type]],
          {} ['ATTACHED_TRANSFER_SIZE         ', [cycle_object_type]],
          {} ['ATTACHED_VOL_OVERFLOW_ALLOWED  ', [cycle_object_type]],
          {} ['ATTACHED_VOLUME_NUMBER         ', [cycle_object_type]],
          {} ['ATTACHMENT_LOG                 ', [file_object_type]],
          {} ['ATTACHMENT_LOGGING_SELECTED    ', [file_object_type]],
          {} ['ATTACHMENT_STATUS              ', [cycle_object_type]],
          {} ['AVERAGE_RECORD_LENGTH          ', [cycle_object_type]],
          {} ['BLOCK_TYPE                     ', [cycle_object_type]],
          {} ['CHARACTER_CONVERSION           ', [cycle_object_type]],
          {} ['COLLATE_TABLE_NAME             ', [cycle_object_type]],
          {} ['COMPLETE_PATH                  ', [cycle_object_type]],
          {} ['COMPRESSION_PROCEDURE_NAME     ', [cycle_object_type]],
          {} ['CONNECTED_FILES                ', [cycle_object_type]],
          {} ['CREATION_DATE_TIME             ', [catalog_object_type, cycle_object_type]],
          {} ['CYCLE_NUMBER                   ', [cycle_object_type]],
          {} ['CYCLE_PATH                     ', [cycle_object_type]],
          {} ['DATA_PADDING                   ', [cycle_object_type]],
          {} ['DEVICE_CLASS                   ', [catalog_object_type, cycle_object_type]],
          {} ['DYNAMIC_HOME_BLOCK_SPACE       ', [cycle_object_type]],
          {} ['EMBEDDED_KEY                   ', [cycle_object_type]],
          {} ['ERROR_EXIT_PROCEDURE_NAME      ', [cycle_object_type]],
          {} ['ERROR_LIMIT                    ', [cycle_object_type]],
          {} ['ESTIMATED_RECORD_COUNT         ', [cycle_object_type]],
          {} ['EXCEPTION_CONDITIONS           ', [catalog_object_type, cycle_object_type]],
          {} ['EXPIRATION_DATE                ', [cycle_object_type]],
          {} ['EXTERNAL_VSN_LIST              ', [cycle_object_type]],
          {} ['FILE_ACCESS_PROCEDURE_NAME     ', [cycle_object_type]],
          {} ['FILE_CONTENTS                  ', [cycle_object_type]],
          {} ['FILE_LABEL_TYPE                ', [cycle_object_type]],
          {} ['FILE_LIMIT                     ', [cycle_object_type]],
          {} ['FILE_ORGANIZATION              ', [cycle_object_type]],
          {} ['FILE_PREVIOUSLY_OPENED         ', [cycle_object_type]],
          {} ['FILE_PROCESSOR                 ', [cycle_object_type]],
          {} ['FORCED_WRITE                   ', [cycle_object_type]],
          {} ['HASHING_PROCEDURE_NAME         ', [cycle_object_type]],
          {} ['INDEX_LEVELS                   ', [cycle_object_type]],
          {} ['INDEX_PADDING                  ', [cycle_object_type]],
          {} ['INITIAL_HOME_BLOCK_COUNT       ', [cycle_object_type]],
          {} ['INTERNAL_CODE                  ', [cycle_object_type]],
          {} ['JOB_FILE_ADDRESS               ', [cycle_object_type]],
          {} ['JOB_FILE_POSITION              ', [cycle_object_type]],
          {} ['JOB_INSTANCES_OF_OPEN          ', [cycle_object_type]],
          {} ['JOB_WRITE_CONCURRENCY          ', [cycle_object_type]],
          {} ['KEY_LENGTH                     ', [cycle_object_type]],
          {} ['KEY_POSITION                   ', [cycle_object_type]],
          {} ['KEY_TYPE                       ', [cycle_object_type]],
          {} ['LAST_ACCESS_DATE_TIME          ', [cycle_object_type]],
          {} ['LAST_DATA_MODIFICATION_TIME    ', [cycle_object_type]],
          {} ['LAST_MODIFICATION_DATE_TIME    ', [cycle_object_type]],
          {} ['LIFETIME                       ', [catalog_object_type, file_object_type, cycle_object_type]],
          {} ['LIFETIME_ATTACHMENT_COUNT      ', [cycle_object_type]],
          {} ['LINE_NUMBER                    ', [cycle_object_type]],
          {} ['LOADING_FACTOR                 ', [cycle_object_type]],
          {} ['LOCK_EXPIRATION_TIME           ', [cycle_object_type]],
          {} ['LOG_RESIDENCE                  ', [cycle_object_type]],
          {} ['LOGGING_OPTIONS                ', [cycle_object_type]],
          {} ['MAINFRAME_ATTACHMENT           ', [cycle_object_type]],
          {} ['MAINFRAME_WRITE_CONCURRENCY    ', [cycle_object_type]],
          {} ['MASS_STORAGE_ALLOCATION_SIZE   ', [catalog_object_type, cycle_object_type]],
          {} ['MASS_STORAGE_BYTES_ALLOCATED   ', [catalog_object_type, cycle_object_type]],
          {} ['MASS_STORAGE_CLASS             ', [catalog_object_type, cycle_object_type]],
          {} ['MASS_STORAGE_FREE_BEHIND       ', [cycle_object_type]],
          {} ['MASS_STORAGE_INITIAL_VOLUME    ', [cycle_object_type]],
          {} ['MASS_STORAGE_SEQUENTIAL_ACCESS ', [cycle_object_type]],
          {} ['MASS_STORAGE_TRANSFER_SIZE     ', [cycle_object_type]],
          {} ['MAXIMUM_BLOCK_LENGTH           ', [cycle_object_type]],
          {} ['MAXIMUM_RECORD_LENGTH          ', [cycle_object_type]],
          {} ['MESSAGE_CONTROL                ', [cycle_object_type]],
          {} ['MINIMUM_BLOCK_LENGTH           ', [cycle_object_type]],
          {} ['MINIMUM_RECORD_LENGTH          ', [cycle_object_type]],
          {} ['OBJECT_TYPE                    ', [catalog_object_type, file_object_type, cycle_object_type]],
          {} ['OPEN_POSITION                  ', [cycle_object_type]],
          {} ['PADDING_CHARACTER              ', [cycle_object_type]],
          {} ['PAGE_FORMAT                    ', [cycle_object_type]],
          {} ['PAGE_LENGTH                    ', [cycle_object_type]],
          {} ['PAGE_WIDTH                     ', [cycle_object_type]],
          {} ['PATH                           ', [catalog_object_type, file_object_type, cycle_object_type]],
          {} ['PERMITTED_ACCESS               ', [catalog_object_type, file_object_type]],
          {} ['POTENTIAL_JOB_ACCESS           ', [cycle_object_type]],
          {} ['PRESET_VALUE                   ', [cycle_object_type]],
          {} ['PRIVATE_READ                   ', [cycle_object_type]],
          {} ['RECORD_DELIMITING_CHARACTER    ', [cycle_object_type]],
          {} ['RECORD_LIMIT                   ', [cycle_object_type]],
          {} ['RECORD_TYPE                    ', [cycle_object_type]],
          {} ['RECORDED_VSN_LIST              ', [catalog_object_type, cycle_object_type]],
          {} ['RECORDS_PER_BLOCK              ', [cycle_object_type]],
          {} ['REGISTERED                     ', [catalog_object_type, file_object_type, cycle_object_type]],
          {} ['REMOVABLE_MEDIA_GROUP          ', [cycle_object_type]],
          {} ['RETRIEVE_OPTION                ', [cycle_object_type]],
          {} ['RING_ATTRIBUTES                ', [cycle_object_type]],
          {} ['SECONDARY_RESIDENCE            ', [cycle_object_type]],
          {} ['SET_NAME                       ', [catalog_object_type, file_object_type, cycle_object_type]],
          {} ['SHARED_QUEUE                   ', [cycle_object_type]],
          {} ['SITE_ARCHIVE_OPTION            ', [cycle_object_type]],
          {} ['SITE_BACKUP_OPTION             ', [cycle_object_type]],
          {} ['SITE_RELEASE_OPTION            ', [cycle_object_type]],
          {} ['SIZE                           ', [catalog_object_type, cycle_object_type]],
          {} ['STATEMENT_IDENTIFIER           ', [cycle_object_type]],
          {} ['TAPE_DENSITY                   ', [cycle_object_type]],
          {} ['UNIQUE_DATA_NAME               ', [catalog_object_type, cycle_object_type]],
          {} ['UNIQUE_NAME                    ', [catalog_object_type, file_object_type, cycle_object_type]],
          {} ['USER_INFORMATION               ', [cycle_object_type]],
          {} ['VERTICAL_PRINT_DENSITY         ', [cycle_object_type]],
          {} ['VOLUME_OVERFLOW_ALLOWED        ', [catalog_object_type, cycle_object_type]]];

  VAR
    category_choices: [STATIC, READ, oss$job_paged_literal] array [1 .. attribute_category_max] of record
      name: ost$name,
      associated_attributes: file_attribute_keys,
      attribute_sums: object_type_counts,
    recend := [['ALL', [access_control_list, account_project, actual_job_access, archive_media_information,
          attached, attached_external_vsn_list, attached_recorded_vsn_list, attached_transfer_size,
          attached_vol_overflow_allowed, attached_volume_number, attachment_log, attachment_logging_selected,
          attachment_status, average_record_length, block_type, character_conversion, collate_table_name,
          complete_path, compression_procedure_name, connected_files, creation_date_time, cycle_number,
          cycle_path, data_padding, device_class, dynamic_home_block_space, embedded_key,
          error_exit_procedure_name, error_limit, estimated_record_count, exception_conditions,
          expiration_date, external_vsn_list, file_access_procedure_name, file_contents, file_label_type,
          file_limit, file_organization, file_previously_opened, file_processor, forced_write,
          hashing_procedure_name, index_levels, index_padding, initial_home_block_count, internal_code,
          job_file_address, job_file_position, job_instances_of_open, job_write_concurrency, key_length,
          key_position, key_type, last_access_date_time, last_data_modification_time,
          last_modification_date_time, lifetime, lifetime_attachment_count, line_number, loading_factor,
          lock_expiration_time, log_residence, logging_options, mainframe_attachment,
          mainframe_write_concurrency, mass_storage_allocation_size, mass_storage_bytes_allocated,
          mass_storage_class, mass_storage_free_behind, mass_storage_initial_volume,
          mass_storage_sequential_access, mass_storage_transfer_size, maximum_block_length,
          maximum_record_length, message_control, minimum_block_length, minimum_record_length, object_type,
          open_position, padding_character, page_format, page_length, page_width, path, permitted_access,
          potential_job_access, preset_value, private_read, record_delimiting_character, record_limit,
          record_type, recorded_vsn_list, records_per_block, registered, removable_media_group,
          retrieve_option, ring_attributes, secondary_residence, set_name, shared_queue, site_archive_option,
          site_backup_option, site_release_option, size, statement_identifier, tape_density, unique_data_name,
          unique_name, user_information, vertical_print_density, volume_overflow_allowed],
          [catalog_attribute_max, file_attribute_max, cycle_attribute_max]],

    ['CATALOG_REGISTRATION_ATTRIBUTES', [access_control_list, account_project, attachment_log,
          attachment_logging_selected, creation_date_time, cycle_number, exception_conditions,
          expiration_date, file_previously_opened, last_access_date_time, last_data_modification_time,
          last_modification_date_time, lifetime, lifetime_attachment_count, mainframe_attachment,
          mainframe_write_concurrency, object_type, path, permitted_access, potential_job_access, registered,
          secondary_residence, set_name, unique_data_name, unique_name], [12, 11, 20]],

    ['COMMON_FILE_ATTRIBUTES', [block_type, character_conversion, file_access_procedure_name, file_contents,
          file_label_type, file_limit, file_organization, file_processor, forced_write, internal_code,
          maximum_block_length, maximum_record_length, minimum_block_length, minimum_record_length,
          padding_character, preset_value, record_delimiting_character, record_type, ring_attributes,
          user_information], [0, 0, 20]],

    ['DEVICE_CLASS_ATTRIBUTES', [device_class, external_vsn_list, mass_storage_allocation_size,
          mass_storage_bytes_allocated, mass_storage_class, mass_storage_initial_volume,
          mass_storage_transfer_size, recorded_vsn_list, removable_media_group, shared_queue, size,
          tape_density, volume_overflow_allowed], [7, 0, 13]],

    ['JOB_ENVIRONMENT_ATTRIBUTES', [actual_job_access, attached, attached_external_vsn_list,
          attached_recorded_vsn_list, attached_transfer_size, attached_vol_overflow_allowed,
          attached_volume_number, connected_files, error_exit_procedure_name, error_limit, job_file_address,
          job_file_position, job_instances_of_open, job_write_concurrency, mass_storage_free_behind,
          mass_storage_sequential_access, message_control, open_position, private_read], [0, 0, 19]],

    ['KEYED_FILE_ATTRIBUTES', [average_record_length, collate_table_name, compression_procedure_name,
          data_padding, dynamic_home_block_space, embedded_key, estimated_record_count,
          hashing_procedure_name, index_levels, index_padding, initial_home_block_count, key_length,
          key_position, key_type, loading_factor, lock_expiration_time, log_residence, logging_options,
          record_limit, records_per_block], [0, 0, 20]],

    ['PRESENTATION_FILE_ATTRIBUTES', [line_number, page_format, page_length, page_width, statement_identifier,
          vertical_print_density], [0, 0, 6]]];

  VAR

{ Each entry in this table represents a letter of the alphabet.  Assuming that the third character is unique
{ among each of the category keyword names, the entry that represents the third character of a category name,
{ contains the corresponding category's index in the table of category choices.

    category_hash_table: [STATIC, READ, oss$job_paged_literal] array [1 .. 26] of
          0 .. attribute_category_max := [
          {A} 0,
          {B} 5, {JOB_ENVIRONMENT_ATTRIBUTES}
          {C} 0,
          {D} 0,
          {E} 7, {PRESENTATION_FILE_ATTRIBUTES}
          {F} 0,
          {G} 0,
          {H} 0,
          {I} 0,
          {J} 0,
          {K} 0,
          {L} 1, {ALL}
          {M} 3, {COMMON_FILE_ATTRIBUTES}
          {N} 0,
          {O} 0,
          {P} 0,
          {Q} 0,
          {R} 0,
          {S} 0,
          {T} 2, {CATALOG_REGISTRATION_ATTRIBUTES}
          {U} 0,
          {V} 4, {DEVICE_CLASS_ATTRIBUTES}
          {W} 0,
          {X} 0,
          {Y} 6, {KEYED_FILE_ATTRIBUTES}
          {Z} 0];

  VAR

{ This table contains the indices into the table of attribute_choices, of the first attribute in the group of
{ attributes beginning with the same character.

    attribute_hash_table: [STATIC, READ, oss$job_paged_literal] array [1 .. 22] of 0 .. attribute_key_max := [
          {A} 1,
          {B} 15,
          {C} 16,
          {D} 24,
          {E} 27,
          {F} 34,
          {G} 0,
          {H} 42,
          {I} 43,
          {J} 47,
          {K} 51,
          {L} 54,
          {M} 64,
          {N} 0,
          {O} 78,
          {P} 80,
          {Q} 0,
          {R} 89,
          {S} 98,
          {T} 106,
          {U} 107,
          {V} 110];

  VAR
    catalog_attributes: [READ, oss$job_paged_literal] array [1 .. catalog_attribute_max] of
          file_attribute_key := [path, object_type, access_control_list, account_project, creation_date_time,
          device_class, exception_conditions, lifetime, mass_storage_allocation_size,
          mass_storage_bytes_allocated, mass_storage_class, permitted_access, recorded_vsn_list, registered,
          set_name, size, unique_data_name, unique_name, volume_overflow_allowed],

    file_attributes: [READ, oss$job_paged_literal] array [1 .. file_attribute_max] of file_attribute_key :=
          [path, object_type, access_control_list, account_project, attachment_log,
          attachment_logging_selected, lifetime, permitted_access, registered, set_name, unique_name],

    cycle_attributes: [READ, oss$job_paged_literal] array [1 .. cycle_attribute_max] of
          file_attribute_key := [actual_job_access, archive_media_information, attached,
          attached_external_vsn_list, attached_recorded_vsn_list, attached_transfer_size,
          attached_vol_overflow_allowed, attached_volume_number, attachment_status, average_record_length,
          block_type, character_conversion, collate_table_name, complete_path, compression_procedure_name,
          connected_files, creation_date_time, cycle_number, cycle_path, data_padding, device_class,
          dynamic_home_block_space, embedded_key, error_exit_procedure_name, error_limit,
          estimated_record_count, exception_conditions, expiration_date, external_vsn_list,
          file_access_procedure_name, file_contents, file_label_type, file_limit, file_organization,
          file_previously_opened, file_processor, forced_write, hashing_procedure_name, index_levels,
          index_padding, initial_home_block_count, internal_code, job_file_address, job_file_position,
          job_instances_of_open, job_write_concurrency, key_length, key_position, key_type,
          last_access_date_time, last_data_modification_time, last_modification_date_time, lifetime,
          lifetime_attachment_count, line_number, loading_factor, lock_expiration_time, log_residence,
          logging_options, mainframe_attachment, mainframe_write_concurrency, mass_storage_allocation_size,
          mass_storage_bytes_allocated, mass_storage_class, mass_storage_free_behind,
          mass_storage_initial_volume, mass_storage_sequential_access, mass_storage_transfer_size,
          maximum_block_length, maximum_record_length, message_control, minimum_block_length,
          minimum_record_length, object_type, open_position, padding_character, page_format, page_length,
          page_width, path, potential_job_access, preset_value, private_read, record_delimiting_character,
          record_limit, record_type, recorded_vsn_list, records_per_block, registered, removable_media_group,
          retrieve_option, ring_attributes, secondary_residence, set_name, shared_queue, site_archive_option,
          site_backup_option, site_release_option, size, statement_identifier, tape_density, unique_data_name,
          unique_name, user_information, vertical_print_density, volume_overflow_allowed];

{ Damage Symptoms

  CONST
    parent_catalog_restored = 1,
    respf_modification_mismatch = 2,

{   cycle_restored = 3,
{   media_image_inconsistent = 4,

    max_damage_symptoms = 2;

  CONST
    access_condition_string = 'ACCESS_CONDITION',
    damage_symptom_string = 'DAMAGE_SYMPTOM';

  VAR
    damage_symptoms_table: [STATIC, READ, oss$job_paged_literal] array [1 .. max_damage_symptoms] of record
      damage_symptom: fst$cycle_damage_symptom,
      name: ost$name,
      status_condition: ost$name,
    recend := [[fsc$parent_catalog_restored, 'OSC$PARENT_CATALOG_RESTORED    ',
          'PFE$PARENT_CATALOG_RESTORED    '], [fsc$respf_modification_mismatch,
          'OSC$RESPF_MODIFICATION_MISMATCH', 'PFE$RESPF_MODIFICATION_MISMATCH']];

  TYPE
    t$path_type = (c$file_path, c$cycle_path, c$complete_path);

?? TITLE := 'determine_attributes_requested', EJECT ??

  PROCEDURE determine_attributes_requested
    (    option_value: ^clt$data_value;
     VAR attributes_requested: file_attribute_keys;
     VAR number_of_requested_attributes: object_type_counts;
     VAR all_requested: boolean;
     VAR source_requested: boolean);

    CONST
      all_index = 1,
      attribute_hash_index = 1,
      category_hash_index = 3; {unique character position}

    VAR
      attribute_index: ost$non_negative_integers,
      category_attributes: file_attribute_keys,
      current_option: ^clt$data_value,
      highest_attribute_index: ost$non_negative_integers,
      individual_attributes: file_attribute_keys,
      non_redundant_attributes: file_attribute_keys;

?? NEWTITLE := 'process_all_or_source_request', EJECT ??

    PROCEDURE [INLINE] process_all_or_source_request
      (    source_specified: boolean);

      attributes_requested := -$file_attribute_keys [];
      number_of_requested_attributes.catalog_type := catalog_attribute_max;
      number_of_requested_attributes.file_type := file_attribute_max;
      number_of_requested_attributes.cycle_type := cycle_attribute_max;
      all_requested := TRUE;
      source_requested := source_requested OR source_specified;

    PROCEND process_all_or_source_request;
?? OLDTITLE, EJECT ??
    all_requested := FALSE;
    source_requested := FALSE;

    IF (option_value^.element_value^.keyword_value = 'SOURCE') AND (option_value^.link = NIL) THEN
      process_all_or_source_request (TRUE {SOURCE} );
    ELSE
      number_of_requested_attributes.catalog_type := 0;
      number_of_requested_attributes.file_type := 0;
      number_of_requested_attributes.cycle_type := 0;
      category_attributes := $file_attribute_keys [];
      individual_attributes := $file_attribute_keys [];
      highest_attribute_index := 1;
      current_option := option_value;

      WHILE current_option <> NIL DO

{ First determine if the given keyword is a category name.  The following hashing algorithm assumes that the
{ third character of each category keyword name is unique.  If the given keyword is not a category name, then
{ the table of all the attribute names is searched.  Initially, the hashing is done on the first character of
{ the attribute and a linear search is performed on the rest of the attributes beginning with that same
{ character.

        attribute_index := category_hash_table [$INTEGER (current_option^.element_value^.
              keyword_value (category_hash_index)) - $INTEGER ('A') + 1];
        IF (attribute_index > 0) AND (current_option^.element_value^.keyword_value =
              category_choices [attribute_index].name) THEN
          IF attribute_index = all_index THEN
            process_all_or_source_request (FALSE {<> ALL} );
            RETURN; {----->
          IFEND;
          category_attributes := category_attributes + category_choices [attribute_index].
                associated_attributes;
          number_of_requested_attributes.catalog_type := number_of_requested_attributes.catalog_type +
                category_choices [attribute_index].attribute_sums.catalog_type;
          number_of_requested_attributes.file_type := number_of_requested_attributes.file_type +
                category_choices [attribute_index].attribute_sums.file_type;
          number_of_requested_attributes.cycle_type := number_of_requested_attributes.cycle_type +
                category_choices [attribute_index].attribute_sums.cycle_type;
        ELSE { not a category }
          attribute_index := attribute_hash_table [($INTEGER (current_option^.element_value^.
                keyword_value (attribute_hash_index))) - $INTEGER ('A') + 1];

        /search_attribute_table/
          BEGIN
            WHILE current_option^.element_value^.keyword_value <> attribute_choices [attribute_index].name DO
              attribute_index := attribute_index + 1;
              IF current_option^.element_value^.keyword_value (1) <> attribute_choices [attribute_index].
                    name (1) THEN
                EXIT /search_attribute_table/; {----->
              IFEND;
            WHILEND;

            IF NOT (attribute_index IN category_attributes) THEN
              individual_attributes := individual_attributes + $file_attribute_keys [attribute_index];
              IF attribute_index > highest_attribute_index THEN
                highest_attribute_index := attribute_index;
              IFEND;
            IFEND;
          END /search_attribute_table/;
        IFEND;

        current_option := current_option^.link;
      WHILEND;

      non_redundant_attributes := individual_attributes - category_attributes;
      IF non_redundant_attributes <> $file_attribute_keys [] THEN
        FOR attribute_index := 1 TO highest_attribute_index DO
          IF attribute_index IN non_redundant_attributes THEN
            number_of_requested_attributes.catalog_type := number_of_requested_attributes.
                  catalog_type + $INTEGER (catalog_object_type IN
                  attribute_choices [attribute_index].applicable_object_types);
            number_of_requested_attributes.cycle_type := number_of_requested_attributes.cycle_type +
                  $INTEGER (cycle_object_type IN attribute_choices [attribute_index].applicable_object_types);
            number_of_requested_attributes.file_type := number_of_requested_attributes.file_type +
                  $INTEGER (file_object_type IN attribute_choices [attribute_index].applicable_object_types);
          IFEND;
        FOREND;
      IFEND;
      attributes_requested := category_attributes + non_redundant_attributes;
    IFEND;

  PROCEND determine_attributes_requested;

?? TITLE := 'determine_object_info_requests', EJECT ??

  PROCEDURE determine_object_info_requests
    (    attributes_requested: file_attribute_keys;
     VAR info_request: {input, output} fst$goi_object_info_requests);

    IF (catalog_and_cycle_identity * attributes_requested) <> $file_attribute_keys [] THEN
      info_request := info_request + $fst$goi_object_info_requests
            [fsc$goi_catalog_identity, fsc$goi_cycle_identity];
    IFEND;
    IF (cycle_info * attributes_requested) <> $file_attribute_keys [] THEN
      info_request := info_request + $fst$goi_object_info_requests [fsc$goi_cycle_info];
    IFEND;
    IF (device_info * attributes_requested) <> $file_attribute_keys [] THEN
      info_request := info_request + $fst$goi_object_info_requests [fsc$goi_cycle_device_info];
      IF (catalog_device_attributes * attributes_requested) <> $file_attribute_keys [] THEN
        info_request := info_request + $fst$goi_object_info_requests [fsc$goi_catalog_device_info];
      IFEND;
    IFEND;
    IF (file_label_attributes * attributes_requested) <> $file_attribute_keys [] THEN
      info_request := info_request + $fst$goi_object_info_requests [fsc$goi_file_label];
    IFEND;
    IF (job_environment_info * attributes_requested) <> $file_attribute_keys [] THEN
      info_request := info_request + $fst$goi_object_info_requests [fsc$goi_job_environment_info];
      IF potential_job_access IN attributes_requested THEN
        info_request := info_request + $fst$goi_object_info_requests
              [fsc$goi_applicable_file_permit, fsc$goi_file_label];
      IFEND;
    IFEND;

    IF access_control_list IN attributes_requested THEN
      info_request := info_request + $fst$goi_object_info_requests
            [fsc$goi_catalog_permits, fsc$goi_file_permits];
    IFEND;
    IF account_project IN attributes_requested THEN
      info_request := info_request + $fst$goi_object_info_requests [fsc$goi_catalog_info, fsc$goi_file_info];
    IFEND;
    IF (archive_media_information IN attributes_requested) THEN
      info_request := info_request + $fst$goi_object_info_requests [fsc$goi_archive_info];
    IFEND;
    IF attachment_log IN attributes_requested THEN
      info_request := info_request + $fst$goi_object_info_requests [fsc$goi_file_log];
    IFEND;
    IF attachment_logging_selected IN attributes_requested THEN
      info_request := info_request + $fst$goi_object_info_requests [fsc$goi_file_info];
    IFEND;
    IF creation_date_time IN attributes_requested THEN
      info_request := info_request + $fst$goi_object_info_requests [fsc$goi_catalog_info, fsc$goi_cycle_info];
    IFEND;
    IF cycle_number IN attributes_requested THEN
      info_request := info_request + $fst$goi_object_info_requests [fsc$goi_cycle_identity];
    IFEND;
    IF permitted_access IN attributes_requested THEN
      info_request := info_request + $fst$goi_object_info_requests
            [fsc$goi_applicable_cat_permit, fsc$goi_applicable_file_permit];
    IFEND;
    IF (secondary_residence IN attributes_requested) THEN
      info_request := info_request + $fst$goi_object_info_requests [fsc$goi_archive_info];
    IFEND;
    IF set_name IN attributes_requested THEN
      info_request := info_request + $fst$goi_object_info_requests [fsc$goi_set_name];
    IFEND;
    IF size IN attributes_requested THEN
      info_request := info_request + $fst$goi_object_info_requests [fsc$goi_catalog_size, fsc$goi_cycle_size];
    IFEND;

  PROCEND determine_object_info_requests;

?? TITLE := 'get_$file_attribute_key', EJECT ??

  PROCEDURE get_$file_attribute_key
    (    name: ost$name;
     VAR key: amt$file_attribute_keys);

    VAR
      temp: integer,
      current_index: 1 .. old_$file_attb_max,
      low_index: 1 .. old_$file_attb_max + 1,
      high_index: 0 .. old_$file_attb_max;

    low_index := 1;
    high_index := old_$file_attb_max;

    REPEAT
      temp := low_index + high_index;
      current_index := temp DIV 2;
      IF name = attb_table_for_$file [current_index].name THEN
        key := attb_table_for_$file [current_index].key;
        RETURN; {----->
      ELSEIF name > attb_table_for_$file [current_index].name THEN
        low_index := current_index + 1;
      ELSE
        high_index := current_index - 1;
      IFEND;
    UNTIL low_index > high_index;

    key := amc$null_attribute;

  PROCEND get_$file_attribute_key;

?? TITLE := 'get_connected_file_attributes', EJECT ??

  PROCEDURE get_connected_file_attributes
    (    object_information: ^fst$goi_object_information;
         validation_criteria: ^fst$goi_validation_criteria;
     VAR work_area_p: ^SEQ ( * );
     VAR file_label_p: ^SEQ ( * );
     VAR target_device_class: rmt$device_class;
     VAR status: ost$status);

    VAR
      connected_file: fst$path,
      local_evaluated_file_ref: fst$evaluated_file_reference,
      object_info_sequence_p: ^SEQ ( * ),
      path_handle_name: fst$path_handle_name,
      target_handle_name: fst$path_handle_name,
      target_object_information: ^fst$goi_object_information;

    connected_file := object_information^.resolved_path^;
    clp$convert_str_to_path_handle (connected_file, {deleted_allowed} TRUE, {resolved_path} FALSE,
          {include_open_pos_in_handle} FALSE, path_handle_name, local_evaluated_file_ref, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    clp$get_ultimate_connection (path_handle_name, target_handle_name, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF path_handle_name <> target_handle_name THEN {target file found}
      clp$get_fs_path_elements (target_handle_name, local_evaluated_file_ref, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;

      object_info_sequence_p := work_area_p;
      get_object_information (local_evaluated_file_ref, file_label_info_request, validation_criteria,
            work_area_p, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;

      NEXT target_object_information IN object_info_sequence_p;
      IF target_object_information = NIL THEN
        osp$set_status_abnormal (amc$access_method_id, fse$system_error, nil_object_info_text, status);
        RETURN; {----->
      IFEND;

      IF target_object_information^.object^.object_type = fsc$goi_file_object THEN
        IF target_object_information^.object^.cycle_object_list = NIL THEN
          file_label_p := NIL;
        ELSE
          file_label_p := target_object_information^.object^.cycle_object_list^ [1].file_label;
          target_device_class := target_object_information^.object^.cycle_object_list^ [1].cycle_device_class;
        IFEND;
      ELSE
        file_label_p := target_object_information^.object^.file_label;
        target_device_class := target_object_information^.object^.cycle_device_class;
      IFEND;

    IFEND; {path_handle_name <> target_handle_name}

  PROCEND get_connected_file_attributes;

?? TITLE := 'get_object_information', EJECT ??

  PROCEDURE [INLINE] get_object_information
    (    evaluated_file_reference: fst$evaluated_file_reference;
         information_request: fst$goi_information_request;
         validation_criteria_p: ^fst$goi_validation_criteria;
     VAR object_info_sequence_p: ^SEQ ( * );
     VAR status: ost$status);

    VAR
      context: ^ost$ecp_exception_context,
      local_evaluated_file_reference: fst$evaluated_file_reference,
      local_sequence_p: ^SEQ ( * ),
      process_pt_results: bat$process_pt_results;

    context := NIL;
    local_evaluated_file_reference := evaluated_file_reference;

    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,
            local_evaluated_file_reference, process_pt_results, status);
    IFEND;

    REPEAT
      local_sequence_p := object_info_sequence_p;
      pfp$r3_get_object_information (local_evaluated_file_reference, information_request,
            validation_criteria_p, local_sequence_p, status);
      IF NOT status.normal THEN
        IF context = NIL THEN
          PUSH context;
          context^ := osv$initial_exception_context;
          context^.file.selector := osc$ecp_evaluated_file_ref;
          context^.file.evaluated_file_reference := local_evaluated_file_reference;
          IF validation_criteria_p <> NIL THEN
            context^.password := validation_criteria_p^ [1].password;
          IFEND;
        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);
    object_info_sequence_p := local_sequence_p;

  PROCEND get_object_information;

?? TITLE := 'process_object_information', EJECT ??

  PROCEDURE process_object_information
    (    evaluated_file_reference: fst$evaluated_file_reference;
         caller_ring: ost$valid_ring;
         validation_criteria: ^fst$goi_validation_criteria;
         all_requested: boolean;
         source_requested: boolean;
         requested_attribute_counts: object_type_counts;
         attributes_requested: file_attribute_keys;
     VAR object_info_sequence_p: ^SEQ ( * );
     VAR work_area: ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);

?? NEWTITLE := 'add_lifetime', EJECT ??

    PROCEDURE add_lifetime;

      VAR
        parsed_file_reference: fst$parsed_file_reference;

      IF evaluated_file_reference.path_structure_size <> 0 THEN
        IF fsp$path_element (^evaluated_file_reference, 1) ^ = fsc$local THEN
          IF (object_information_p <> NIL) AND (object_information_p^.resolved_path <> NIL) THEN
            clp$convert_string_to_file_ref (object_information_p^.resolved_path^, parsed_file_reference,
                  status);
            IF (parsed_file_reference.file_path_size <= fsc$local_size + 1) OR
                  (parsed_file_reference.path (1, fsc$local_size + 1) <> ':$LOCAL') THEN
              clp$make_keyword_value ('UNLIMITED', work_area, field_values^ [current_field_number].value);
            ELSE
              clp$make_keyword_value ('JOB', work_area, field_values^ [current_field_number].value);
            IFEND;
          ELSE
            clp$make_keyword_value ('JOB', work_area, field_values^ [current_field_number].value);
          IFEND;
        ELSE
          clp$make_keyword_value ('UNLIMITED', work_area, field_values^ [current_field_number].value);
        IFEND;
      ELSE
        clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
      IFEND;

    PROCEND add_lifetime;

?? TITLE := 'add_path', EJECT ??

    PROCEDURE add_path
      (    path_type: t$path_type);

      VAR
        parsed_file_reference: fst$parsed_file_reference;

      IF (object_information_p <> NIL) AND (object_information_p^.resolved_path <> NIL) THEN
        clp$convert_string_to_file_ref (object_information_p^.resolved_path^, parsed_file_reference, status);
        CASE path_type OF
        = c$file_path =
          clp$make_file_value (parsed_file_reference.path (1, parsed_file_reference.file_path_size),
                work_area, field_values^ [current_field_number].value);
        = c$cycle_path =
          clp$make_file_value (parsed_file_reference.path (1, parsed_file_reference.cycle_path_size),
                work_area, field_values^ [current_field_number].value);
        = c$complete_path =
          clp$make_file_value (parsed_file_reference.path (1, parsed_file_reference.complete_path_size),
                work_area, field_values^ [current_field_number].value);
        CASEND;

      ELSEIF evaluated_file_reference.path_structure_size <> 0 THEN
        convert_file_ref_to_string (evaluated_file_reference, path_type, str, path_size);
        clp$make_file_value (str (1, path_size), work_area, field_values^ [current_field_number].value);

      ELSE
        clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
      IFEND;

    PROCEND add_path;

?? TITLE := 'add_pft$path', EJECT ??

    PROCEDURE add_pft$path
      (    path: pft$path;
           cycle_number: fst$cycle_number;
       VAR value_p: ^clt$data_value);

      VAR
        i: integer,
        local_status: ost$status,
        name_size: ost$name_size,
        size: fst$path_size,
        str: ost$string,
        value: fst$path;

      size := 1;
      value (1) := ':';
      FOR i := 1 TO UPPERBOUND (path) DO
        name_size := clp$trimmed_string_size (path [i]);
        value (size + 1, name_size) := path [i];
        value (size + name_size + 1, 1) := '.';
        size := size + name_size + 1;
      FOREND;

      clp$convert_integer_to_string (cycle_number, 10 {radix} , FALSE {exclude radix} , str, local_status);
      value (size + 1, str.size) := str.value (1, str.size);
      size := size + str.size;

      IF (UPPERBOUND (path) >= LOWERBOUND (path)) AND (local_status.normal) AND
            (size <= fsc$max_path_size) THEN
        clp$make_file_value (value (1, size), work_area, value_p);
      ELSE
        clp$make_unspecified_value (work_area, value_p);
      IFEND;

    PROCEND add_pft$path;

?? TITLE := 'add_set_name', EJECT ??

    PROCEDURE add_set_name;

      IF (object_information_p <> NIL) AND (object_information_p^.set_name <> osc$null_name) THEN
        clp$make_name_value (object_information_p^.set_name, work_area,
              field_values^ [current_field_number].value);
      ELSE
        clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
      IFEND;

    PROCEND add_set_name;

?? TITLE := 'build_catalog_attrib_record', EJECT ??

    PROCEDURE build_catalog_attrib_record
      (VAR result: ^clt$data_value);

?? TITLE := 'add_exception_conditions', EJECT ??

      PROCEDURE add_exception_conditions;

        VAR
          access_condition_entry: fst$access_condition_entry,
          catalog_device_info: ^fst$mass_storage_device_info,
          criteria: ost$ecp_criteria,
          entry_found: boolean,
          ignore_status: ost$status,
          status_condition_name: ost$status_condition_name,
          wait_message: oft$display_message;

        IF (object_information_p <> NIL) AND (object_information_p^.object^.catalog_device_information <> NIL)
              THEN
          catalog_device_info := ^object_information_p^.object^.catalog_device_information^.
                mass_storage_device_info;
          field_values^ [current_field_number].value := NIL;
          node := ^field_values^ [current_field_number].value;
          IF (catalog_device_info^.object_condition IN -$fst$file_access_conditions
                [fsc$space_unavailable, fsc$null_file_access_condition]) THEN

            osp$find_access_condition_entry (catalog_device_info^.object_condition, access_condition_entry,
                  entry_found);

            IF entry_found THEN
              clp$make_list_value (work_area, node^);
              clp$make_record_value (4, work_area, node^^.element_value);
              node^^.element_value^.field_values^ [1].name := 'NAME';
              clp$make_name_value (access_condition_entry.user_defined_condition, work_area,
                    node^^.element_value^.field_values^ [1].value);
              node^^.element_value^.field_values^ [2].name := 'STATUS_CONDITION';
              osp$get_status_condition_name (access_condition_entry.status_condition, status_condition_name,
                    ignore_status);
              clp$make_name_value (status_condition_name, work_area,
                    node^^.element_value^.field_values^ [2].value);
              node^^.element_value^.field_values^ [3].name := 'TYPE';
              clp$make_keyword_value (access_condition_string, work_area,
                    node^^.element_value^.field_values^ [3].value);
              node^^.element_value^.field_values^ [4].name := 'WAIT_MESSAGE_TEXT';
              IF catalog_device_info^.resides_online THEN
                osp$format_wait_message (^access_condition_entry, object_information_p^.resolved_path,
                      catalog_device_info^.mass_storage_class, catalog_device_info^.volume_condition_list,
                      catalog_device_info^.volume_list, wait_message);
              ELSE
                osp$format_wait_message (^access_condition_entry, object_information_p^.resolved_path,
                      rmc$unspecified_file_class, {volume_condition_list} NIL, {volume_list} NIL,
                      wait_message);
              IFEND;
              clp$make_string_value (wait_message.text (1, wait_message.size), work_area,
                    node^^.element_value^.field_values^ [4].value);
              node := ^node^^.link;
            IFEND;
          ELSE
            clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
          IFEND;
        ELSE
          clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
        IFEND;

      PROCEND add_exception_conditions;

      VAR
        permit_array: array [1 .. 1] of pft$permit_array_entry,
        volume_index: ost$positive_integers;

      clp$make_list_value (work_area, result);
      clp$make_record_value (number_of_requested_attributes.catalog_type, work_area, result^.element_value);
      field_values := result^.element_value^.field_values;
      current_field_number := 1;

      FOR attribute := 1 TO catalog_attribute_max DO
        IF current_field_number > number_of_requested_attributes.catalog_type THEN
          RETURN; {----->
        IFEND;
        IF catalog_attributes [attribute] IN local_attributes_requested THEN
          field_values^ [current_field_number].name := attribute_choices [catalog_attributes [attribute]].
                name;
          CASE catalog_attributes [attribute] OF
          = access_control_list =
            IF (object_information_p <> NIL) AND (object_information_p^.object^.catalog_permits <> NIL) THEN
              get_permits (object_information_p^.object^.catalog_permits,
                    field_values^ [current_field_number].value);
            ELSE
              clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
            IFEND;

          = account_project =
            IF (object_information_p <> NIL) AND (object_information_p^.object^.catalog_information <> NIL)
                  THEN
              clp$make_record_value (2, work_area, field_values^ [current_field_number].value);
              field_values^ [current_field_number].value^.field_values^ [1].name := 'ACCOUNT';
              clp$make_name_value (object_information_p^.object^.catalog_information^.account, work_area,
                    field_values^ [current_field_number].value^.field_values^ [1].value);
              field_values^ [current_field_number].value^.field_values^ [2].name := 'PROJECT';
              clp$make_name_value (object_information_p^.object^.catalog_information^.project, work_area,
                    field_values^ [current_field_number].value^.field_values^ [2].value);
            ELSE
              clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
            IFEND;

          = creation_date_time =
            IF (object_information_p <> NIL) AND (object_information_p^.object^.catalog_information <> NIL)
                  THEN
              date_time.date_specified := TRUE;
              date_time.time_specified := TRUE;
              date_time.value := object_information_p^.object^.catalog_information^.creation_date_time;
              clp$make_date_time_value (date_time, work_area, field_values^ [current_field_number].value);
            ELSE
              clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
            IFEND;

          = device_class =
            IF object_information_p <> NIL THEN
              clp$make_keyword_value ('MASS_STORAGE', work_area, field_values^ [current_field_number].value);
            ELSE
              clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
            IFEND;

          = exception_conditions =
            add_exception_conditions;

          = lifetime =
            add_lifetime;

          = mass_storage_allocation_size =
            IF (object_information_p <> NIL) AND (object_information_p^.object^.catalog_device_information <>
                  NIL) THEN
              clp$make_integer_value (object_information_p^.object^.catalog_device_information^.
                    mass_storage_device_info.allocation_unit_size, 10, FALSE, work_area,
                    field_values^ [current_field_number].value);
            ELSE
              clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
            IFEND;

          = mass_storage_bytes_allocated =
            IF (object_information_p <> NIL) AND (object_information_p^.object^.catalog_device_information <>
                  NIL) THEN
              clp$make_integer_value (object_information_p^.object^.catalog_device_information^.
                    mass_storage_device_info.bytes_allocated, 10, FALSE, work_area,
                    field_values^ [current_field_number].value);
            ELSE
              clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
            IFEND;

          = mass_storage_class =
            IF (object_information_p <> NIL) AND (object_information_p^.object^.catalog_device_information <>
                  NIL) THEN
              character_string := object_information_p^.object^.catalog_device_information^.
                    mass_storage_device_info.mass_storage_class;
              clp$make_name_value (character_string, work_area, field_values^ [current_field_number].value);
            ELSE
              clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
            IFEND;

          = object_type =
            IF (object_information_p <> NIL) AND (object_information_p^.object <> NIL) THEN
              clp$make_keyword_value ('CATALOG', work_area, field_values^ [current_field_number].value);
            ELSE { system_default_values requested or object not registered }
              clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
            IFEND;

          = path =
            add_path (c$file_path);

          = permitted_access =
            IF (object_information_p <> NIL) AND (object_information_p^.object^.applicable_catalog_permit <>
                  NIL) THEN
              permit_array [1] := object_information_p^.object^.applicable_catalog_permit^;
              get_permits (^permit_array, field_values^ [current_field_number].value);
            ELSE
              clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
            IFEND;

          = recorded_vsn_list =
            IF (object_information_p <> NIL) AND (object_information_p^.object^.catalog_device_information <>
                  NIL) THEN
              node := ^field_values^ [current_field_number].value;
              FOR volume_index := 1 TO UPPERBOUND (object_information_p^.object^.catalog_device_information^.
                    mass_storage_device_info.volume_list^) DO
                clp$make_list_value (work_area, node^);
                clp$make_name_value (object_information_p^.object^.catalog_device_information^.
                      mass_storage_device_info.volume_list^ [volume_index].recorded_vsn, work_area,
                      node^^.element_value);
                node := ^node^^.link;
              FOREND;
            ELSE
              clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
            IFEND;

          = registered =
            IF object_information_p <> NIL THEN
              clp$make_boolean_value ((object_information_p^.object <> NIL), boolean_kind, work_area,
                    field_values^ [current_field_number].value);
            ELSE
              clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
            IFEND;

          = set_name =
            add_set_name;

          = size =
            IF (object_information_p <> NIL) AND (object_information_p^.object^.catalog_size <> NIL) THEN
              clp$make_integer_value (object_information_p^.object^.catalog_size^, 10, FALSE, work_area,
                    field_values^ [current_field_number].value);
            ELSE
              clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
            IFEND;

          = unique_data_name =
            IF object_information_p <> NIL THEN
              pmp$convert_binary_unique_name (object_information_p^.object^.catalog_global_file_name, gfn,
                    status);
              IF status.normal THEN
                clp$make_name_value (gfn, work_area, field_values^ [current_field_number].value);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
                status.normal := TRUE;
              IFEND;
            ELSE
              clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
            IFEND;

          = unique_name =
            IF object_information_p <> NIL THEN
              pmp$convert_binary_unique_name (object_information_p^.object^.catalog_global_file_name, gfn,
                    status);
              IF status.normal THEN
                clp$make_name_value (gfn, work_area, field_values^ [current_field_number].value);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
                status.normal := TRUE;
              IFEND;
            ELSE
              clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
            IFEND;

          = volume_overflow_allowed =
            IF object_information_p <> NIL THEN
              clp$make_boolean_value (FALSE, boolean_kind, work_area,
                    field_values^ [current_field_number].value);
            ELSE
              clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
            IFEND;

          ELSE
          CASEND;
          current_field_number := current_field_number + 1;
        IFEND;
      FOREND
    PROCEND build_catalog_attrib_record;

?? TITLE := 'build_cycle_attrib_record', EJECT ??

    PROCEDURE build_cycle_attrib_record
      (    cycle_object: ^fst$goi_object;
       VAR result: ^clt$data_value);

      CONST
        max_wait_message_length = 51, { osc$max_name_size + 20 }
        output_path_length = 14;

      VAR
        max_date_time: [STATIC, READ, oss$job_paged_literal] ost$date_time := [255, 12, 31, 23, 59, 59, 999],
        zero_date_time: [STATIC, READ, oss$job_paged_literal] ost$date_time := [0, 1, 1, 0, 0, 0, 0];

      VAR
        catalog_reference: clt$file_reference,
        combined_file_contents: amt$file_contents,
        conversion_status: ost$status,
        default_new_retention: fst$retention,
        default_new_retention_specified: boolean,
        determined_potential_access: pft$usage_selections,
        entry: ost$positive_integers,
        file_label_p: ^SEQ ( * ),
        fs_option: fst$file_access_option,
        logging_option: amt$logging_possibilities,
        message_control_value: amc$trivial_errors .. amc$statistics,
        mf_attachment: fst$mf_usage_concurrency_scope,
        now: ost$date_time,
        page_length_width: array [1 .. 2] of ift$terminal_attribute,
        parsed_file_reference: fst$parsed_file_reference,
        pf_option: pft$usage_options,
        previously_opened: boolean,
        required_share_modes: pft$share_selections,
        static_label_attributes: bat$static_label_attributes,
        target_device_class: rmt$device_class,
        time_increment: pmt$time_increment,
        volume_list: ^rmt$volume_list,
        wait_message: string (max_wait_message_length),
        wait_message_length: integer;

?? NEWTITLE := 'add_actual_job_access', EJECT ??

      PROCEDURE add_actual_job_access;

        IF (cycle_object <> NIL) AND (cycle_object^.job_environment_information <> NIL) THEN
          clp$make_record_value (2, work_area, field_values^ [current_field_number].value);

          field_values^ [current_field_number].value^.field_values^ [1].name := 'ACCESS_MODES';
          node := ^field_values^ [current_field_number].value^.field_values^ [1].value;
          IF cycle_object^.job_environment_information^.attached_access_modes = $fst$file_access_options
                [] THEN
            clp$make_keyword_value ('NONE', work_area, node^);
          ELSE
            FOR fs_option := LOWERVALUE (fst$file_access_option) TO UPPERVALUE (fst$file_access_option) DO
              IF fs_option IN cycle_object^.job_environment_information^.attached_access_modes THEN
                clp$make_list_value (work_area, node^);
                clp$make_keyword_value (access_share_modes [fs_option], work_area, node^^.element_value);
                node := ^node^^.link;
              IFEND;
            FOREND;
          IFEND;

          field_values^ [current_field_number].value^.field_values^ [2].name := 'SHARE_MODES';
          IF cycle_object^.job_environment_information^.attached_share_modes = $fst$file_access_options
                [] THEN
            clp$make_keyword_value ('NONE', work_area, field_values^ [current_field_number].value^.
                  field_values^ [2].value);
          ELSE
            node := ^field_values^ [current_field_number].value^.field_values^ [2].value;
            FOR fs_option := LOWERVALUE (fst$file_access_option) TO UPPERVALUE (fst$file_access_option) DO
              IF fs_option IN cycle_object^.job_environment_information^.attached_share_modes THEN
                clp$make_list_value (work_area, node^);
                clp$make_keyword_value (access_share_modes [fs_option], work_area, node^^.element_value);
                node := ^node^^.link;
              IFEND;
            FOREND;
          IFEND;
        ELSE
          clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
        IFEND;

      PROCEND add_actual_job_access;

?? TITLE := 'add_archive_media_information', EJECT ??

      PROCEDURE add_archive_media_information;

        CONST
          record_field_count = 10;

        VAR
          local_node_pp: ^^clt$data_value,
          local_status: ost$status;

?? NEWTITLE := 'add_archive_media_descriptor', EJECT ??

        PROCEDURE add_archive_media_descriptor
          (    amd_p: ^pft$amd;
           VAR node_p: ^clt$data_value);

{NOTE: The following definitions reflect are ARCHIVE_VE definitions!

          TYPE
            t#afmd_descriptor = record {art$afmd_descriptor
              legible_media_descriptors_r: REL (SEQ ( * )) ^t#legible_media_descriptors,
              media_container_r: REL (SEQ ( * )) ^SEQ ( * ),
              case kind: 0 .. 0ff(16) of {art$afmd_descriptor_kind
              = 0 = {arc$system_supplied_descriptor
                version: 0 .. 15, {art$system_descriptor_version
              = 1 = {arc$side_supplied_descriptor
              casend,
            recend,
            t#legible_media_descriptors = array [1 .. * ] of t#legible_media_descriptor,
            t#legible_media_descriptor = string (osc$max_name_size), {art$legible_media_descriptor
            t#system_media_container = record {
              kind: 0 .. 0ff(16), {art$media_container_kind
              media_container: SEQ ( * ), {art$media_container
            recend;

          VAR
            record_field_counts: [STATIC, READ, oss$job_paged_literal] array [boolean] of array [boolean] of
                  0 .. 5 := [
{ NOT SOURCE          } [{     Kind, Version, Legible_Media_Descriptor, Media_Container
{   SITE_DESCRIPTOR     } 1, {   x
{   SYSTEM_DESCRIPTOR   } 2], { x                                           x
{ SOURCE              } [
{   SITE_DESCRIPTOR     } 2, {   x                      x
{   SYSTEM_DESCRIPTOR   } 4]]; { x      x               x                    x

          VAR
            afmd_container_p: ^pft$amd,
            afmd_descriptor_p: ^t#afmd_descriptor,
            field_number: 0 .. 5,
            i: integer,
            legible_media_descriptors_p: ^t#legible_media_descriptors,
            local_node_pp: ^^clt$data_value,
            media_container_p: ^SEQ ( * ),
            sys_container_p: ^t#system_media_container,
            sys_container_size: integer;

?? NEWTITLE := 'add_css_container', EJECT ??

          PROCEDURE add_css_container
            (    tape_media_container_p: ^SEQ ( * );
             VAR node_p: ^clt$data_value);

{ff
            clp$make_unspecified_value (work_area, node_p);

          PROCEND add_css_container;
?? OLDTITLE ??
?? NEWTITLE := 'add_nos_container', EJECT ??

          PROCEDURE add_nos_container
            (    tape_media_container_p: ^SEQ ( * );
             VAR node_p: ^clt$data_value);

{ff
            clp$make_unspecified_value (work_area, node_p);

          PROCEND add_nos_container;
?? OLDTITLE ??
?? NEWTITLE := 'add_tape_container', EJECT ??

          PROCEDURE add_tape_container
            (    tape_media_container_p: ^SEQ ( * );
             VAR node_p: ^clt$data_value);

            TYPE
              t#system_tape_container = SEQ ( * ),
              t#system_tape_descriptor_v0 = record
                tape_media_status: t#tape_media_status,
                file_position: t#relative_file_position,
                original_path_name_r: REL (SEQ ( * )) ^pft$path,
                original_cycle_number: fst$cycle_number,
                number_of_tapes: t#number_of_media,
                case source: t#tape_descriptor_source of
                = c#system_tape_descriptor =
                  class: 0 .. 0ff(16), {art$tape_class
                  density: {0 .. 0ff(16),} rmt$density,
                  system_supplied_r: REL (SEQ ( * )) ^rmt$volume_list,
                = c#site_tape_descriptor =
                  site_supplied: integer,
                casend,
              recend,
              t#system_tape_descriptor_v3 = record
                version: t#tape_descriptor_version, {art$tape_descriptor_version
                v0: t#system_tape_descriptor_v0,
              recend,
              t#tape_descriptor_version = 0 .. 15, { art$tape_descriptor_version
              t#tape_media_status = set of t#tape_media_condition,
              t#tape_media_condition = (c#tape_media_condition_1, c#tape_media_condition_2,
                    c#tape_media_condition_3, c#tape_media_condition_4, c#tape_media_condition_5,
                    c#tape_media_condition_6, c#tape_media_condition_7, c#tape_media_condition_8),
              t#relative_file_position = 0 .. 0ffff(16),
              t#number_of_media = 0 .. 100,
              t#tape_descriptor_source = (c#system_tape_descriptor, c#site_tape_descriptor);

            VAR
              container_p: ^t#system_tape_container,
              field_number: 0 .. 255,
              local_node_pp: ^^clt$data_value,
              path_p: ^pft$path,
              tape_descriptor_p: ^t#system_tape_descriptor_v0,
              tape_list_p: ^rmt$volume_list,
              version: t#tape_descriptor_version,
              version_p: ^t#tape_descriptor_version;

?? NEWTITLE := 'add_tape_media_status', EJECT ??

            PROCEDURE add_tape_media_status
              (    tape_media_status: t#tape_media_status;
               VAR node_p: ^clt$data_value);

              VAR
                tape_media_condition: t#tape_media_condition,
                scl_list_pp: ^^clt$data_value;

              scl_list_pp := ^node_p;
              FOR tape_media_condition := LOWERVALUE (tape_media_condition)
                    TO UPPERVALUE (tape_media_condition) DO
                IF tape_media_condition IN tape_media_status THEN
                  clp$make_list_value (work_area, scl_list_pp^);
                  CASE tape_media_condition OF
                  = c#tape_media_condition_1 =
                    clp$make_keyword_value ('ERROR_FREE', work_area, scl_list_pp^^.element_value);
                  = c#tape_media_condition_2 =
                    clp$make_keyword_value ('PARITY_ERRORS', work_area, scl_list_pp^^.element_value);
                  ELSE
                    clp$make_integer_value ($INTEGER (tape_media_condition), 10, FALSE, work_area,
                          scl_list_pp^^.element_value);
                  CASEND;

                  scl_list_pp := ^scl_list_pp^^.link;
                IFEND;
              FOREND;

              IF scl_list_pp = ^node_p THEN
                clp$make_list_value (work_area, node_p);
              IFEND;

            PROCEND add_tape_media_status;
?? OLDTITLE ??
?? NEWTITLE := 'add_tape_vsn_list', EJECT ??

            PROCEDURE add_tape_vsn_list
              (    tape_list_p: ^rmt$volume_list;
               VAR node_p: ^clt$data_value);

              VAR
                i: integer,
                local_node_pp: ^^clt$data_value;

?? NEWTITLE := '[inline] add_tape_vsn_list_element', EJECT ??

              PROCEDURE [INLINE] add_tape_vsn_list_element
                (    vsn: string (6);
                 VAR node_p: ^clt$data_value);

                VAR
                  valid: boolean,
                  validated_name: ost$name;

                IF vsn = '' THEN
                  clp$make_unspecified_value (work_area, node_p);
                  RETURN; {----->
                IFEND;

                clp$validate_name (vsn, validated_name, valid);
                IF valid THEN
                  clp$make_name_value (vsn, work_area, node_p);
                ELSE
                  clp$make_string_value (vsn, work_area, node_p);
                IFEND;

              PROCEND add_tape_vsn_list_element;
?? OLDTITLE ??
?? EJECT ??
              IF tape_list_p = NIL THEN
                clp$make_unspecified_value (work_area, node_p);
                RETURN; {----->
              IFEND;

              local_node_pp := ^node_p;
              FOR i := LOWERBOUND (tape_list_p^) TO UPPERBOUND (tape_list_p^) DO
                clp$make_list_value (work_area, local_node_pp^);
                clp$make_record_value (2, work_area, local_node_pp^^.element_value);
{RECORDED_VSN
                local_node_pp^^.element_value^.field_values^ [1].name := 'RECORDED_VSN';
                add_tape_vsn_list_element (tape_list_p^ [i].recorded_vsn,
                      local_node_pp^^.element_value^.field_values^ [1].value);

{EXTERNAL_VSN
                local_node_pp^^.element_value^.field_values^ [2].name := 'EXTERNAL_VSN';
                add_tape_vsn_list_element (tape_list_p^ [i].external_vsn,
                      local_node_pp^^.element_value^.field_values^ [2].value);

                local_node_pp := ^local_node_pp^^.link;
              FOREND;

            PROCEND add_tape_vsn_list;
?? OLDTITLE ??
?? EJECT ??
            container_p := tape_media_container_p;
            NEXT version_p IN container_p;
            IF version_p = NIL THEN
              clp$make_unspecified_value (work_area, node_p);
              RETURN; {----->
            IFEND;

            IF version_p^ = 3 THEN
              version := 3;
              NEXT tape_descriptor_p IN container_p;
            ELSE
              version := 0;
              RESET container_p;
              NEXT tape_descriptor_p IN container_p;
            IFEND;

            IF tape_descriptor_p = NIL THEN
              clp$make_unspecified_value (work_area, node_p);
              RETURN; {----->
            IFEND;

            path_p := #PTR (tape_descriptor_p^.original_path_name_r, container_p^);
            tape_list_p := #PTR (tape_descriptor_p^.system_supplied_r, container_p^);

            clp$make_list_value (work_area, node_p);
            local_node_pp := ^node_p^.element_value;
            field_number := 1;

            IF source_requested THEN
              clp$make_record_value (8, work_area, local_node_pp^);
{Version
              local_node_pp^^.field_values^ [field_number].name := 'VERSION';
              clp$make_integer_value (version, 10, FALSE, work_area, local_node_pp^^.
                    field_values^ [field_number].value);
              field_number := field_number + 1;
            ELSE
              clp$make_record_value (7, work_area, local_node_pp^);
            IFEND;

{ Tape Media Status
            local_node_pp^^.field_values^ [field_number].name := 'TAPE_MEDIA_STATUS';
            add_tape_media_status (tape_descriptor_p^.tape_media_status, local_node_pp^^.
                  field_values^ [field_number].value);
            field_number := field_number + 1;

{ Relative File Position
            local_node_pp^^.field_values^ [field_number].name := 'RELATIVE_FILE_POSITION';
            clp$make_integer_value (tape_descriptor_p^.file_position, 10, FALSE, work_area,
                  local_node_pp^^.field_values^ [field_number].value);
            field_number := field_number + 1;

{ Original Path
            local_node_pp^^.field_values^ [field_number].name := 'ORIGINAL_PATH';
            IF path_p <> NIL THEN
              add_pft$path (path_p^, tape_descriptor_p^.original_cycle_number, local_node_pp^^.
                    field_values^ [field_number].value);
            ELSE
              clp$make_unspecified_value (work_area, local_node_pp^^.field_values^ [field_number].value);
            IFEND;
            field_number := field_number + 1;

{ Number of Tapes
            local_node_pp^^.field_values^ [field_number].name := 'NUMBER_OF_TAPES';
            clp$make_integer_value (tape_descriptor_p^.number_of_tapes, 10, FALSE, work_area,
                  local_node_pp^^.field_values^ [field_number].value);
            field_number := field_number + 1;

{ Tape Locator Source
            local_node_pp^^.field_values^ [field_number].name := 'TAPE_LOCATOR_SOURCE';
            clp$make_unspecified_value (work_area, local_node_pp^^.field_values^ [field_number].value);
            field_number := field_number + 1;

{ Tape Density
            local_node_pp^^.field_values^ [field_number].name := 'TAPE_DENSITY';
            clp$make_unspecified_value (work_area, local_node_pp^^.field_values^ [field_number].value);
            field_number := field_number + 1;

{ VSN_List
            local_node_pp^^.field_values^ [field_number].name := 'VSN_LIST';
            add_tape_vsn_list (tape_list_p, local_node_pp^^.field_values^ [field_number].value);
            field_number := field_number + 1;

          PROCEND add_tape_container;
?? OLDTITLE ??
?? EJECT ??
          IF amd_p = NIL THEN
            clp$make_unspecified_value (work_area, node_p);
            RETURN; {----->
          IFEND;

          afmd_container_p := amd_p;
          RESET afmd_container_p;
          NEXT afmd_descriptor_p IN afmd_container_p;
          IF afmd_descriptor_p = NIL THEN
            clp$make_unspecified_value (work_area, node_p);
            RETURN; {----->
          IFEND;

          field_number := record_field_counts [source_requested] [afmd_descriptor_p^.kind = 0];
          clp$make_record_value (field_number, work_area, node_p);
          field_number := 1;

{ Kind
          node_p^.field_values^ [field_number].name := 'KIND';
          CASE afmd_descriptor_p^.kind OF
          = 0 = {arc$system_supplied_descriptor
            clp$make_keyword_value ('SYSTEM_SUPPLIED_DESCRIPTOR', work_area, node_p^.
                  field_values^ [field_number].value);

          = 1 = {arc$side_supplied_descriptor
            clp$make_keyword_value ('SITE_SUPPLIED_DESCRIPTOR', work_area, node_p^.
                  field_values^ [field_number].value);
          ELSE
            clp$make_integer_value (afmd_descriptor_p^.kind, 10, FALSE, work_area, node_p^.
                  field_values^ [field_number].value);
          CASEND;
          field_number := field_number + 1;

{ Version
          IF source_requested AND (afmd_descriptor_p^.kind = 0) THEN
            node_p^.field_values^ [field_number].name := 'VERSION';
            clp$make_integer_value (afmd_descriptor_p^.version, 10, FALSE, work_area, node_p^.
                  field_values^ [field_number].value);
            field_number := field_number + 1;
          IFEND;

{ Legible Media Descriptor
          IF source_requested THEN
            legible_media_descriptors_p := #PTR (afmd_descriptor_p^.legible_media_descriptors_r,
                  afmd_container_p^);
            node_p^.field_values^ [field_number].name := 'LEGIBLE_MEDIA_DESCRIPTOR';

            IF (legible_media_descriptors_p = NIL)
{         } OR (LOWERBOUND (legible_media_descriptors_p^) > UPPERBOUND (legible_media_descriptors_p^)) THEN
              clp$make_unspecified_value (work_area, node_p^.field_values^ [field_number].value);
            ELSE
              local_node_pp := ^node_p^.field_values^ [field_number].value;
              FOR i := LOWERBOUND (legible_media_descriptors_p^)
                    TO UPPERBOUND (legible_media_descriptors_p^) DO
                clp$make_list_value (work_area, local_node_pp^);
                clp$make_string_value (legible_media_descriptors_p^
                      [i] (1, clp$trimmed_string_size (legible_media_descriptors_p^ [i])), work_area,
                      local_node_pp^^.element_value);

                local_node_pp := ^local_node_pp^^.link;
              FOREND;
            IFEND;
            field_number := field_number + 1;
          IFEND;

{ Media Container
          IF afmd_descriptor_p^.kind = 0 THEN
            node_p^.field_values^ [field_number].name := 'MEDIA_CONTAINER';

            media_container_p := #PTR (afmd_descriptor_p^.media_container_r, afmd_container_p^);
            sys_container_p := NIL;

            IF media_container_p <> NIL THEN
              sys_container_size := #SIZE (media_container_p^) - 1;
              NEXT sys_container_p: [[REP sys_container_size OF cell]] IN media_container_p;
            IFEND;

            IF sys_container_p = NIL THEN
              clp$make_unspecified_value (work_area, node_p^.field_values^ [field_number].value);
            ELSE
              CASE sys_container_p^.kind OF
              = 1 = { arc$tape_container
                add_tape_container (^sys_container_p^.media_container,
                      node_p^.field_values^ [field_number].value);

              = 2 = { arc$nos_container
                add_nos_container (^sys_container_p^.media_container,
                      node_p^.field_values^ [field_number].value);

              = 3 = { arc$css_container
                add_css_container (^sys_container_p^.media_container,
                      node_p^.field_values^ [field_number].value);

              ELSE
                clp$make_unspecified_value (work_area, node_p^.field_values^ [field_number].value);
              CASEND;
            IFEND;

            field_number := field_number + 1;
          IFEND;

        PROCEND add_archive_media_descriptor;
?? OLDTITLE ??
?? EJECT ??
        IF (cycle_object <> NIL) AND (cycle_object^.archive_information_list <> NIL) THEN
          node := ^field_values^ [current_field_number].value;
          date_time.date_specified := TRUE;
          date_time.time_specified := TRUE;
          FOR entry := 1 TO UPPERBOUND (cycle_object^.archive_information_list^) DO
            clp$make_list_value (work_area, node^);
            clp$make_record_value (record_field_count, work_area, node^^.element_value);

{1. Application_Identifier
            node^^.element_value^.field_values^ [1].name := 'APPLICATION_IDENTIFIER';
            clp$make_name_value (cycle_object^.archive_information_list^ [entry].archive_entry.
                  archive_identification.application_identifier, work_area,
                  node^^.element_value^.field_values^ [1].value);

{2. Device_Class
            node^^.element_value^.field_values^ [2].name := 'DEVICE_CLASS';
            clp$make_name_value (cycle_object^.archive_information_list^ [entry].archive_entry.
                  archive_identification.media_identifier.media_device_class, work_area,
                  node^^.element_value^.field_values^ [2].value);

{3. Duplication_Date_Time
            node^^.element_value^.field_values^ [3].name := 'DUPLICATION_DATE_TIME';
            date_time.value := cycle_object^.archive_information_list^ [entry].archive_entry.
                  archive_date_time;
            clp$make_date_time_value (date_time, work_area, node^^.element_value^.field_values^ [3].value);

{4. Last_Data_Modification_Time
            node^^.element_value^.field_values^ [4].name := 'LAST_DATA_MODIFICATION_TIME';
            date_time.value := cycle_object^.archive_information_list^ [entry].archive_entry.
                  modification_date_time;
            clp$make_date_time_value (date_time, work_area, node^^.element_value^.field_values^ [4].value);

{5. Last_Data_Retrieval_Date_Time
            node^^.element_value^.field_values^ [5].name := 'LAST_DATA_RETRIEVAL_DATE_TIME';
            IF cycle_object^.archive_information_list^ [entry].archive_entry.last_retrieval_status.
                  retrieval_date_time = zero_date_time THEN
              clp$make_keyword_value ('NONE', work_area, node^^.element_value^.field_values^ [5].value);
            ELSE
              date_time.value := cycle_object^.archive_information_list^ [entry].archive_entry.
                    last_retrieval_status.retrieval_date_time;
              clp$make_date_time_value (date_time, work_area, node^^.element_value^.field_values^ [5].value);
            IFEND;

{6. LAST_RETRIEVAL_STATUS
            node^^.element_value^.field_values^ [6].name := 'LAST_RETRIEVAL_STATUS';

            IF cycle_object^.archive_information_list^ [entry].archive_entry.last_retrieval_status.normal THEN
              local_status.normal := TRUE;
            ELSE
              osp$set_status_condition (cycle_object^.archive_information_list^ [entry].archive_entry.
                    last_retrieval_status.condition, local_status);
            IFEND;
            clp$make_status_value (local_status, work_area, node^^.element_value^.field_values^ [6].value);

{7. Release_Candidate  ...
            node^^.element_value^.field_values^ [7].name := 'RELEASE_CANDIDATE';
            local_node_pp := ^node^^.element_value^.field_values^ [7].value;
            IF cycle_object^.archive_information_list^ [entry].archive_entry.release_candidate.releasable THEN
              clp$make_record_value (2, work_area, local_node_pp^);
{   1. MARKED_AS_CANDIDATE
              local_node_pp^^.field_values^ [1].name := 'MARKED_AS_CANDIDATE';
              clp$make_boolean_value (cycle_object^.archive_information_list^ [entry].archive_entry.
                    release_candidate.releasable, boolean_kind, work_area,
                    local_node_pp^^.field_values^ [1].value);

{   2. MARK_DATE_TIME
              local_node_pp^^.field_values^ [2].name := 'MARK_DATE_TIME';
              date_time.value := cycle_object^.archive_information_list^ [entry].archive_entry.
                    release_candidate.mark_date_time;
              clp$make_date_time_value (date_time, work_area, local_node_pp^^.field_values^ [2].value);
            ELSE
              clp$make_record_value (1, work_area, local_node_pp^);
{   1. MARKED_AS_CANDIDATE
              local_node_pp^^.field_values^ [1].name := 'MARKED_AS_CANDIDATE';
              clp$make_boolean_value (cycle_object^.archive_information_list^ [entry].archive_entry.
                    release_candidate.releasable, boolean_kind, work_area,
                    local_node_pp^^.field_values^ [1].value);
            IFEND;

{8. Size
            node^^.element_value^.field_values^ [8].name := 'SIZE';
            clp$make_integer_value (cycle_object^.archive_information_list^ [entry].archive_entry.file_size,
                  10, FALSE, work_area, node^^.element_value^.field_values^ [8].value);

{9 . Volume Identifier
            node^^.element_value^.field_values^ [9].name := 'VOLUME_IDENTIFIER';
            clp$make_name_value (cycle_object^.archive_information_list^ [entry].archive_entry.
                  archive_identification.media_identifier.media_volume_identifier, work_area,
                  node^^.element_value^.field_values^ [9].value);

{10. Archive Media Descriptor
            node^^.element_value^.field_values^ [10].name := 'ARCHIVE_MEDIA_DESCRIPTOR';
            add_archive_media_descriptor (cycle_object^.archive_information_list^ [entry].amd,
                  node^^.element_value^.field_values^ [10].value);

            node := ^node^^.link;
          FOREND;
        ELSE
          clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
        IFEND;

      PROCEND add_archive_media_information;

?? TITLE := 'add_attachment_status', EJECT ??

      PROCEDURE add_attachment_status;

        VAR
          local_node_pp: ^^clt$data_value,
          attach_status_p: ^pft$attach_status;

        IF (cycle_object <> NIL) AND (cycle_object^.cycle_information <> NIL) THEN
          attach_status_p := ^cycle_object^.cycle_information^.attachment_status;
          node := ^field_values^ [current_field_number].value;
          clp$make_record_value (3, work_area, node^);

{1. Attachment_Count
          node^^.field_values^ [1].name := 'ATTACHMENT_COUNT';
          clp$make_integer_value (attach_status_p^.attach_count, 10, FALSE, work_area, node^^.
                field_values^ [1].value);

{2. Usage_Counts
          node^^.field_values^ [2].name := 'USAGE_COUNTS';
          local_node_pp := ^node^^.field_values^ [2].value;
          clp$make_record_value (5, work_area, local_node_pp^);

{   1. Read
          local_node_pp^^.field_values^ [1].name := 'READ';
          clp$make_integer_value (attach_status_p^.usage_counts [pfc$read], 10, FALSE, work_area,
                local_node_pp^^.field_values^ [1].value);
{   2. Shorten
          local_node_pp^^.field_values^ [2].name := 'SHORTEN';
          clp$make_integer_value (attach_status_p^.usage_counts [pfc$shorten], 10, FALSE, work_area,
                local_node_pp^^.field_values^ [2].value);
{   3. Append
          local_node_pp^^.field_values^ [3].name := 'APPEND';
          clp$make_integer_value (attach_status_p^.usage_counts [pfc$append], 10, FALSE, work_area,
                local_node_pp^^.field_values^ [3].value);
{   4. Modify
          local_node_pp^^.field_values^ [4].name := 'MODIFY';
          clp$make_integer_value (attach_status_p^.usage_counts [pfc$modify], 10, FALSE, work_area,
                local_node_pp^^.field_values^ [4].value);
{   5. Execute
          local_node_pp^^.field_values^ [5].name := 'EXECUTE';
          clp$make_integer_value (attach_status_p^.usage_counts [pfc$execute], 10, FALSE, work_area,
                local_node_pp^^.field_values^ [5].value);

{3. Prevent_Usage_Counts
          node^^.field_values^ [3].name := 'PREVENT_USAGE_COUNTS';
          local_node_pp := ^node^^.field_values^ [3].value;
          clp$make_record_value (5, work_area, local_node_pp^);

{   1. Read
          local_node_pp^^.field_values^ [1].name := 'READ';
          clp$make_integer_value (attach_status_p^.prevent_usage_counts [pfc$read], 10, FALSE, work_area,
                local_node_pp^^.field_values^ [1].value);
{   2. Shorten
          local_node_pp^^.field_values^ [2].name := 'SHORTEN';
          clp$make_integer_value (attach_status_p^.prevent_usage_counts [pfc$shorten], 10, FALSE, work_area,
                local_node_pp^^.field_values^ [2].value);
{   3. Append
          local_node_pp^^.field_values^ [3].name := 'APPEND';
          clp$make_integer_value (attach_status_p^.prevent_usage_counts [pfc$append], 10, FALSE, work_area,
                local_node_pp^^.field_values^ [3].value);
{   4. Modify
          local_node_pp^^.field_values^ [4].name := 'MODIFY';
          clp$make_integer_value (attach_status_p^.prevent_usage_counts [pfc$modify], 10, FALSE, work_area,
                local_node_pp^^.field_values^ [4].value);
{   5. Execute
          local_node_pp^^.field_values^ [5].name := 'EXECUTE';
          clp$make_integer_value (attach_status_p^.prevent_usage_counts [pfc$execute], 10, FALSE, work_area,
                local_node_pp^^.field_values^ [5].value);
        ELSE
          clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
        IFEND;

      PROCEND add_attachment_status;

?? TITLE := 'add_exception_conditions', EJECT ??

      PROCEDURE add_exception_conditions;

        VAR
          access_condition_entry: fst$access_condition_entry,
          criteria: ost$ecp_criteria,
          entry_found: boolean,
          ignore_status: ost$status,
          status_condition_name: ost$status_condition_name,
          wait_message: oft$display_message;

        IF cycle_object <> NIL THEN
          field_values^ [current_field_number].value := NIL;
          node := ^field_values^ [current_field_number].value;
          IF (cycle_object^.cycle_device_class = rmc$mass_storage_device) AND
                (cycle_object^.cycle_device_information <> NIL) AND
                (cycle_object^.cycle_device_information^.mass_storage_device_info.object_condition IN
                -$fst$file_access_conditions [fsc$null_file_access_condition, fsc$space_unavailable]) THEN

            osp$find_access_condition_entry (cycle_object^.cycle_device_information^.mass_storage_device_info.
                  object_condition, access_condition_entry, entry_found);

            IF entry_found THEN
              clp$make_list_value (work_area, node^);
              clp$make_record_value (4, work_area, node^^.element_value);
              node^^.element_value^.field_values^ [1].name := 'NAME';
              clp$make_name_value (access_condition_entry.user_defined_condition, work_area,
                    node^^.element_value^.field_values^ [1].value);
              node^^.element_value^.field_values^ [2].name := 'STATUS_CONDITION';
              osp$get_status_condition_name (access_condition_entry.status_condition, status_condition_name,
                    ignore_status);
              clp$make_name_value (status_condition_name, work_area,
                    node^^.element_value^.field_values^ [2].value);
              node^^.element_value^.field_values^ [3].name := 'TYPE';
              clp$make_keyword_value (access_condition_string, work_area,
                    node^^.element_value^.field_values^ [3].value);
              node^^.element_value^.field_values^ [4].name := 'WAIT_MESSAGE_TEXT';
              IF cycle_object^.cycle_device_information^.mass_storage_device_info.resides_online THEN
                osp$format_wait_message (^access_condition_entry, object_information_p^.resolved_path,
                      cycle_object^.cycle_device_information^.mass_storage_device_info.mass_storage_class,
                      cycle_object^.cycle_device_information^.mass_storage_device_info.volume_condition_list,
                      cycle_object^.cycle_device_information^.mass_storage_device_info.volume_list,
                      wait_message);
              ELSE
                osp$format_wait_message (^access_condition_entry, object_information_p^.resolved_path,
                      rmc$unspecified_file_class, {volume_condition_list} NIL, {volume_list} NIL,
                      wait_message);
              IFEND;
              clp$make_string_value (wait_message.text (1, wait_message.size), work_area,
                    node^^.element_value^.field_values^ [4].value);
              node := ^node^^.link;
            IFEND;
          IFEND;

          IF (cycle_object^.cycle_information <> NIL) AND (cycle_object^.cycle_information^.
                damage_symptoms <> $fst$cycle_damage_symptoms []) THEN
            FOR entry := 1 TO max_damage_symptoms DO
              IF damage_symptoms_table [entry].damage_symptom IN
                    cycle_object^.cycle_information^.damage_symptoms THEN
                clp$make_list_value (work_area, node^);
                clp$make_record_value (4, work_area, node^^.element_value);
                node^^.element_value^.field_values^ [1].name := 'NAME';
                clp$make_name_value (damage_symptoms_table [entry].name, work_area,
                      node^^.element_value^.field_values^ [1].value);
                node^^.element_value^.field_values^ [2].name := 'STATUS_CONDITION';
                clp$make_name_value (damage_symptoms_table [entry].status_condition, work_area,
                      node^^.element_value^.field_values^ [2].value);
                node^^.element_value^.field_values^ [3].name := 'TYPE';
                clp$make_keyword_value (damage_symptom_string, work_area,
                      node^^.element_value^.field_values^ [3].value);
                node^^.element_value^.field_values^ [4].name := 'WAIT_MESSAGE_TEXT';
                clp$make_unspecified_value (work_area, node^^.element_value^.field_values^ [4].value);
                node := ^node^^.link;
              IFEND;
            FOREND;
          ELSEIF field_values^ [current_field_number].value = NIL THEN
            clp$make_unspecified_value (work_area, node^);
          IFEND;
        ELSE
          clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
        IFEND;

      PROCEND add_exception_conditions;

?? TITLE := 'add_open_position', EJECT ??

      PROCEDURE add_open_position;

        IF cycle_object <> NIL THEN
          IF ((STRLENGTH (object_information_p^.resolved_path^) >= output_path_length) AND
                (object_information_p^.resolved_path^ (1, output_path_length) = ':$LOCAL.OUTPUT')) AND
                ((cycle_object^.job_environment_information = NIL) OR
                (cycle_object^.job_environment_information^.attachment_options_sources.open_position_source =
                amc$access_method_default)) THEN
            clp$make_keyword_value ('$EOI', work_area, field_values^ [current_field_number].value);
          ELSEIF cycle_object^.job_environment_information <> NIL THEN
            IF evaluated_file_reference.path_handle_info.path_handle.open_position.specified AND
                  (cycle_object^.job_environment_information^.attachment_options_sources.
                  open_position_source > amc$file_reference) THEN
              clp$make_keyword_value (clv$open_positions [evaluated_file_reference.path_handle_info.
                    path_handle.open_position.value], work_area, field_values^ [current_field_number].value);
            ELSE
              clp$make_keyword_value (clv$open_positions [cycle_object^.job_environment_information^.
                    open_position], work_area, field_values^ [current_field_number].value);
            IFEND
          ELSEIF evaluated_file_reference.path_handle_info.path_handle.open_position.specified THEN
            clp$make_keyword_value (clv$open_positions [evaluated_file_reference.path_handle_info.path_handle.
                  open_position.value], work_area, field_values^ [current_field_number].value);
          ELSE
            clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
          IFEND
        ELSEIF (evaluated_file_reference.path_structure_size <> 0) AND
              evaluated_file_reference.path_handle_info.path_handle.open_position.specified THEN
          clp$make_keyword_value (clv$open_positions [evaluated_file_reference.path_handle_info.path_handle.
                open_position.value], work_area, field_values^ [current_field_number].value);
        ELSE
          clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
        IFEND;

      PROCEND add_open_position;

?? TITLE := 'add_potential_job_access', EJECT ??

      PROCEDURE add_potential_job_access;

        IF object_information_p <> NIL THEN
          clp$make_record_value (2, work_area, field_values^ [current_field_number].value);

          field_values^ [current_field_number].value^.field_values^ [1].name := 'ACCESS_MODES';
          node := ^field_values^ [current_field_number].value^.field_values^ [1].value;

{ The following special casing will no longer be necessary when get_object_information is enhanced to
{ return the applicable_file_permit for an unregistered object, to the owner or a nonowner with CYCLE
{ permission.

          IF (cycle_object = NIL) OR (object_information_p^.object^.object_type <> fsc$goi_file_object) THEN
            determined_potential_access := fmv$system_file_attributes.descriptive_label.global_access_mode;
            required_share_modes := fmv$system_file_attributes.descriptive_label.global_share_mode;
          ELSE
            IF fsp$file_is_$job_log (object_information_p^.resolved_path) AND
                  (cycle_object^.job_environment_information^.prevented_open_access_modes =
                  $fst$file_access_options []) THEN
              determined_potential_access := $pft$usage_selections [pfc$read, pfc$append];
            ELSE
              fsp$determine_global_access (caller_ring, cycle_object^.job_environment_information,
                    object_information_p^.object, cycle_object, static_label_attributes.ring_attributes,
                    determined_potential_access);
            IFEND;
            IF (cycle_object^.job_environment_information <> NIL) AND
                  cycle_object^.job_environment_information^.cycle_attached THEN
              #UNCHECKED_CONVERSION (cycle_object^.job_environment_information^.attached_share_modes,
                    required_share_modes);
            ELSEIF object_information_p^.object^.applicable_file_permit <> NIL THEN
              IF cycle_object^.cycle_information <> NIL THEN
                required_share_modes := object_information_p^.object^.applicable_file_permit^.
                      share_requirements + cycle_object^.cycle_information^.outstanding_access_modes;
              ELSE
                required_share_modes := object_information_p^.object^.applicable_file_permit^.
                      share_requirements;
              IFEND;
            ELSE
              required_share_modes := fmv$system_file_attributes.descriptive_label.global_share_mode;
            IFEND;
          IFEND;

          IF determined_potential_access = $pft$usage_selections [] THEN
            clp$make_keyword_value ('NONE', work_area, node^);
          ELSE
            FOR pf_option := LOWERVALUE (pft$usage_options) TO UPPERVALUE (pft$usage_options) DO
              IF pf_option IN determined_potential_access THEN
                clp$make_list_value (work_area, node^);
                clp$make_keyword_value (permit_share_options [pf_option], work_area, node^^.element_value);
                node := ^node^^.link;
              IFEND;
            FOREND;
          IFEND;

          field_values^ [current_field_number].value^.field_values^ [2].name := 'SHARE_MODES';
          node := ^field_values^ [current_field_number].value^.field_values^ [2].value;
          IF required_share_modes = $pft$share_requirements [] THEN
            clp$make_keyword_value ('NONE', work_area, node^);
          ELSE
            FOR pf_option := LOWERVALUE (pft$share_options) TO UPPERVALUE (pft$share_options) DO
              IF pf_option IN required_share_modes THEN
                clp$make_list_value (work_area, node^);
                clp$make_keyword_value (permit_share_options [pf_option], work_area, node^^.element_value);
                node := ^node^^.link;
              IFEND;
            FOREND;
          IFEND;
        ELSE
          clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
        IFEND;

      PROCEND add_potential_job_access;

?? TITLE := 'add_recorded_vsn_list', EJECT ??

      PROCEDURE add_recorded_vsn_list;

        IF (cycle_object <> NIL) AND (cycle_object^.cycle_device_information <> NIL) THEN
          IF (cycle_object^.cycle_device_class = rmc$magnetic_tape_device) AND
                (cycle_object^.cycle_device_information^.magnetic_tape_device_info.volume_list <> NIL) THEN
            make_list_of_recorded_vsns (cycle_object^.cycle_device_information^.magnetic_tape_device_info.
                  volume_list);
          ELSEIF (cycle_object^.cycle_device_class = rmc$mass_storage_device) AND
                cycle_object^.cycle_device_information^.mass_storage_device_info.resides_online AND
                (cycle_object^.cycle_device_information^.mass_storage_device_info.volume_list <> NIL) THEN
            node := ^field_values^ [current_field_number].value;
            FOR entry := 1 TO UPPERBOUND (cycle_object^.cycle_device_information^.mass_storage_device_info.
                  volume_list^) DO
              clp$make_list_value (work_area, node^);
              clp$make_name_value (cycle_object^.cycle_device_information^.mass_storage_device_info.
                    volume_list^ [entry].recorded_vsn, work_area, node^^.element_value);
              node := ^node^^.link;
            FOREND;
          ELSE
            clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
          IFEND;
        ELSE
          clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
        IFEND;

      PROCEND add_recorded_vsn_list;

?? TITLE := 'add_retrieve_option', EJECT ??

      PROCEDURE add_retrieve_option;

        IF (cycle_object <> NIL) AND (cycle_object^.cycle_information <> NIL) THEN
          CASE cycle_object^.cycle_information^.retrieve_option OF
          = pfc$always_retrieve =
            clp$make_keyword_value ('ALWAYS_RETRIEVE', work_area, field_values^ [current_field_number].value);
          = pfc$explicit_retrieve_only =
            clp$make_keyword_value ('EXPLICIT_RETRIEVE_ONLY', work_area,
                  field_values^ [current_field_number].value);
          = pfc$admin_retrieve_only =
            clp$make_keyword_value ('ADMINISTRATIVE_RETRIEVE_ONLY', work_area,
                  field_values^ [current_field_number].value);
          ELSE
            clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
          CASEND;
        ELSE
          clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
        IFEND;

      PROCEND add_retrieve_option;

?? TITLE := 'add_secondary_residence', EJECT ??

      PROCEDURE add_secondary_residence;

        IF (cycle_object <> NIL) AND (cycle_object^.archive_information_list <> NIL) THEN
          node := ^field_values^ [current_field_number].value;
          date_time.date_specified := TRUE;
          date_time.time_specified := TRUE;
          FOR entry := 1 TO UPPERBOUND (cycle_object^.archive_information_list^) DO
            clp$make_list_value (work_area, node^);
            clp$make_record_value (6, work_area, node^^.element_value);
            node^^.element_value^.field_values^ [1].name := 'DEVICE_CLASS';
            clp$make_name_value (cycle_object^.archive_information_list^ [entry].archive_entry.
                  archive_identification.media_identifier.media_device_class, work_area,
                  node^^.element_value^.field_values^ [1].value);
            node^^.element_value^.field_values^ [2].name := 'DUPLICATION_DATE_TIME';
            date_time.value := cycle_object^.archive_information_list^ [entry].archive_entry.
                  archive_date_time;
            clp$make_date_time_value (date_time, work_area, node^^.element_value^.field_values^ [2].value);
            node^^.element_value^.field_values^ [3].name := 'LAST_DATA_MODIFICATION_TIME';
            date_time.value := cycle_object^.archive_information_list^ [entry].archive_entry.
                  modification_date_time;
            clp$make_date_time_value (date_time, work_area, node^^.element_value^.field_values^ [3].value);
            node^^.element_value^.field_values^ [4].name := 'LAST_DATA_RETRIEVAL_DATE_TIME';
            IF cycle_object^.archive_information_list^ [entry].archive_entry.last_retrieval_status.
                  retrieval_date_time = zero_date_time THEN
              clp$make_keyword_value ('NONE', work_area, node^^.element_value^.field_values^ [4].value);
            ELSE
              date_time.value := cycle_object^.archive_information_list^ [entry].archive_entry.
                    last_retrieval_status.retrieval_date_time;
              clp$make_date_time_value (date_time, work_area, node^^.element_value^.field_values^ [4].value);
            IFEND;
            node^^.element_value^.field_values^ [5].name := 'LAST_RETRIEVAL_STATUS_NORMAL';
            clp$make_boolean_value (cycle_object^.archive_information_list^ [entry].archive_entry.
                  last_retrieval_status.normal, boolean_kind, work_area, node^^.element_value^.
                  field_values^ [5].value);
            node^^.element_value^.field_values^ [6].name := 'SIZE';
            clp$make_integer_value (cycle_object^.archive_information_list^ [entry].archive_entry.file_size,
                  10, FALSE, work_area, node^^.element_value^.field_values^ [6].value);
            node := ^node^^.link;
          FOREND;
        ELSE
          clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
        IFEND;

      PROCEND add_secondary_residence;

?? TITLE := 'make_list_of_external_vsns', EJECT ??

      PROCEDURE make_list_of_external_vsns
        (    volume_list: ^rmt$volume_list);

        node := ^field_values^ [current_field_number].value;
        IF volume_list = NIL THEN
          clp$make_list_value (work_area, node^);
        ELSEIF volume_list^ [1].external_vsn = ' ' THEN
          clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
        ELSE
          FOR entry := 1 TO UPPERBOUND (volume_list^) DO
            clp$make_list_value (work_area, node^);
            clp$make_string_value (volume_list^ [entry].external_vsn, work_area, node^^.element_value);
            node := ^node^^.link;
          FOREND;
        IFEND;

      PROCEND make_list_of_external_vsns;

?? TITLE := 'make_list_of_recorded_vsns', EJECT ??

      PROCEDURE make_list_of_recorded_vsns
        (    volume_list: ^rmt$volume_list);

        node := ^field_values^ [current_field_number].value;
        IF volume_list = NIL THEN
          clp$make_list_value (work_area, node^);
        ELSEIF volume_list^ [1].recorded_vsn = ' ' THEN
          clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
        ELSE
          FOR entry := 1 TO UPPERBOUND (volume_list^) DO
            clp$make_list_value (work_area, node^);
            clp$make_string_value (volume_list^ [entry].recorded_vsn, work_area, node^^.element_value);
            node := ^node^^.link;
          FOREND;
        IFEND;

      PROCEND make_list_of_recorded_vsns;

?? OLDTITLE, EJECT ??

      clp$make_list_value (work_area, result);
      clp$make_record_value (number_of_requested_attributes.cycle_type, work_area, result^.element_value);
      field_values := result^.element_value^.field_values;

      IF object_information_p = NIL THEN { defaults requested }
        bap$get_default_file_attribs (static_label_attributes, default_new_retention_specified,
              default_new_retention, status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
      ELSEIF (cycle_object <> NIL) AND (((file_label_attributes * local_attributes_requested) <>
            $file_attribute_keys []) OR (potential_job_access IN local_attributes_requested)) THEN
        file_label_p := cycle_object^.file_label;

        IF cycle_object^.cycle_device_class = rmc$connected_file_device THEN
          target_device_class := cycle_object^.cycle_device_class;
          get_connected_file_attributes (object_information_p, validation_criteria, work_area, file_label_p,
                target_device_class, status);
          IF NOT status.normal THEN
            RETURN; {----->
          IFEND;
        IFEND;

        fsp$expand_file_label (file_label_p, static_label_attributes, previously_opened, status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;

        IF (NOT previously_opened) AND (cycle_object^.cycle_device_class = rmc$magnetic_tape_device) AND
              (($file_attribute_keys [file_label_type, maximum_block_length] * local_attributes_requested) <>
              $file_attribute_keys []) AND (cycle_object^.cycle_device_information <> NIL) THEN
          fsp$adjust_tape_defaults (cycle_object^.cycle_device_information^.magnetic_tape_device_info.density,
                static_label_attributes);
        IFEND;
      IFEND;

      IF (cycle_object <> NIL) AND ((cycle_object^.cycle_device_class = rmc$terminal_device) OR
            ((cycle_object^.cycle_device_class = rmc$connected_file_device) AND
            (target_device_class = rmc$terminal_device))) AND
            ((static_label_attributes.page_length_source = amc$access_method_default) OR
            (static_label_attributes.page_width_source = amc$access_method_default)) THEN
        ifp$get_page_length_width (evaluated_file_reference.path_handle_info.path_handle, page_length_width,
              status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
        IF static_label_attributes.page_length_source = amc$access_method_default THEN
          IF page_length_width [1].page_length = 0 THEN
            static_label_attributes.page_length := UPPERVALUE (amt$page_length);
          ELSE
            static_label_attributes.page_length := page_length_width [1].page_length;
          IFEND;
        IFEND;
        IF static_label_attributes.page_width_source = amc$access_method_default THEN
          IF page_length_width [2].page_width = 0 THEN
            static_label_attributes.page_width := amc$max_page_width;
          ELSE
            static_label_attributes.page_width := page_length_width [2].page_width;
          IFEND;
        IFEND;
      IFEND;

      current_field_number := 1;

      FOR attribute := 1 TO cycle_attribute_max DO
        IF current_field_number > number_of_requested_attributes.cycle_type THEN
          RETURN; {----->
        IFEND;

        IF cycle_attributes [attribute] IN local_attributes_requested THEN
          field_values^ [current_field_number].name := attribute_choices [cycle_attributes [attribute]].name;
          IF (object_information_p <> NIL) AND (cycle_object = NIL) AND
                NOT (cycle_attributes [attribute] IN $file_attribute_keys
                [complete_path, cycle_number, cycle_path, lifetime, open_position, path, potential_job_access,
                registered, set_name]) THEN
            { attribute is not applicable for an unregistered object }
            clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
          ELSE
            CASE cycle_attributes [attribute] OF
            = actual_job_access =
              add_actual_job_access;

            = archive_media_information =
              add_archive_media_information;

            = attached =
              IF cycle_object <> NIL THEN
                clp$make_boolean_value (((cycle_object^.job_environment_information <> NIL) AND
                      cycle_object^.job_environment_information^.cycle_attached), boolean_kind, work_area,
                      field_values^ [current_field_number].value);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = attached_external_vsn_list =
              IF (cycle_object <> NIL) AND (cycle_object^.cycle_device_class = rmc$magnetic_tape_device) AND
                    (cycle_object^.job_environment_information <> NIL) AND
                    (cycle_object^.job_environment_information^.cycle_attached) THEN
                make_list_of_external_vsns (cycle_object^.job_environment_information^.volume_list);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = attached_recorded_vsn_list =
              IF (cycle_object <> NIL) AND (cycle_object^.cycle_device_class = rmc$magnetic_tape_device) AND
                    (cycle_object^.job_environment_information <> NIL) AND
                    (cycle_object^.job_environment_information^.cycle_attached) THEN
                make_list_of_recorded_vsns (cycle_object^.job_environment_information^.volume_list);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = attached_transfer_size =
              IF (cycle_object <> NIL) AND (cycle_object^.cycle_device_class = rmc$mass_storage_device) AND
                    (cycle_object^.job_environment_information <> NIL) AND
                    (cycle_object^.job_environment_information^.cycle_attached) AND
                    (fsc$transfer_size_ao IN cycle_object^.job_environment_information^.
                    specified_attachment_options) THEN
                clp$make_integer_value (cycle_object^.job_environment_information^.transfer_size, 10, FALSE,
                      work_area, field_values^ [current_field_number].value);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = attached_vol_overflow_allowed =
              IF (cycle_object <> NIL) AND (cycle_object^.cycle_device_class = rmc$magnetic_tape_device) AND
                    (cycle_object^.job_environment_information <> NIL) AND
                    (cycle_object^.job_environment_information^.cycle_attached) THEN
                clp$make_boolean_value (cycle_object^.job_environment_information^.volume_overflow_allowed,
                      boolean_kind, work_area, field_values^ [current_field_number].value);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = attached_volume_number =
              IF (cycle_object <> NIL) AND (cycle_object^.cycle_device_class = rmc$magnetic_tape_device) AND
                    (cycle_object^.job_environment_information <> NIL) AND
                    (cycle_object^.job_environment_information^.cycle_attached) THEN
                clp$make_integer_value (cycle_object^.job_environment_information^.volume_number, 10, FALSE,
                      work_area, field_values^ [current_field_number].value);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = attachment_status =
              add_attachment_status;

            = average_record_length =
              IF static_label_attributes.average_record_length_source <> amc$undefined_attribute THEN
                clp$make_integer_value (static_label_attributes.average_record_length, 10, FALSE, work_area,
                      field_values^ [current_field_number].value);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = block_type =
              clp$make_keyword_value (block_types [static_label_attributes.block_type], work_area,
                    field_values^ [current_field_number].value);

            = character_conversion =
              clp$make_boolean_value (static_label_attributes.character_conversion, boolean_kind, work_area,
                    field_values^ [current_field_number].value);

            = collate_table_name =
              IF static_label_attributes.collate_table_name = osc$null_name THEN
                clp$make_keyword_value ('NONE', work_area, field_values^ [current_field_number].value);
              ELSE
                clp$make_entry_point_ref_value (static_label_attributes.collate_table_name, '', work_area,
                      field_values^ [current_field_number].value);
              IFEND;

            = complete_path =
              add_path (c$complete_path);

            = compression_procedure_name =
              IF static_label_attributes.compression_procedure_name.name = osc$null_name THEN
                clp$make_keyword_value ('NONE', work_area, field_values^ [current_field_number].value);
              ELSE
                clp$make_entry_point_ref_value (static_label_attributes.compression_procedure_name.name,
                      static_label_attributes.compression_procedure_name.object_library, work_area,
                      field_values^ [current_field_number].value);
              IFEND;

            = connected_files =
              IF (cycle_object <> NIL) AND (cycle_object^.cycle_device_class = rmc$connected_file_device) THEN
                node := ^field_values^ [current_field_number].value;
                IF (cycle_object^.job_environment_information <> NIL) AND
                      (cycle_object^.job_environment_information^.connected_files <> NIL) THEN
                  FOR entry := 1 TO UPPERBOUND (cycle_object^.job_environment_information^.connected_files^)
                        DO
                    clp$make_list_value (work_area, node^);
                    clp$make_file_value (cycle_object^.job_environment_information^.connected_files^ [entry]
                          (1, clp$trimmed_string_size (cycle_object^.job_environment_information^.
                          connected_files^ [entry])), work_area, node^^.element_value);
                    node := ^node^^.link;
                  FOREND;
                ELSE
                  clp$make_list_value (work_area, node^);
                IFEND;
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = creation_date_time =
              IF (cycle_object <> NIL) AND (cycle_object^.cycle_information <> NIL) THEN
                date_time.date_specified := TRUE;
                date_time.time_specified := TRUE;
                date_time.value := cycle_object^.cycle_information^.creation_date_time;
                clp$make_date_time_value (date_time, work_area, field_values^ [current_field_number].value);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = cycle_number =
              IF (cycle_object <> NIL) AND (cycle_object^.cycle_global_file_name <> null_unique_name) THEN
                clp$make_integer_value (cycle_object^.cycle_number, 10, FALSE, work_area,
                      field_values^ [current_field_number].value);
              ELSEIF (evaluated_file_reference.path_structure_size <> 0) AND
                    (evaluated_file_reference.cycle_reference.specification = fsc$cycle_number) THEN
                clp$make_integer_value (evaluated_file_reference.cycle_reference.cycle_number, 10, FALSE,
                      work_area, field_values^ [current_field_number].value);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = cycle_path =
              add_path (c$cycle_path);

            = data_padding =
              clp$make_integer_value (static_label_attributes.data_padding, 10, FALSE, work_area,
                    field_values^ [current_field_number].value);

            = device_class =
              IF cycle_object <> NIL THEN
                clp$make_keyword_value (class [cycle_object^.cycle_device_class],
                      work_area, field_values^ [current_field_number].value);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = dynamic_home_block_space =
              clp$make_boolean_value (static_label_attributes.dynamic_home_block_space, boolean_kind,
                    work_area, field_values^ [current_field_number].value);

            = embedded_key =
              clp$make_boolean_value (static_label_attributes.embedded_key, boolean_kind, work_area,
                    field_values^ [current_field_number].value);

            = error_exit_procedure_name =
              IF cycle_object <> NIL THEN
                IF (cycle_object^.job_environment_information = NIL) OR
                      (cycle_object^.job_environment_information^.error_exit_procedure_name = osc$null_name)
                      THEN
                  clp$make_keyword_value ('NONE', work_area, field_values^ [current_field_number].value);
                ELSE
                  clp$make_entry_point_ref_value (cycle_object^.job_environment_information^.
                        error_exit_procedure_name, '', work_area, field_values^ [current_field_number].value);
                IFEND;
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = error_limit =
              IF (cycle_object <> NIL) AND (cycle_object^.job_environment_information <> NIL) THEN
                clp$make_integer_value (cycle_object^.job_environment_information^.error_limit, 10, FALSE,
                      work_area, field_values^ [current_field_number].value);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = estimated_record_count =
              IF static_label_attributes.estimated_record_count_source <> amc$undefined_attribute THEN
                clp$make_integer_value (static_label_attributes.estimated_record_count, 10, FALSE, work_area,
                      field_values^ [current_field_number].value);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = exception_conditions =
              add_exception_conditions;

            = expiration_date =
              IF cycle_object <> NIL THEN
                clp$convert_string_to_file_ref (object_information_p^.resolved_path^, parsed_file_reference,
                      status);
                IF (parsed_file_reference.file_path_size > fsc$local_size + 1) AND
                      (parsed_file_reference.path (1, fsc$local_size + 1) = ':$LOCAL') THEN
                  clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
                ELSEIF (cycle_object^.cycle_information = NIL) OR
                      (cycle_object^.cycle_information^.expiration_date_time = max_date_time) THEN
                  clp$make_keyword_value ('INFINITE', work_area, field_values^ [current_field_number].value);
                ELSE
                  date_time.value := cycle_object^.cycle_information^.expiration_date_time;
                  date_time.date_specified := TRUE;
                  date_time.time_specified := FALSE;
                  clp$make_date_time_value (date_time, work_area, field_values^ [current_field_number].value);
                IFEND;
              ELSE
                IF NOT default_new_retention_specified THEN
                  clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
                ELSE
                  CASE default_new_retention.selector OF
                  = fsc$retention_day_increment =
                    time_increment.year := 0;
                    time_increment.month := 0;
                    time_increment.day := default_new_retention.day_increment;
                    time_increment.hour := 0;
                    time_increment.minute := 0;
                    time_increment.second := 0;
                    time_increment.millisecond := 0;
                  = fsc$retention_time_increment =
                    time_increment := default_new_retention.time_increment;
                  = fsc$retention_expiration_date =
                    ;
                  CASEND;
                  IF default_new_retention.selector = fsc$retention_expiration_date THEN
                    date_time.value := default_new_retention.expiration_date;
                  ELSE
                    pmp$get_compact_date_time (now, status);
                    IF NOT status.normal THEN
                      RETURN; {----->
                    IFEND;
                    pmp$compute_date_time (now, time_increment, date_time.value, status);
                    IF NOT status.normal THEN
                      RETURN; {----->
                    IFEND;
                  IFEND;
                  IF (default_new_retention.selector = fsc$retention_day_increment) AND
                        (default_new_retention.day_increment = UPPERVALUE (pft$retention)) THEN
                    clp$make_keyword_value ('INFINITE', work_area, field_values^ [current_field_number].
                          value);
                  ELSE
                    date_time.date_specified := TRUE;
                    date_time.time_specified := FALSE;
                    clp$make_date_time_value (date_time, work_area, field_values^ [current_field_number].
                          value);
                  IFEND;
                IFEND;
              IFEND;

            = external_vsn_list =
              IF (cycle_object <> NIL) AND (cycle_object^.cycle_device_class = rmc$magnetic_tape_device) AND
                    (cycle_object^.cycle_device_information <> NIL) AND
                    (cycle_object^.cycle_device_information^.magnetic_tape_device_info.volume_list <> NIL)
                    THEN
                make_list_of_external_vsns (cycle_object^.cycle_device_information^.magnetic_tape_device_info.
                      volume_list);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = file_access_procedure_name =
              IF static_label_attributes.file_access_procedure = osc$null_name THEN
                clp$make_keyword_value ('NONE', work_area, field_values^ [current_field_number].value);
              ELSE
                clp$make_entry_point_ref_value (static_label_attributes.file_access_procedure, '', work_area,
                      field_values^ [current_field_number].value);
              IFEND;

            = file_contents =
              fsp$convert_file_contents (static_label_attributes.file_contents,
                    static_label_attributes.file_structure, combined_file_contents, conversion_status);
              IF conversion_status.normal THEN
                clp$make_keyword_value (combined_file_contents, work_area,
                      field_values^ [current_field_number].value);
              ELSE
                clp$make_name_value (static_label_attributes.file_contents, work_area,
                      field_values^ [current_field_number].value);
              IFEND;

            = file_label_type =
              clp$make_keyword_value (label_types [static_label_attributes.label_type], work_area,
                    field_values^ [current_field_number].value);

            = file_limit =
              clp$make_integer_value (static_label_attributes.file_limit, 10, FALSE, work_area,
                    field_values^ [current_field_number].value);

            = file_organization =
              clp$make_keyword_value (file_organizations [static_label_attributes.file_organization],
                    work_area, field_values^ [current_field_number].value);

            = file_previously_opened =
              IF cycle_object <> NIL THEN
                clp$make_boolean_value (previously_opened, boolean_kind, work_area,
                      field_values^ [current_field_number].value);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = file_processor =

            /search_reserved_file_processors/
              BEGIN
                FOR entry := 1 TO UPPERBOUND (reserved_file_processors) DO
                  IF static_label_attributes.file_processor = reserved_file_processors [entry] THEN
                    clp$make_keyword_value (static_label_attributes.file_processor, work_area,
                          field_values^ [current_field_number].value);
                    EXIT /search_reserved_file_processors/; {----->
                  IFEND;
                FOREND;
                clp$make_name_value (static_label_attributes.file_processor, work_area,
                      field_values^ [current_field_number].value);
              END /search_reserved_file_processors/;


            = forced_write =
              IF static_label_attributes.forced_write = amc$forced_if_structure_change THEN
                clp$make_keyword_value ('FORCED_IF_STRUCTURE_CHANGE', work_area,
                      field_values^ [current_field_number].value);
              ELSE
                clp$make_boolean_value ((static_label_attributes.forced_write = amc$forced), boolean_kind,
                      work_area, field_values^ [current_field_number].value);
              IFEND;

            = hashing_procedure_name =
              IF (static_label_attributes.hashing_procedure_name_source = amc$undefined_attribute) OR
                    (static_label_attributes.hashing_procedure_name.name = osc$null_name) THEN
                clp$make_keyword_value ('NONE', work_area, field_values^ [current_field_number].value);
              ELSE
                clp$make_entry_point_ref_value (static_label_attributes.hashing_procedure_name.name,
                      static_label_attributes.hashing_procedure_name.object_library, work_area,
                      field_values^ [current_field_number].value);
              IFEND;

            = index_levels =
              clp$make_integer_value (static_label_attributes.index_levels, 10, FALSE, work_area,
                    field_values^ [current_field_number].value);

            = index_padding =
              clp$make_integer_value (static_label_attributes.index_padding, 10, FALSE, work_area,
                    field_values^ [current_field_number].value);

            = initial_home_block_count =
              clp$make_integer_value (static_label_attributes.initial_home_block_count, 10, FALSE, work_area,
                    field_values^ [current_field_number].value);

            = internal_code =
              clp$make_keyword_value (internal_codes [static_label_attributes.internal_code], work_area,
                    field_values^ [current_field_number].value);

            = job_file_address =
              IF (cycle_object <> NIL) AND (cycle_object^.job_environment_information <> NIL) THEN
                clp$make_integer_value (cycle_object^.job_environment_information^.job_file_address, 10,
                      FALSE, work_area, field_values^ [current_field_number].value);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = job_file_position =
              IF (cycle_object <> NIL) AND (cycle_object^.job_environment_information <> NIL) THEN
                clp$make_keyword_value (job_file_positions [cycle_object^.job_environment_information^.
                      job_file_position], work_area, field_values^ [current_field_number].value);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = job_instances_of_open =
              IF (cycle_object <> NIL) AND (cycle_object^.job_environment_information <> NIL) THEN
                clp$make_integer_value (cycle_object^.job_environment_information^.concurrent_open_count, 10,
                      FALSE, work_area, field_values^ [current_field_number].value);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = job_write_concurrency =
              IF (cycle_object <> NIL) AND (cycle_object^.job_environment_information <> NIL) AND
                    (fsc$job_write_concurrency_ao IN cycle_object^.job_environment_information^.
                    specified_attachment_options) THEN
                clp$make_boolean_value (cycle_object^.job_environment_information^.job_write_concurrency,
                      boolean_kind, work_area, field_values^ [current_field_number].value);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = key_length =
              IF static_label_attributes.key_length_source <> amc$undefined_attribute THEN
                clp$make_integer_value (static_label_attributes.key_length, 10, FALSE, work_area,
                      field_values^ [current_field_number].value);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = key_position =
              clp$make_integer_value (static_label_attributes.key_position, 10, FALSE, work_area,
                    field_values^ [current_field_number].value);

            = key_type =
              clp$make_keyword_value (key_types [static_label_attributes.key_type],
                    work_area, field_values^ [current_field_number].value);

            = last_access_date_time =
              IF (cycle_object <> NIL) AND (cycle_object^.cycle_information <> NIL) THEN
                date_time.date_specified := TRUE;
                date_time.time_specified := TRUE;
                date_time.value := cycle_object^.cycle_information^.last_access_date_time;
                clp$make_date_time_value (date_time, work_area, field_values^ [current_field_number].value);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = last_data_modification_time =
              IF (cycle_object <> NIL) AND (cycle_object^.cycle_information <> NIL) THEN
                date_time.date_specified := TRUE;
                date_time.time_specified := TRUE;
                date_time.value := cycle_object^.cycle_information^.data_modification_date_time;
                clp$make_date_time_value (date_time, work_area, field_values^ [current_field_number].value);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = last_modification_date_time =
              IF (cycle_object <> NIL) AND (cycle_object^.cycle_information <> NIL) THEN
                date_time.date_specified := TRUE;
                date_time.time_specified := TRUE;
                date_time.value := cycle_object^.cycle_information^.last_modification_date_time;
                clp$make_date_time_value (date_time, work_area, field_values^ [current_field_number].value);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = lifetime =
              add_lifetime;

            = lifetime_attachment_count =
              IF (cycle_object <> NIL) AND (cycle_object^.cycle_information <> NIL) THEN
                clp$make_integer_value (cycle_object^.cycle_information^.lifetime_attachment_count, 10, FALSE,
                      work_area, field_values^ [current_field_number].value);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = line_number =
              IF static_label_attributes.line_number_source <> amc$undefined_attribute THEN
                clp$make_record_value (2, work_area, field_values^ [current_field_number].value);
                field_values^ [current_field_number].value^.field_values^ [1].name := 'LOCATION';
                clp$make_integer_value (static_label_attributes.line_number.location, 10, FALSE, work_area,
                      field_values^ [current_field_number].value^.field_values^ [1].value);
                field_values^ [current_field_number].value^.field_values^ [2].name := 'LENGTH';
                clp$make_integer_value (static_label_attributes.line_number.length, 10, FALSE, work_area,
                      field_values^ [current_field_number].value^.field_values^ [2].value);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = loading_factor =
              clp$make_integer_value (static_label_attributes.loading_factor, 10, FALSE, work_area,
                    field_values^ [current_field_number].value);

            = lock_expiration_time =
              clp$make_integer_value (static_label_attributes.lock_expiration_time, 10, FALSE, work_area,
                    field_values^ [current_field_number].value);

            = logging_options =
              IF static_label_attributes.logging_options <> $amt$logging_options [] THEN
                node := ^field_values^ [current_field_number].value;
                FOR logging_option := LOWERVALUE (amt$logging_possibilities)
                      TO UPPERVALUE (amt$logging_possibilities) DO
                  IF logging_option IN static_label_attributes.logging_options THEN
                    clp$make_list_value (work_area, node^);
                    clp$make_keyword_value (logging_possibilities [logging_option], work_area,
                          node^^.element_value);
                    node := ^node^^.link;
                  IFEND;
                FOREND;
              ELSE
                clp$make_keyword_value ('NONE', work_area, field_values^ [current_field_number].value);
              IFEND;

            = log_residence =
              IF static_label_attributes.log_residence <> ' ' THEN
                clp$make_file_value (static_label_attributes.log_residence, work_area,
                      field_values^ [current_field_number].value);
              ELSE
                clp$make_keyword_value ('NONE', work_area, field_values^ [current_field_number].value);
              IFEND;

            = mainframe_attachment =
              IF (cycle_object <> NIL) AND (cycle_object^.cycle_information <> NIL) AND
                    (cycle_object^.cycle_information^.mainframe_usage_concurrency <>
                    $fst$mainframe_usage_concurrency []) THEN
                node := ^field_values^ [current_field_number].value;
                FOR mf_attachment := LOWERVALUE (fst$mf_usage_concurrency_scope)
                      TO UPPERVALUE (fst$mf_usage_concurrency_scope) DO
                  IF mf_attachment IN cycle_object^.cycle_information^.mainframe_usage_concurrency THEN
                    clp$make_list_value (work_area, node^);
                    clp$make_keyword_value (mainframe_attachments [mf_attachment], work_area,
                          node^^.element_value);
                    node := ^node^^.link;
                  IFEND;
                FOREND;
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = mainframe_write_concurrency =
              IF (cycle_object <> NIL) AND (cycle_object^.cycle_information <> NIL) AND
                    (cycle_object^.cycle_information^.mainframe_write_concurrency <>
                    fsc$not_attached_for_write) THEN
                clp$make_keyword_value (mainframe_write_concurrencies
                      [cycle_object^.cycle_information^.mainframe_write_concurrency], work_area,
                      field_values^ [current_field_number].value);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = mass_storage_allocation_size =
              IF (cycle_object <> NIL) AND (cycle_object^.cycle_device_class = rmc$mass_storage_device) AND
                    (cycle_object^.cycle_device_information <> NIL) AND
                    cycle_object^.cycle_device_information^.mass_storage_device_info.resides_online THEN
                clp$make_integer_value (cycle_object^.cycle_device_information^.mass_storage_device_info.
                      allocation_unit_size, 10, FALSE, work_area, field_values^ [current_field_number].value);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = mass_storage_bytes_allocated =
              IF (cycle_object <> NIL) AND (cycle_object^.cycle_device_class = rmc$mass_storage_device) AND
                    (cycle_object^.cycle_device_information <> NIL) AND
                    cycle_object^.cycle_device_information^.mass_storage_device_info.resides_online THEN
                clp$make_integer_value (cycle_object^.cycle_device_information^.mass_storage_device_info.
                      bytes_allocated, 10, FALSE, work_area, field_values^ [current_field_number].value);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = mass_storage_class =
              IF (cycle_object <> NIL) AND (cycle_object^.cycle_device_class = rmc$mass_storage_device) AND
                    (cycle_object^.cycle_device_information <> NIL) AND
                    cycle_object^.cycle_device_information^.mass_storage_device_info.resides_online THEN
                character_string := cycle_object^.cycle_device_information^.mass_storage_device_info.
                      mass_storage_class;
                clp$make_name_value (character_string, work_area, field_values^ [current_field_number].value);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = mass_storage_free_behind =
              IF (cycle_object <> NIL) AND (cycle_object^.cycle_device_class = rmc$mass_storage_device) AND
                    (cycle_object^.job_environment_information <> NIL) AND
                    (fsc$free_behind_ao IN cycle_object^.job_environment_information^.
                    specified_attachment_options) THEN
                clp$make_boolean_value (cycle_object^.job_environment_information^.mass_storage_free_behind,
                      boolean_kind, work_area, field_values^ [current_field_number].value);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = mass_storage_initial_volume =
              IF (cycle_object <> NIL) AND (cycle_object^.cycle_device_class = rmc$mass_storage_device) AND
                    (cycle_object^.cycle_device_information <> NIL) AND
                    cycle_object^.cycle_device_information^.mass_storage_device_info.resides_online AND
                    (cycle_object^.cycle_device_information^.mass_storage_device_info.initial_volume <> ' ')
                    THEN
                clp$make_string_value (cycle_object^.cycle_device_information^.mass_storage_device_info.
                      initial_volume, work_area, field_values^ [current_field_number].value);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = mass_storage_sequential_access =
              IF (cycle_object <> NIL) AND (cycle_object^.cycle_device_class = rmc$mass_storage_device) AND
                    (cycle_object^.job_environment_information <> NIL) AND
                    (fsc$sequential_access_ao IN cycle_object^.job_environment_information^.
                    specified_attachment_options) THEN
                clp$make_boolean_value (cycle_object^.job_environment_information^.
                      mass_storage_sequential_access, boolean_kind, work_area,
                      field_values^ [current_field_number].value);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = mass_storage_transfer_size =
              IF (cycle_object <> NIL) AND (cycle_object^.cycle_device_class = rmc$mass_storage_device) AND
                    (cycle_object^.cycle_device_information <> NIL) AND
                    cycle_object^.cycle_device_information^.mass_storage_device_info.resides_online THEN
                clp$make_integer_value (cycle_object^.cycle_device_information^.mass_storage_device_info.
                      transfer_size, 10, FALSE, work_area, field_values^ [current_field_number].value);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = maximum_block_length =
              clp$make_integer_value (static_label_attributes.max_block_length, 10, FALSE, work_area,
                    field_values^ [current_field_number].value);

            = maximum_record_length =
              clp$make_integer_value (static_label_attributes.max_record_length, 10, FALSE, work_area,
                    field_values^ [current_field_number].value);

            = message_control =
              IF (cycle_object <> NIL) AND (cycle_object^.job_environment_information <> NIL) THEN
                IF cycle_object^.job_environment_information^.message_control <> $amt$message_control [] THEN
                  node := ^field_values^ [current_field_number].value;
                  FOR message_control_value := amc$trivial_errors TO amc$statistics DO
                    IF message_control_value IN cycle_object^.job_environment_information^.
                          message_control THEN
                      clp$make_list_value (work_area, node^);
                      clp$make_keyword_value (message_controls [message_control_value], work_area,
                            node^^.element_value);
                      node := ^node^^.link;
                    IFEND;
                  FOREND;
                ELSE
                  clp$make_keyword_value ('NONE', work_area, field_values^ [current_field_number].value);
                IFEND;
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = minimum_block_length =
              clp$make_integer_value (static_label_attributes.min_block_length, 10, FALSE, work_area,
                    field_values^ [current_field_number].value);

            = minimum_record_length =
              clp$make_integer_value (static_label_attributes.min_record_length, 10, FALSE, work_area,
                    field_values^ [current_field_number].value);

            = object_type =
              IF (object_information_p <> NIL) AND (cycle_object <> NIL) THEN
                clp$make_keyword_value ('CYCLE', work_area, field_values^ [current_field_number].value);
              ELSE { system_default_values requested or object not registered }
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = open_position =
              add_open_position;

            = padding_character =
              character_string := static_label_attributes.padding_character;
              clp$make_string_value (character_string, work_area, field_values^ [current_field_number].value);

            = page_format =
              clp$make_keyword_value (page_formats [static_label_attributes.page_format], work_area,
                    field_values^ [current_field_number].value);

            = page_length =
              clp$make_integer_value (static_label_attributes.page_length, 10, FALSE, work_area,
                    field_values^ [current_field_number].value);

            = page_width =
              clp$make_integer_value (static_label_attributes.page_width, 10, FALSE, work_area,
                    field_values^ [current_field_number].value);

            = path =
              add_path (c$file_path);

            = potential_job_access =
              add_potential_job_access;

            = preset_value =
              clp$make_integer_value (static_label_attributes.preset_value, 10, FALSE, work_area,
                    field_values^ [current_field_number].value);

            = private_read =
              IF (cycle_object <> NIL) AND (cycle_object^.job_environment_information <> NIL) AND
                    cycle_object^.job_environment_information^.private_read.specified_on_attach THEN
                clp$make_boolean_value (cycle_object^.job_environment_information^.private_read.value,
                      boolean_kind, work_area, field_values^ [current_field_number].value);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = record_delimiting_character =
              character_string := static_label_attributes.record_delimiting_character;
              clp$make_string_value (character_string, work_area, field_values^ [current_field_number].value);

            = record_limit =
              IF static_label_attributes.record_limit_source <> amc$undefined_attribute THEN
                clp$make_integer_value (static_label_attributes.record_limit, 10, FALSE, work_area,
                      field_values^ [current_field_number].value);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = record_type =
              clp$make_keyword_value (record_types [static_label_attributes.record_type], work_area,
                    field_values^ [current_field_number].value);

            = recorded_vsn_list =
              add_recorded_vsn_list;

            = records_per_block =
              IF static_label_attributes.records_per_block_source <> amc$undefined_attribute THEN
                clp$make_integer_value (static_label_attributes.records_per_block, 10, FALSE, work_area,
                      field_values^ [current_field_number].value);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = registered =
              IF (object_information_p <> NIL) THEN
                clp$make_boolean_value (((cycle_object <> NIL) AND
                      (cycle_object^.cycle_global_file_name <> null_unique_name)), boolean_kind, work_area,
                      field_values^ [current_field_number].value);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = removable_media_group =
              IF (cycle_object <> NIL) AND (cycle_object^.cycle_device_information <> NIL) AND
                    (cycle_object^.cycle_device_class = rmc$magnetic_tape_device) THEN
                clp$make_name_value (cycle_object^.cycle_device_information^.magnetic_tape_device_info.
                      removable_media_group, work_area, field_values^ [current_field_number].value);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = retrieve_option =
              add_retrieve_option;

            = ring_attributes =
              clp$make_record_value (3, work_area, field_values^ [current_field_number].value);
              field_values^ [current_field_number].value^.field_values^ [1].name := 'R1';
              clp$make_integer_value (static_label_attributes.ring_attributes.r1, 10, FALSE, work_area,
                    field_values^ [current_field_number].value^.field_values^ [1].value);
              field_values^ [current_field_number].value^.field_values^ [2].name := 'R2';
              clp$make_integer_value (static_label_attributes.ring_attributes.r2, 10, FALSE, work_area,
                    field_values^ [current_field_number].value^.field_values^ [2].value);
              field_values^ [current_field_number].value^.field_values^ [3].name := 'R3';
              clp$make_integer_value (static_label_attributes.ring_attributes.r3, 10, FALSE, work_area,
                    field_values^ [current_field_number].value^.field_values^ [3].value);

            = secondary_residence =
              add_secondary_residence;

            = set_name =
              add_set_name;

            = shared_queue =
              IF (cycle_object <> NIL) AND (cycle_object^.cycle_device_class = rmc$mass_storage_device) AND
                    (cycle_object^.cycle_device_information <> NIL) AND
                    (cycle_object^.cycle_device_information^.mass_storage_device_info.shared_queue <>
                    osc$null_name) THEN
                clp$make_keyword_value (cycle_object^.cycle_device_information^.mass_storage_device_info.
                      shared_queue, work_area, field_values^ [current_field_number].value);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = site_archive_option =
              IF (cycle_object <> NIL) AND (cycle_object^.cycle_information <> NIL) AND
                    (cycle_object^.cycle_information^.site_archive_option <> 0) THEN
                clp$make_integer_value (cycle_object^.cycle_information^.site_archive_option, 10, FALSE,
                      work_area, field_values^ [current_field_number].value);
              ELSE
                clp$make_keyword_value ('NULL', work_area, field_values^ [current_field_number].value);
              IFEND;

            = site_backup_option =
              IF (cycle_object <> NIL) AND (cycle_object^.cycle_information <> NIL) AND
                    (cycle_object^.cycle_information^.site_backup_option <> 0) THEN
                clp$make_integer_value (cycle_object^.cycle_information^.site_backup_option, 10, FALSE,
                      work_area, field_values^ [current_field_number].value);
              ELSE
                clp$make_keyword_value ('NULL', work_area, field_values^ [current_field_number].value);
              IFEND;

            = site_release_option =
              IF (cycle_object <> NIL) AND (cycle_object^.cycle_information <> NIL) AND
                    (cycle_object^.cycle_information^.site_release_option <> 0) THEN
                clp$make_integer_value (cycle_object^.cycle_information^.site_release_option, 10, FALSE,
                      work_area, field_values^ [current_field_number].value);
              ELSE
                clp$make_keyword_value ('NULL', work_area, field_values^ [current_field_number].value);
              IFEND;

            = size =
              IF (cycle_object <> NIL) AND (cycle_object^.cycle_size <> NIL) THEN
                clp$make_integer_value (cycle_object^.cycle_size^, 10, FALSE, work_area,
                      field_values^ [current_field_number].value);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = statement_identifier =
              IF static_label_attributes.statement_identifier_source <> amc$undefined_attribute THEN
                clp$make_record_value (2, work_area, field_values^ [current_field_number].value);
                field_values^ [current_field_number].value^.field_values^ [1].name := 'LOCATION';
                clp$make_integer_value (static_label_attributes.statement_identifier.location, 10, FALSE,
                      work_area, field_values^ [current_field_number].value^.field_values^ [1].value);
                field_values^ [current_field_number].value^.field_values^ [2].name := 'LENGTH';
                clp$make_integer_value (static_label_attributes.statement_identifier.length, 10, FALSE,
                      work_area, field_values^ [current_field_number].value^.field_values^ [2].value);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = tape_density =
              IF (cycle_object <> NIL) AND (cycle_object^.cycle_device_class = rmc$magnetic_tape_device) AND
                    (cycle_object^.cycle_device_information <> NIL) THEN
                clp$make_keyword_value (tape_densities [cycle_object^.cycle_device_information^.
                      magnetic_tape_device_info.density], work_area,
                      field_values^ [current_field_number].value);
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = unique_data_name =
              IF (cycle_object <> NIL) AND (cycle_object^.cycle_device_class = rmc$mass_storage_device) THEN
                pmp$convert_binary_unique_name (cycle_object^.cycle_global_file_name, gfn, status);
                IF status.normal THEN
                  clp$make_name_value (gfn, work_area, field_values^ [current_field_number].value);
                ELSE
                  clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
                  status.normal := TRUE;
                IFEND;
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = unique_name =
              IF cycle_object <> NIL THEN
                pmp$convert_binary_unique_name (cycle_object^.cycle_global_file_name, gfn, status);
                IF status.normal THEN
                  clp$make_name_value (gfn, work_area, field_values^ [current_field_number].value);
                ELSE
                  clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
                  status.normal := TRUE;
                IFEND;
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            = user_information =
              IF static_label_attributes.user_info <> ' ' THEN
                clp$make_string_value (static_label_attributes.user_info
                      (1, clp$trimmed_string_size (static_label_attributes.user_info)), work_area,
                      field_values^ [current_field_number].value);
              ELSE
                clp$make_string_value ('', work_area, field_values^ [current_field_number].value);
              IFEND;

            = vertical_print_density =
              clp$make_integer_value (static_label_attributes.vertical_print_density, 10, FALSE, work_area,
                    field_values^ [current_field_number].value);

            = volume_overflow_allowed =
              IF (cycle_object <> NIL) AND (cycle_object^.cycle_device_information <> NIL) THEN
                IF cycle_object^.cycle_device_class = rmc$mass_storage_device THEN
                  clp$make_boolean_value (cycle_object^.cycle_device_information^.mass_storage_device_info.
                        volume_overflow_allowed, boolean_kind, work_area,
                        field_values^ [current_field_number].value);
                ELSEIF cycle_object^.cycle_device_class = rmc$magnetic_tape_device THEN
                  clp$make_boolean_value (cycle_object^.cycle_device_information^.magnetic_tape_device_info.
                        volume_overflow_allowed, boolean_kind, work_area,
                        field_values^ [current_field_number].value);
                ELSE
                  clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
                IFEND;
              ELSE
                clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
              IFEND;

            ELSE
            CASEND;
          IFEND; {unregistered object}
          current_field_number := current_field_number + 1;
        IFEND; {attribute requested}
      FOREND;

    PROCEND build_cycle_attrib_record;

?? TITLE := 'build_file_attrib_record', EJECT ??

    PROCEDURE build_file_attrib_record
      (VAR result: ^clt$data_value);

      VAR
        entry: ost$positive_integers,
        permit_array: array [1 .. 1] of pft$permit_array_entry;

      clp$make_list_value (work_area, result);
      clp$make_record_value (number_of_requested_attributes.file_type, work_area, result^.element_value);
      field_values := result^.element_value^.field_values;
      current_field_number := 1;

      FOR attribute := 1 TO file_attribute_max DO
        IF current_field_number > number_of_requested_attributes.file_type THEN
          RETURN; {----->
        IFEND;
        IF file_attributes [attribute] IN local_attributes_requested THEN
          field_values^ [current_field_number].name := attribute_choices [file_attributes [attribute]].name;
          CASE file_attributes [attribute] OF
          = access_control_list =
            IF (object_information_p <> NIL) AND (object_information_p^.object <> NIL) AND
                  (object_information_p^.object^.file_permits <> NIL) THEN
              get_permits (object_information_p^.object^.file_permits,
                    field_values^ [current_field_number].value);
            ELSE
              clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
            IFEND;

          = account_project =
            IF (object_information_p <> NIL) AND (object_information_p^.object <> NIL) AND
                  (object_information_p^.object^.file_information <> NIL) THEN
              clp$make_record_value (2, work_area, field_values^ [current_field_number].value);
              field_values^ [current_field_number].value^.field_values^ [1].name := 'ACCOUNT';
              clp$make_name_value (object_information_p^.object^.file_information^.account, work_area,
                    field_values^ [current_field_number].value^.field_values^ [1].value);
              field_values^ [current_field_number].value^.field_values^ [2].name := 'PROJECT';
              clp$make_name_value (object_information_p^.object^.file_information^.project, work_area,
                    field_values^ [current_field_number].value^.field_values^ [2].value);
            ELSE
              clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
            IFEND;

          = attachment_log =
            IF (object_information_p <> NIL) AND (object_information_p^.object <> NIL) THEN
              node := ^field_values^ [current_field_number].value;
              IF object_information_p^.object^.file_log <> NIL THEN
                FOR entry := 1 TO UPPERBOUND (object_information_p^.object^.file_log^) DO
                  clp$make_list_value (work_area, node^);
                  clp$make_record_value (5, work_area, node^^.element_value);
                  node^^.element_value^.field_values^ [1].name := 'USER';
                  clp$make_name_value (object_information_p^.object^.file_log^ [entry].user_id.user,
                        work_area, node^^.element_value^.field_values^ [1].value);
                  node^^.element_value^.field_values^ [2].name := 'FAMILY';
                  clp$make_name_value (object_information_p^.object^.file_log^ [entry].user_id.family,
                        work_area, node^^.element_value^.field_values^ [2].value);
                  node^^.element_value^.field_values^ [3].name := 'FILE_ACCESS_COUNT';
                  clp$make_integer_value (object_information_p^.object^.file_log^ [entry].access_count, 10,
                        FALSE, work_area, node^^.element_value^.field_values^ [3].value);
                  node^^.element_value^.field_values^ [4].name := 'LAST_ACCESS_DATE_TIME';
                  date_time.date_specified := TRUE;
                  date_time.time_specified := TRUE;
                  date_time.value := object_information_p^.object^.file_log^ [entry].access_date_time;
                  clp$make_date_time_value (date_time, work_area,
                        node^^.element_value^.field_values^ [4].value);
                  node^^.element_value^.field_values^ [5].name := 'LAST_CYCLE_REFERENCED';
                  clp$make_integer_value (object_information_p^.object^.file_log^ [entry].last_cycle, 10,
                        FALSE, work_area, node^^.element_value^.field_values^ [5].value);
                  node := ^node^^.link;
                FOREND;
              ELSE
                IF NOT all_requested THEN { this procedure call was already made if all_requested is true }
                  pmp$get_user_identification (user_id, status);
                  IF NOT status.normal THEN
                    RETURN; {----->
                  IFEND;
                IFEND;
                IF (NOT avp$system_administrator ()) AND (fsp$path_element (^evaluated_file_reference,
                      2) ^ <> user_id.user) AND (fsp$path_element (^evaluated_file_reference,
                      1) ^ <> fsc$local) THEN
                  osp$set_status_abnormal (amc$access_method_id, fse$attribute_not_available,
                        'ATTACHMENT_LOG', status);
                  osp$append_status_file (osc$status_parameter_delimiter,
                        object_information_p^.resolved_path^, status);
                ELSE
                  clp$make_list_value (work_area, node^);
                IFEND;
              IFEND;
            ELSE
              clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
            IFEND;

          = attachment_logging_selected =
            IF (object_information_p <> NIL) AND (object_information_p^.object <> NIL) AND
                  (object_information_p^.object^.file_information <> NIL) THEN
              IF object_information_p^.object^.file_information^.logging_selection = NIL THEN
                IF NOT all_requested THEN { this procedure call was already made if all_requested is true }
                  pmp$get_user_identification (user_id, status);
                  IF NOT status.normal THEN
                    RETURN; {----->
                  IFEND;
                IFEND;
                IF (NOT avp$system_administrator ()) AND (fsp$path_element (^evaluated_file_reference,
                      2) ^ <> user_id.user) AND (fsp$path_element (^evaluated_file_reference,
                      1) ^ <> fsc$local) THEN
                  osp$set_status_abnormal (amc$access_method_id, fse$attribute_not_available,
                        'ATTACHMENT_LOGGING_SELECTED', status);
                  osp$append_status_file (osc$status_parameter_delimiter,
                        object_information_p^.resolved_path^, status);
                ELSE
                  clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
                IFEND;
              ELSE
                clp$make_boolean_value ((object_information_p^.object^.file_information^.logging_selection^ =
                      pfc$log), boolean_kind, work_area, field_values^ [current_field_number].value);
              IFEND;
            ELSE
              clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
            IFEND;

          = lifetime =
            add_lifetime;

          = object_type =
            IF (object_information_p <> NIL) AND (object_information_p^.object <> NIL) THEN
              clp$make_keyword_value ('FILE', work_area, field_values^ [current_field_number].value);
            ELSE { system_default_values requested or object not registered }
              clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
            IFEND;

          = path =
            add_path (c$file_path);

          = permitted_access =
            IF (object_information_p <> NIL) AND (object_information_p^.object <> NIL) AND
                  (object_information_p^.object^.applicable_file_permit <> NIL) THEN
              permit_array [1] := object_information_p^.object^.applicable_file_permit^;
              get_permits (^permit_array, field_values^ [current_field_number].value);
            ELSE
              clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
            IFEND;

          = registered =
            IF object_information_p <> NIL THEN
              clp$make_boolean_value ((object_information_p^.object <> NIL), boolean_kind, work_area,
                    field_values^ [current_field_number].value);
            ELSE
              clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);
            IFEND;

          = set_name =
            add_set_name;

          = unique_name =
            clp$make_unspecified_value (work_area, field_values^ [current_field_number].value);

          ELSE
          CASEND;
          current_field_number := current_field_number + 1;
        IFEND;
      FOREND;

    PROCEND build_file_attrib_record;

?? TITLE := 'convert_file_ref_to_string', EJECT ??

    PROCEDURE convert_file_ref_to_string
      (    evaluated_file_reference: fst$evaluated_file_reference;
           path_type: t$path_type;
       VAR str: fst$path;
       VAR size: fst$path_size);

      VAR
        i: fst$path_index;

?? NEWTITLE := 'add_int_to_path', EJECT ??

      PROCEDURE [INLINE] add_int_to_path
        (    int: integer;
         VAR str: fst$path;
         VAR size: fst$path_size);

        VAR
          int_str: ost$string,
          local_status: ost$status;

        clp$convert_integer_to_string (int, 10 {radix} , FALSE {exclude radix} , int_str, local_status);
        IF local_status.normal THEN
          add_str_to_path (int_str.value (1, int_str.size), str, size);
        IFEND;

      PROCEND add_int_to_path;

?? OLDTITLE ??
?? NEWTITLE := 'add_str_to_path', EJECT ??

      PROCEDURE [INLINE] add_str_to_path
        (    element_string: string ( * );
         VAR str: fst$path;
         VAR size: fst$path_size);

        VAR
          str_size: integer;

        str_size := STRLENGTH (element_string);
        IF str_size + size <= fsc$max_path_size THEN
          str (size + 1, str_size) := element_string;
          size := size + str_size;
        IFEND;

      PROCEND add_str_to_path;

?? OLDTITLE ??
?? EJECT ??

      size := evaluated_file_reference.path_structure_size;
      str := evaluated_file_reference.path_structure (1, size);
      str (1) := ':';
      i := $INTEGER (evaluated_file_reference.path_structure (1)) + 2;
      WHILE i < size DO
        str (i) := '.';
        i := i + $INTEGER (evaluated_file_reference.path_structure (i)) + 1;
      WHILEND;

{Add Cycle
      IF path_type >= c$cycle_path THEN
        CASE evaluated_file_reference.cycle_reference.specification OF
        = fsc$high_cycle =
          add_str_to_path ('.$HIGH', str, size);
        = fsc$low_cycle =
          add_str_to_path ('.$LOW', str, size);
        = fsc$next_cycle =
          add_str_to_path ('.$NEXT', str, size);
        = fsc$cycle_number =
          add_int_to_path (evaluated_file_reference.cycle_reference.cycle_number, str, size);
        ELSE
        CASEND;

      IFEND;

{Add Open_Position
      IF (path_type = c$complete_path)
{   } AND (evaluated_file_reference.path_handle_info.path_handle_present)
{   } AND (evaluated_file_reference.path_handle_info.path_handle.open_position.specified) THEN

{?? need to special case for $output???

        add_str_to_path (clv$open_positions [evaluated_file_reference.path_handle_info.path_handle.
              open_position.value], str, size);
      IFEND;

    PROCEND convert_file_ref_to_string;

?? TITLE := 'get_permits', EJECT ??

    PROCEDURE get_permits
      (    permits: ^pft$permit_array;
       VAR access_control_list_p: ^clt$data_value);

      VAR
        access_control_list_pp: ^^clt$data_value,
        i: ost$positive_integers,
        option_list_pp: ^^clt$data_value;

      access_control_list_pp := ^access_control_list_p;

      FOR i := 1 TO UPPERBOUND (permits^) DO
        clp$make_list_value (work_area, access_control_list_pp^);
        clp$make_record_value (4, work_area, access_control_list_pp^^.element_value);
        access_control_list_pp^^.element_value^.field_values^ [1].name := 'SUBJECT';
        clp$make_record_value (5, work_area, access_control_list_pp^^.element_value^.field_values^ [1].value);
        access_control_list_pp^^.element_value^.field_values^ [1].value^.field_values^ [1].name := 'GROUP';
        access_control_list_pp^^.element_value^.field_values^ [1].value^.field_values^ [2].name := 'FAMILY';
        clp$make_unspecified_value (work_area, access_control_list_pp^^.element_value^.field_values^ [1].
              value^.field_values^ [2].value);
        access_control_list_pp^^.element_value^.field_values^ [1].value^.field_values^ [3].name := 'ACCOUNT';
        clp$make_unspecified_value (work_area, access_control_list_pp^^.element_value^.field_values^ [1].
              value^.field_values^ [3].value);
        access_control_list_pp^^.element_value^.field_values^ [1].value^.field_values^ [4].name := 'PROJECT';
        clp$make_unspecified_value (work_area, access_control_list_pp^^.element_value^.field_values^ [1].
              value^.field_values^ [4].value);
        access_control_list_pp^^.element_value^.field_values^ [1].value^.field_values^ [5].name := 'USER';
        clp$make_unspecified_value (work_area, access_control_list_pp^^.element_value^.field_values^ [1].
              value^.field_values^ [5].value);

        CASE permits^ [i].group.group_type OF
        = pfc$public =
          clp$make_keyword_value ('PUBLIC', work_area, access_control_list_pp^^.element_value^.
                field_values^ [1].value^.field_values^ [1].value);
        = pfc$family =
          clp$make_keyword_value ('FAMILY', work_area, access_control_list_pp^^.element_value^.
                field_values^ [1].value^.field_values^ [1].value);
          clp$make_name_value (permits^ [i].group.family_description.family, work_area,
                access_control_list_pp^^.element_value^.field_values^ [1].value^.field_values^ [2].value);
        = pfc$account =
          clp$make_keyword_value ('ACCOUNT', work_area, access_control_list_pp^^.element_value^.
                field_values^ [1].value^.field_values^ [1].value);
          clp$make_name_value (permits^ [i].group.account_description.family, work_area,
                access_control_list_pp^^.element_value^.field_values^ [1].value^.field_values^ [2].value);
          clp$make_name_value (permits^ [i].group.account_description.account, work_area,
                access_control_list_pp^^.element_value^.field_values^ [1].value^.field_values^ [3].value);
        = pfc$project =
          clp$make_keyword_value ('PROJECT', work_area, access_control_list_pp^^.element_value^.
                field_values^ [1].value^.field_values^ [1].value);
          clp$make_name_value (permits^ [i].group.project_description.family, work_area,
                access_control_list_pp^^.element_value^.field_values^ [1].value^.field_values^ [2].value);
          clp$make_name_value (permits^ [i].group.project_description.account, work_area,
                access_control_list_pp^^.element_value^.field_values^ [1].value^.field_values^ [3].value);
          clp$make_name_value (permits^ [i].group.project_description.project, work_area,
                access_control_list_pp^^.element_value^.field_values^ [1].value^.field_values^ [4].value);
        = pfc$user =
          clp$make_keyword_value ('USER', work_area, access_control_list_pp^^.element_value^.
                field_values^ [1].value^.field_values^ [1].value);
          clp$make_name_value (permits^ [i].group.user_description.family, work_area,
                access_control_list_pp^^.element_value^.field_values^ [1].value^.field_values^ [2].value);
          clp$make_name_value (permits^ [i].group.user_description.user, work_area,
                access_control_list_pp^^.element_value^.field_values^ [1].value^.field_values^ [5].value);
        = pfc$user_account =
          clp$make_keyword_value ('USER_ACCOUNT', work_area,
                access_control_list_pp^^.element_value^.field_values^ [1].value^.field_values^ [1].value);
          clp$make_name_value (permits^ [i].group.user_account_description.family, work_area,
                access_control_list_pp^^.element_value^.field_values^ [1].value^.field_values^ [2].value);
          clp$make_name_value (permits^ [i].group.user_account_description.account, work_area,
                access_control_list_pp^^.element_value^.field_values^ [1].value^.field_values^ [3].value);
          clp$make_name_value (permits^ [i].group.user_account_description.user, work_area,
                access_control_list_pp^^.element_value^.field_values^ [1].value^.field_values^ [5].value);
        = pfc$member =
          clp$make_keyword_value ('MEMBER', work_area, access_control_list_pp^^.element_value^.
                field_values^ [1].value^.field_values^ [1].value);
          clp$make_name_value (permits^ [i].group.member_description.family, work_area,
                access_control_list_pp^^.element_value^.field_values^ [1].value^.field_values^ [2].value);
          clp$make_name_value (permits^ [i].group.member_description.account, work_area,
                access_control_list_pp^^.element_value^.field_values^ [1].value^.field_values^ [3].value);
          clp$make_name_value (permits^ [i].group.member_description.project, work_area,
                access_control_list_pp^^.element_value^.field_values^ [1].value^.field_values^ [4].value);
          clp$make_name_value (permits^ [i].group.member_description.user, work_area,
                access_control_list_pp^^.element_value^.field_values^ [1].value^.field_values^ [5].value);
        ELSE
        CASEND;

        access_control_list_pp^^.element_value^.field_values^ [2].name := 'ACCESS_MODES';
        IF permits^ [i].usage_permissions = $pft$permit_selections [] THEN
          clp$make_keyword_value ('NONE', work_area, access_control_list_pp^^.element_value^.
                field_values^ [2].value);
        ELSE
          option_list_pp := ^access_control_list_pp^^.element_value^.field_values^ [2].value;
          FOR option := LOWERVALUE (pft$permit_options) TO UPPERVALUE (pft$permit_options) DO
            IF option IN permits^ [i].usage_permissions THEN
              clp$make_list_value (work_area, option_list_pp^);
              clp$make_keyword_value (permit_share_options [option], work_area,
                    option_list_pp^^.element_value);
              option_list_pp := ^option_list_pp^^.link;
            IFEND;
          FOREND;
        IFEND;

        access_control_list_pp^^.element_value^.field_values^ [3].name := 'APPLICATION_INFORMATION';
        clp$make_string_value (permits^ [i].application_info
              (1, clp$trimmed_string_size (permits^ [i].application_info)), work_area,
              access_control_list_pp^^.element_value^.field_values^ [3].value);

        access_control_list_pp^^.element_value^.field_values^ [4].name := 'REQUIRED_SHARE_MODES';
        IF permits^ [i].share_requirements = $pft$share_requirements [] THEN
          clp$make_keyword_value ('NONE', work_area, access_control_list_pp^^.element_value^.
                field_values^ [4].value);
        ELSE
          option_list_pp := ^access_control_list_pp^^.element_value^.field_values^ [4].value;
          FOR option := LOWERVALUE (pft$share_options) TO UPPERVALUE (pft$share_options) DO
            IF option IN permits^ [i].share_requirements THEN
              clp$make_list_value (work_area, option_list_pp^);
              clp$make_keyword_value (permit_share_options [option], work_area,
                    option_list_pp^^.element_value);
              option_list_pp := ^option_list_pp^^.link;
            IFEND;
          FOREND;
        IFEND;
        access_control_list_pp := ^access_control_list_pp^^.link;
      FOREND;

    PROCEND get_permits;
?? OLDTITLE, EJECT ??

    CONST
      owner_only_catalog_attributes = 1,
      owner_only_file_attributes = 3;

    VAR
      file_only_attributes: [STATIC, READ, oss$job_paged_literal] file_attribute_keys :=
            [access_control_list, account_project, attachment_log, attachment_logging_selected,
            permitted_access],
      file_type_attributes: [STATIC, READ, oss$job_paged_literal] file_attribute_keys :=
            [access_control_list, account_project, attachment_log, attachment_logging_selected, lifetime,
            object_type, path, permitted_access, registered, set_name, unique_name],
      owner_only_attributes: [STATIC, READ, oss$job_paged_literal] file_attribute_keys :=
            [access_control_list, attachment_log, attachment_logging_selected];

    VAR
      attribute: file_attribute_key,
      character_string: string (1),
      current_field_number: file_attribute_key,
      cycle_element: ost$positive_integers,
      date_time: clt$date_time,
      field_values: ^array [1 .. * ] of clt$field_value,
      gfn: ost$name,
      local_attributes_requested: file_attribute_keys,
      node: ^^clt$data_value,
      number_of_requested_attributes: object_type_counts,
      object_information_p: ^fst$goi_object_information,
      object_registered_and_permitted: boolean,
      option: pft$permit_options,
      path_size: fst$path_size,
      result_pp: ^^clt$data_value,
      str: fst$path,
      user_id: ost$user_identification;

    object_registered_and_permitted := status.normal;
    status.normal := TRUE;

    IF object_info_sequence_p <> NIL THEN
      NEXT object_information_p IN object_info_sequence_p;
      IF object_information_p = NIL THEN
        osp$set_status_condition (fse$system_error, status);
        osp$append_status_parameter (osc$status_parameter_delimiter, nil_object_info_text, status);
        RETURN; {----->
      IFEND;
    ELSE
      object_information_p := NIL;
    IFEND;

    local_attributes_requested := attributes_requested;
    number_of_requested_attributes := requested_attribute_counts;
    IF all_requested THEN
      IF NOT avp$system_administrator () THEN
        pmp$get_user_identification (user_id, status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
        IF (fsp$path_element (^evaluated_file_reference, 1) ^ <> fsc$local) AND
              (fsp$path_element (^evaluated_file_reference, 2) ^ <> user_id.user) THEN
          local_attributes_requested := local_attributes_requested - owner_only_attributes;
          number_of_requested_attributes.file_type := number_of_requested_attributes.file_type -
                owner_only_file_attributes;
          number_of_requested_attributes.catalog_type := number_of_requested_attributes.catalog_type -
                owner_only_catalog_attributes;
        IFEND;
      IFEND;
    IFEND;

    IF (object_info_sequence_p = NIL) {system_default_values specified} OR
          NOT object_registered_and_permitted THEN
      result_pp := ^result;
      IF (local_attributes_requested * file_only_attributes) <> $file_attribute_keys [] THEN
        build_file_attrib_record (result_pp^);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
        IF (local_attributes_requested - file_type_attributes) = $file_attribute_keys [] THEN
          RETURN; {----->
        ELSE
          result_pp := ^result_pp^^.link;
        IFEND;
      IFEND;
      IF number_of_requested_attributes.cycle_type > 0 THEN
        build_cycle_attrib_record ({cycle_object} NIL, result_pp^);
      IFEND;
    ELSEIF object_information_p^.object = NIL THEN
      osp$set_status_condition (fse$attributes_not_defined, status);
      RETURN; {----->
    ELSEIF object_information_p^.object^.object_type = fsc$goi_catalog_object THEN
      IF number_of_requested_attributes.catalog_type > 0 THEN
        build_catalog_attrib_record (result);
      ELSE
        osp$set_status_condition (fse$attributes_not_defined, status);
        RETURN; {----->
      IFEND;
    ELSEIF object_information_p^.object^.object_type = fsc$goi_file_object THEN
      IF (local_attributes_requested * file_only_attributes) <> $file_attribute_keys [] THEN
        build_file_attrib_record (result);
        IF (NOT status.normal) OR ((local_attributes_requested - file_type_attributes) =
              $file_attribute_keys []) THEN

{ Attributes that are common to both file and cycle objects, such as lifetime, object_type, path,
{ registered, set_name and unique_name, would cause cycle object information to be requested.  But if no other
{ cycle attributes were requested, it would not be necessary to return a record of type cycle attributes in
{ addition to one of type file attributes.

          RETURN; {----->
        IFEND;
      IFEND;

      IF object_information_p^.object^.cycle_object_list <> NIL THEN
        result_pp := ^result;
        IF (local_attributes_requested * file_only_attributes) <> $file_attribute_keys [] THEN

{ A file type record was built.  It is possible for get_object_information to return a file object even if
{ no file type attributes were requested, in which case it would not be necessary to return a record of
{ file attributes type.  This would occur if potential_job_access was requested, because it requires file
{ object information such as applicable_permits to determine its value.

          IF NOT (cycle_number IN local_attributes_requested) THEN

{ Cycle_number must be added to the display to differentiate the file's cycles.

            local_attributes_requested := local_attributes_requested + $file_attribute_keys [cycle_number];
            number_of_requested_attributes.cycle_type := number_of_requested_attributes.cycle_type + 1;
          IFEND;
          result_pp := ^result_pp^^.link;
        IFEND;

        FOR cycle_element := 1 TO UPPERBOUND (object_information_p^.object^.cycle_object_list^) DO
          build_cycle_attrib_record (^object_information_p^.object^.cycle_object_list^ [cycle_element],
                result_pp^);
          IF NOT status.normal THEN
            RETURN; {----->
          IFEND;
          result_pp := ^result_pp^^.link;
        FOREND;
      IFEND;
    ELSE { cycle object }
      build_cycle_attrib_record (object_information_p^.object, result);
    IFEND;

  PROCEND process_object_information;

?? TITLE := 'status_condition_ignorable', EJECT ??

  FUNCTION [INLINE] status_condition_ignorable
    (    condition: ost$status_condition_code;
         attributes_requested: file_attribute_keys;
         evaluated_file_reference: fst$evaluated_file_reference): boolean;

    status_condition_ignorable := (condition IN unknown_object_pf_conditions) OR
          (condition = ame$file_not_known) OR ((condition = pfe$unknown_permanent_file) AND
          (((-$file_attribute_keys [lifetime, path, set_name]) * attributes_requested =
          $file_attribute_keys []) OR (((-$file_attribute_keys [cycle_number, lifetime, path,
          set_name]) * attributes_requested = $file_attribute_keys []) AND
          (evaluated_file_reference.cycle_reference.specification = fsc$cycle_number)) OR
          (((-$file_attribute_keys [cycle_number, open_position, lifetime, path,
          set_name]) * attributes_requested = $file_attribute_keys []) AND
          evaluated_file_reference.path_handle_info.path_handle.open_position.specified)));

  FUNCEND status_condition_ignorable;

?? TITLE := 'clp$_display_file_attributes', EJECT ??

  PROCEDURE [XDCL] clp$_display_file_attributes
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{ PROCEDURE display_file_attributes, display_file_attribute, disfa (
{   file, f: any of
{       key
{         (system_default_values, system_default_value, sdv)
{       keyend
{       list of file
{     anyend = $required
{   display_options, display_option, do: list of key
{       all
{       (access_control_list, acl)
{       (account_project, ap)
{       (actual_job_access, am, access_modes, access_mode, aja)
{       (attached, a)
{       (catalog_registration_attributes, cra)
{       (common_file_attributes, cfa)
{       (creation_date_time, cdt)
{       (cycle_number, cn)
{       (device_class_attributes, dca)
{       (exception_conditions, exception_condition, ec)
{       (expiration_date, ed)
{       (file_contents, file_structure, fs, file_content, fc)
{       (file_processor, fp)
{       (job_environment_attributes, jea)
{       (keyed_file_attributes, kfa)
{       (last_access_date_time, ladt)
{       (last_modification_date_time, lmdt)
{       (object_type, ot)
{       (path, p)
{       (permitted_access, application_info, ai, application_information, pa)
{       (potential_job_access, global_access_mode, gam, gsm, global_access_modes, global_share_modes, ..
{       global_share_mode, pja)
{       (presentation_file_attributes, pfa)
{       (registered, r)
{       (size, s)
{     advanced_key
{       (archive_media_information, archive_media_description, ami, archive_media_descriptor, amd)
{       (attached_external_vsn_list, aevl)
{       (attached_recorded_vsn_list, arvl)
{       (attached_transfer_size, ats)
{       (attached_vol_overflow_allowed, avoa)
{       (attached_volume_number, avn)
{       (attachment_log, al)
{       (attachment_logging_selected, als)
{       (attachment_status, as)
{       (average_record_length, arl)
{       (block_type, bt)
{       (character_conversion, cc)
{       (collate_table_name, ctn)
{       complete_path
{       (compression_procedure_name, cpn)
{       (connected_files, cf)
{       (cycle_path, cp)
{       (data_padding, dp)
{       (device_class, dc)
{       (dynamic_home_block_space, dhbs)
{       (embedded_key, ek)
{       (error_exit_procedure_name, een, error_exit_name, eepn)
{       (error_limit, el)
{       (estimated_record_count, erc)
{       (external_vsn_list, evsnl, evl)
{       (file_access_procedure_name, fap, file_access_procedure, fapn)
{       (file_label_type, flt)
{       (file_limit, fl)
{       (file_organization, fo)
{       (file_previously_opened, fpo)
{       (forced_write, fw)
{       (hashing_procedure_name, hpn)
{       (index_levels, index_level, il)
{       (index_padding, ip)
{       (initial_home_block_count, ihbc)
{       (internal_code, ic)
{       (job_file_address, global_file_address, gfa, jfa)
{       (job_file_position, global_file_position, gfp, jfp)
{       (job_instances_of_open, jioo)
{       (job_write_concurrency, jwc)
{       (key_length, kl)
{       (key_position, kp)
{       (key_type, kt)
{       (last_data_modification_time, last_data_modification_date, ldmdt, ldmd, ldmt)
{       (lifetime, permanent, l)
{       (lifetime_attachment_count, lac)
{       (line_number, ln)
{       (loading_factor, lf)
{       (lock_expiration_time, let)
{       (log_residence, lr)
{       (logging_options, lo)
{       (mainframe_attachment, ma)
{       (mainframe_write_concurrency, mwc)
{       (mass_storage_allocation_size, msas)
{       (mass_storage_bytes_allocated, msba)
{       (mass_storage_class, msc)
{       (mass_storage_free_behind, msfb)
{       (mass_storage_initial_volume, msiv)
{       (mass_storage_sequential_access, mssa)
{       (mass_storage_transfer_size, msts)
{       (maximum_block_length, maxbl)
{       (maximum_record_length, maxrl)
{       (message_control, mc)
{       (minimum_block_length, minbl)
{       (minimum_record_length, minrl)
{       (open_position, op)
{       (padding_character, pc)
{       (page_format, pf)
{       (page_length, pl)
{       (page_width, pw)
{       (preset_value, pv)
{       (private_read, pr)
{       (record_delimiting_character, rdc)
{       (record_limit, rl)
{       (record_type, rt)
{       (recorded_vsn_list, rvsnl, rvl)
{       (records_per_block, rpb)
{       (removable_media_group, rmg)
{       (retrieve_option, ro)
{       (ring_attributes, ring_attribute, ra)
{       (secondary_residence, sr)
{       (set_name, sn)
{       (shared_queue, sq)
{       (site_archive_option, sao)
{       (site_backup_option, sbo)
{       (site_release_option, sro)
{       (statement_identifier, si)
{       (tape_density, td)
{       (unique_data_name, global_file_name, gfn, udn)
{       (unique_name, un)
{       (user_information, ui)
{       (vertical_print_density, vpd)
{       (volume_overflow_allowed, voa)
{     hidden_key
{       source
{     keyend = osd$disfa_display_options, (attached, file_contents, file_processor, potential_job_access, si..
{ ze)
{   output, o: file = $output
{   password, pw: (BY_NAME, SECURE) any of
{       key
{         none
{       keyend
{       name
{     anyend = none
{   status)

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

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 10] of clt$pdt_parameter_name,
      parameters: array [1 .. 5] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 3] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$list_type_qualifier_v2,
          element_type_spec: record
            header: clt$type_specification_header,
          recend,
        recend,
      recend,
      type2: record
        header: clt$type_specification_header,
        qualifier: clt$list_type_qualifier_v2,
        element_type_spec: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 272] of clt$keyword_specification,
        recend,
        default_name: string (25),
        default_value: string (69),
      recend,
      type3: record
        header: clt$type_specification_header,
        default_value: string (7),
      recend,
      type4: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 1] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$name_type_qualifier,
        recend,
        default_value: string (4),
      recend,
      type5: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [101, 7, 3, 12, 19, 54, 403],
    clc$command, 10, 5, 1, 0, 0, 0, 5, ''], [
    ['DISPLAY_OPTION                 ',clc$alias_entry, 2],
    ['DISPLAY_OPTIONS                ',clc$nominal_entry, 2],
    ['DO                             ',clc$abbreviation_entry, 2],
    ['F                              ',clc$abbreviation_entry, 1],
    ['FILE                           ',clc$nominal_entry, 1],
    ['O                              ',clc$abbreviation_entry, 3],
    ['OUTPUT                         ',clc$nominal_entry, 3],
    ['PASSWORD                       ',clc$nominal_entry, 4],
    ['PW                             ',clc$abbreviation_entry, 4],
    ['STATUS                         ',clc$nominal_entry, 5]],
    [
{ PARAMETER 1
    [5, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 157,
  clc$required_parameter, 0, 0],
{ PARAMETER 2
    [2, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 10087,
  clc$optional_default_parameter, 25, 69],
{ PARAMETER 3
    [7, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_default_parameter, 0, 7],
{ PARAMETER 4
    [8, clc$normal_usage_entry, clc$secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 69,
  clc$optional_default_parameter, 0, 4],
{ PARAMETER 5
    [10, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$union_type], [[clc$keyword_type, clc$list_type],
    FALSE, 2],
    118, [[1, 0, clc$keyword_type], [3], [
      ['SDV                            ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
      ['SYSTEM_DEFAULT_VALUE           ', clc$alias_entry, clc$normal_usage_entry, 1],
      ['SYSTEM_DEFAULT_VALUES          ', clc$nominal_entry, clc$normal_usage_entry, 1]]
      ],
    19, [[1, 0, clc$list_type], [3, 1, clc$max_list_size, 0, FALSE, FALSE],
        [[1, 0, clc$file_type]]
      ]
    ],
{ PARAMETER 2
    [[1, 0, clc$list_type], [10071, 1, clc$max_list_size, 0, FALSE, FALSE],
      [[1, 0, clc$keyword_type], [272], [
      ['A                              ', clc$abbreviation_entry, clc$normal_usage_entry, 5],
      ['ACCESS_CONTROL_LIST            ', clc$nominal_entry, clc$normal_usage_entry, 2],
      ['ACCESS_MODE                    ', clc$alias_entry, clc$normal_usage_entry, 4],
      ['ACCESS_MODES                   ', clc$alias_entry, clc$normal_usage_entry, 4],
      ['ACCOUNT_PROJECT                ', clc$nominal_entry, clc$normal_usage_entry, 3],
      ['ACL                            ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
      ['ACTUAL_JOB_ACCESS              ', clc$nominal_entry, clc$normal_usage_entry, 4],
      ['AEVL                           ', clc$abbreviation_entry, clc$advanced_usage_entry, 27],
      ['AI                             ', clc$alias_entry, clc$normal_usage_entry, 21],
      ['AJA                            ', clc$abbreviation_entry, clc$normal_usage_entry, 4],
      ['AL                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 32],
      ['ALL                            ', clc$nominal_entry, clc$normal_usage_entry, 1],
      ['ALS                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 33],
      ['AM                             ', clc$alias_entry, clc$normal_usage_entry, 4],
      ['AMD                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 26],
      ['AMI                            ', clc$alias_entry, clc$advanced_usage_entry, 26],
      ['AP                             ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
      ['APPLICATION_INFO               ', clc$alias_entry, clc$normal_usage_entry, 21],
      ['APPLICATION_INFORMATION        ', clc$alias_entry, clc$normal_usage_entry, 21],
      ['ARCHIVE_MEDIA_DESCRIPTION      ', clc$alias_entry, clc$advanced_usage_entry, 26],
      ['ARCHIVE_MEDIA_DESCRIPTOR       ', clc$alias_entry, clc$advanced_usage_entry, 26],
      ['ARCHIVE_MEDIA_INFORMATION      ', clc$nominal_entry, clc$advanced_usage_entry, 26],
      ['ARL                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 35],
      ['ARVL                           ', clc$abbreviation_entry, clc$advanced_usage_entry, 28],
      ['AS                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 34],
      ['ATS                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 29],
      ['ATTACHED                       ', clc$nominal_entry, clc$normal_usage_entry, 5],
      ['ATTACHED_EXTERNAL_VSN_LIST     ', clc$nominal_entry, clc$advanced_usage_entry, 27],
      ['ATTACHED_RECORDED_VSN_LIST     ', clc$nominal_entry, clc$advanced_usage_entry, 28],
      ['ATTACHED_TRANSFER_SIZE         ', clc$nominal_entry, clc$advanced_usage_entry, 29],
      ['ATTACHED_VOLUME_NUMBER         ', clc$nominal_entry, clc$advanced_usage_entry, 31],
      ['ATTACHED_VOL_OVERFLOW_ALLOWED  ', clc$nominal_entry, clc$advanced_usage_entry, 30],
      ['ATTACHMENT_LOG                 ', clc$nominal_entry, clc$advanced_usage_entry, 32],
      ['ATTACHMENT_LOGGING_SELECTED    ', clc$nominal_entry, clc$advanced_usage_entry, 33],
      ['ATTACHMENT_STATUS              ', clc$nominal_entry, clc$advanced_usage_entry, 34],
      ['AVERAGE_RECORD_LENGTH          ', clc$nominal_entry, clc$advanced_usage_entry, 35],
      ['AVN                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 31],
      ['AVOA                           ', clc$abbreviation_entry, clc$advanced_usage_entry, 30],
      ['BLOCK_TYPE                     ', clc$nominal_entry, clc$advanced_usage_entry, 36],
      ['BT                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 36],
      ['CATALOG_REGISTRATION_ATTRIBUTES', clc$nominal_entry, clc$normal_usage_entry, 6],
      ['CC                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 37],
      ['CDT                            ', clc$abbreviation_entry, clc$normal_usage_entry, 8],
      ['CF                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 41],
      ['CFA                            ', clc$abbreviation_entry, clc$normal_usage_entry, 7],
      ['CHARACTER_CONVERSION           ', clc$nominal_entry, clc$advanced_usage_entry, 37],
      ['CN                             ', clc$abbreviation_entry, clc$normal_usage_entry, 9],
      ['COLLATE_TABLE_NAME             ', clc$nominal_entry, clc$advanced_usage_entry, 38],
      ['COMMON_FILE_ATTRIBUTES         ', clc$nominal_entry, clc$normal_usage_entry, 7],
      ['COMPLETE_PATH                  ', clc$nominal_entry, clc$advanced_usage_entry, 39],
      ['COMPRESSION_PROCEDURE_NAME     ', clc$nominal_entry, clc$advanced_usage_entry, 40],
      ['CONNECTED_FILES                ', clc$nominal_entry, clc$advanced_usage_entry, 41],
      ['CP                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 42],
      ['CPN                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 40],
      ['CRA                            ', clc$abbreviation_entry, clc$normal_usage_entry, 6],
      ['CREATION_DATE_TIME             ', clc$nominal_entry, clc$normal_usage_entry, 8],
      ['CTN                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 38],
      ['CYCLE_NUMBER                   ', clc$nominal_entry, clc$normal_usage_entry, 9],
      ['CYCLE_PATH                     ', clc$nominal_entry, clc$advanced_usage_entry, 42],
      ['DATA_PADDING                   ', clc$nominal_entry, clc$advanced_usage_entry, 43],
      ['DC                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 44],
      ['DCA                            ', clc$abbreviation_entry, clc$normal_usage_entry, 10],
      ['DEVICE_CLASS                   ', clc$nominal_entry, clc$advanced_usage_entry, 44],
      ['DEVICE_CLASS_ATTRIBUTES        ', clc$nominal_entry, clc$normal_usage_entry, 10],
      ['DHBS                           ', clc$abbreviation_entry, clc$advanced_usage_entry, 45],
      ['DP                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 43],
      ['DYNAMIC_HOME_BLOCK_SPACE       ', clc$nominal_entry, clc$advanced_usage_entry, 45],
      ['EC                             ', clc$abbreviation_entry, clc$normal_usage_entry, 11],
      ['ED                             ', clc$abbreviation_entry, clc$normal_usage_entry, 12],
      ['EEN                            ', clc$alias_entry, clc$advanced_usage_entry, 47],
      ['EEPN                           ', clc$abbreviation_entry, clc$advanced_usage_entry, 47],
      ['EK                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 46],
      ['EL                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 48],
      ['EMBEDDED_KEY                   ', clc$nominal_entry, clc$advanced_usage_entry, 46],
      ['ERC                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 49],
      ['ERROR_EXIT_NAME                ', clc$alias_entry, clc$advanced_usage_entry, 47],
      ['ERROR_EXIT_PROCEDURE_NAME      ', clc$nominal_entry, clc$advanced_usage_entry, 47],
      ['ERROR_LIMIT                    ', clc$nominal_entry, clc$advanced_usage_entry, 48],
      ['ESTIMATED_RECORD_COUNT         ', clc$nominal_entry, clc$advanced_usage_entry, 49],
      ['EVL                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 50],
      ['EVSNL                          ', clc$alias_entry, clc$advanced_usage_entry, 50],
      ['EXCEPTION_CONDITION            ', clc$alias_entry, clc$normal_usage_entry, 11],
      ['EXCEPTION_CONDITIONS           ', clc$nominal_entry, clc$normal_usage_entry, 11],
      ['EXPIRATION_DATE                ', clc$nominal_entry, clc$normal_usage_entry, 12],
      ['EXTERNAL_VSN_LIST              ', clc$nominal_entry, clc$advanced_usage_entry, 50],
      ['FAP                            ', clc$alias_entry, clc$advanced_usage_entry, 51],
      ['FAPN                           ', clc$abbreviation_entry, clc$advanced_usage_entry, 51],
      ['FC                             ', clc$abbreviation_entry, clc$normal_usage_entry, 13],
      ['FILE_ACCESS_PROCEDURE          ', clc$alias_entry, clc$advanced_usage_entry, 51],
      ['FILE_ACCESS_PROCEDURE_NAME     ', clc$nominal_entry, clc$advanced_usage_entry, 51],
      ['FILE_CONTENT                   ', clc$alias_entry, clc$normal_usage_entry, 13],
      ['FILE_CONTENTS                  ', clc$nominal_entry, clc$normal_usage_entry, 13],
      ['FILE_LABEL_TYPE                ', clc$nominal_entry, clc$advanced_usage_entry, 52],
      ['FILE_LIMIT                     ', clc$nominal_entry, clc$advanced_usage_entry, 53],
      ['FILE_ORGANIZATION              ', clc$nominal_entry, clc$advanced_usage_entry, 54],
      ['FILE_PREVIOUSLY_OPENED         ', clc$nominal_entry, clc$advanced_usage_entry, 55],
      ['FILE_PROCESSOR                 ', clc$nominal_entry, clc$normal_usage_entry, 14],
      ['FILE_STRUCTURE                 ', clc$alias_entry, clc$normal_usage_entry, 13],
      ['FL                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 53],
      ['FLT                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 52],
      ['FO                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 54],
      ['FORCED_WRITE                   ', clc$nominal_entry, clc$advanced_usage_entry, 56],
      ['FP                             ', clc$abbreviation_entry, clc$normal_usage_entry, 14],
      ['FPO                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 55],
      ['FS                             ', clc$alias_entry, clc$normal_usage_entry, 13],
      ['FW                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 56],
      ['GAM                            ', clc$alias_entry, clc$normal_usage_entry, 22],
      ['GFA                            ', clc$alias_entry, clc$advanced_usage_entry, 62],
      ['GFN                            ', clc$alias_entry, clc$advanced_usage_entry, 114],
      ['GFP                            ', clc$alias_entry, clc$advanced_usage_entry, 63],
      ['GLOBAL_ACCESS_MODE             ', clc$alias_entry, clc$normal_usage_entry, 22],
      ['GLOBAL_ACCESS_MODES            ', clc$alias_entry, clc$normal_usage_entry, 22],
      ['GLOBAL_FILE_ADDRESS            ', clc$alias_entry, clc$advanced_usage_entry, 62],
      ['GLOBAL_FILE_NAME               ', clc$alias_entry, clc$advanced_usage_entry, 114],
      ['GLOBAL_FILE_POSITION           ', clc$alias_entry, clc$advanced_usage_entry, 63],
      ['GLOBAL_SHARE_MODE              ', clc$alias_entry, clc$normal_usage_entry, 22],
      ['GLOBAL_SHARE_MODES             ', clc$alias_entry, clc$normal_usage_entry, 22],
      ['GSM                            ', clc$alias_entry, clc$normal_usage_entry, 22],
      ['HASHING_PROCEDURE_NAME         ', clc$nominal_entry, clc$advanced_usage_entry, 57],
      ['HPN                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 57],
      ['IC                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 61],
      ['IHBC                           ', clc$abbreviation_entry, clc$advanced_usage_entry, 60],
      ['IL                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 58],
      ['INDEX_LEVEL                    ', clc$alias_entry, clc$advanced_usage_entry, 58],
      ['INDEX_LEVELS                   ', clc$nominal_entry, clc$advanced_usage_entry, 58],
      ['INDEX_PADDING                  ', clc$nominal_entry, clc$advanced_usage_entry, 59],
      ['INITIAL_HOME_BLOCK_COUNT       ', clc$nominal_entry, clc$advanced_usage_entry, 60],
      ['INTERNAL_CODE                  ', clc$nominal_entry, clc$advanced_usage_entry, 61],
      ['IP                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 59],
      ['JEA                            ', clc$abbreviation_entry, clc$normal_usage_entry, 15],
      ['JFA                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 62],
      ['JFP                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 63],
      ['JIOO                           ', clc$abbreviation_entry, clc$advanced_usage_entry, 64],
      ['JOB_ENVIRONMENT_ATTRIBUTES     ', clc$nominal_entry, clc$normal_usage_entry, 15],
      ['JOB_FILE_ADDRESS               ', clc$nominal_entry, clc$advanced_usage_entry, 62],
      ['JOB_FILE_POSITION              ', clc$nominal_entry, clc$advanced_usage_entry, 63],
      ['JOB_INSTANCES_OF_OPEN          ', clc$nominal_entry, clc$advanced_usage_entry, 64],
      ['JOB_WRITE_CONCURRENCY          ', clc$nominal_entry, clc$advanced_usage_entry, 65],
      ['JWC                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 65],
      ['KEYED_FILE_ATTRIBUTES          ', clc$nominal_entry, clc$normal_usage_entry, 16],
      ['KEY_LENGTH                     ', clc$nominal_entry, clc$advanced_usage_entry, 66],
      ['KEY_POSITION                   ', clc$nominal_entry, clc$advanced_usage_entry, 67],
      ['KEY_TYPE                       ', clc$nominal_entry, clc$advanced_usage_entry, 68],
      ['KFA                            ', clc$abbreviation_entry, clc$normal_usage_entry, 16],
      ['KL                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 66],
      ['KP                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 67],
      ['KT                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 68],
      ['L                              ', clc$abbreviation_entry, clc$advanced_usage_entry, 70],
      ['LAC                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 71],
      ['LADT                           ', clc$abbreviation_entry, clc$normal_usage_entry, 17],
      ['LAST_ACCESS_DATE_TIME          ', clc$nominal_entry, clc$normal_usage_entry, 17],
      ['LAST_DATA_MODIFICATION_DATE    ', clc$alias_entry, clc$advanced_usage_entry, 69],
      ['LAST_DATA_MODIFICATION_TIME    ', clc$nominal_entry, clc$advanced_usage_entry, 69],
      ['LAST_MODIFICATION_DATE_TIME    ', clc$nominal_entry, clc$normal_usage_entry, 18],
      ['LDMD                           ', clc$alias_entry, clc$advanced_usage_entry, 69],
      ['LDMDT                          ', clc$alias_entry, clc$advanced_usage_entry, 69],
      ['LDMT                           ', clc$abbreviation_entry, clc$advanced_usage_entry, 69],
      ['LET                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 74],
      ['LF                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 73],
      ['LIFETIME                       ', clc$nominal_entry, clc$advanced_usage_entry, 70],
      ['LIFETIME_ATTACHMENT_COUNT      ', clc$nominal_entry, clc$advanced_usage_entry, 71],
      ['LINE_NUMBER                    ', clc$nominal_entry, clc$advanced_usage_entry, 72],
      ['LMDT                           ', clc$abbreviation_entry, clc$normal_usage_entry, 18],
      ['LN                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 72],
      ['LO                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 76],
      ['LOADING_FACTOR                 ', clc$nominal_entry, clc$advanced_usage_entry, 73],
      ['LOCK_EXPIRATION_TIME           ', clc$nominal_entry, clc$advanced_usage_entry, 74],
      ['LOGGING_OPTIONS                ', clc$nominal_entry, clc$advanced_usage_entry, 76],
      ['LOG_RESIDENCE                  ', clc$nominal_entry, clc$advanced_usage_entry, 75],
      ['LR                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 75],
      ['MA                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 77],
      ['MAINFRAME_ATTACHMENT           ', clc$nominal_entry, clc$advanced_usage_entry, 77],
      ['MAINFRAME_WRITE_CONCURRENCY    ', clc$nominal_entry, clc$advanced_usage_entry, 78],
      ['MASS_STORAGE_ALLOCATION_SIZE   ', clc$nominal_entry, clc$advanced_usage_entry, 79],
      ['MASS_STORAGE_BYTES_ALLOCATED   ', clc$nominal_entry, clc$advanced_usage_entry, 80],
      ['MASS_STORAGE_CLASS             ', clc$nominal_entry, clc$advanced_usage_entry, 81],
      ['MASS_STORAGE_FREE_BEHIND       ', clc$nominal_entry, clc$advanced_usage_entry, 82],
      ['MASS_STORAGE_INITIAL_VOLUME    ', clc$nominal_entry, clc$advanced_usage_entry, 83],
      ['MASS_STORAGE_SEQUENTIAL_ACCESS ', clc$nominal_entry, clc$advanced_usage_entry, 84],
      ['MASS_STORAGE_TRANSFER_SIZE     ', clc$nominal_entry, clc$advanced_usage_entry, 85],
      ['MAXBL                          ', clc$abbreviation_entry, clc$advanced_usage_entry, 86],
      ['MAXIMUM_BLOCK_LENGTH           ', clc$nominal_entry, clc$advanced_usage_entry, 86],
      ['MAXIMUM_RECORD_LENGTH          ', clc$nominal_entry, clc$advanced_usage_entry, 87],
      ['MAXRL                          ', clc$abbreviation_entry, clc$advanced_usage_entry, 87],
      ['MC                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 88],
      ['MESSAGE_CONTROL                ', clc$nominal_entry, clc$advanced_usage_entry, 88],
      ['MINBL                          ', clc$abbreviation_entry, clc$advanced_usage_entry, 89],
      ['MINIMUM_BLOCK_LENGTH           ', clc$nominal_entry, clc$advanced_usage_entry, 89],
      ['MINIMUM_RECORD_LENGTH          ', clc$nominal_entry, clc$advanced_usage_entry, 90],
      ['MINRL                          ', clc$abbreviation_entry, clc$advanced_usage_entry, 90],
      ['MSAS                           ', clc$abbreviation_entry, clc$advanced_usage_entry, 79],
      ['MSBA                           ', clc$abbreviation_entry, clc$advanced_usage_entry, 80],
      ['MSC                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 81],
      ['MSFB                           ', clc$abbreviation_entry, clc$advanced_usage_entry, 82],
      ['MSIV                           ', clc$abbreviation_entry, clc$advanced_usage_entry, 83],
      ['MSSA                           ', clc$abbreviation_entry, clc$advanced_usage_entry, 84],
      ['MSTS                           ', clc$abbreviation_entry, clc$advanced_usage_entry, 85],
      ['MWC                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 78],
      ['OBJECT_TYPE                    ', clc$nominal_entry, clc$normal_usage_entry, 19],
      ['OP                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 91],
      ['OPEN_POSITION                  ', clc$nominal_entry, clc$advanced_usage_entry, 91],
      ['OT                             ', clc$abbreviation_entry, clc$normal_usage_entry, 19],
      ['P                              ', clc$abbreviation_entry, clc$normal_usage_entry, 20],
      ['PA                             ', clc$abbreviation_entry, clc$normal_usage_entry, 21],
      ['PADDING_CHARACTER              ', clc$nominal_entry, clc$advanced_usage_entry, 92],
      ['PAGE_FORMAT                    ', clc$nominal_entry, clc$advanced_usage_entry, 93],
      ['PAGE_LENGTH                    ', clc$nominal_entry, clc$advanced_usage_entry, 94],
      ['PAGE_WIDTH                     ', clc$nominal_entry, clc$advanced_usage_entry, 95],
      ['PATH                           ', clc$nominal_entry, clc$normal_usage_entry, 20],
      ['PC                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 92],
      ['PERMANENT                      ', clc$alias_entry, clc$advanced_usage_entry, 70],
      ['PERMITTED_ACCESS               ', clc$nominal_entry, clc$normal_usage_entry, 21],
      ['PF                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 93],
      ['PFA                            ', clc$abbreviation_entry, clc$normal_usage_entry, 23],
      ['PJA                            ', clc$abbreviation_entry, clc$normal_usage_entry, 22],
      ['PL                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 94],
      ['POTENTIAL_JOB_ACCESS           ', clc$nominal_entry, clc$normal_usage_entry, 22],
      ['PR                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 97],
      ['PRESENTATION_FILE_ATTRIBUTES   ', clc$nominal_entry, clc$normal_usage_entry, 23],
      ['PRESET_VALUE                   ', clc$nominal_entry, clc$advanced_usage_entry, 96],
      ['PRIVATE_READ                   ', clc$nominal_entry, clc$advanced_usage_entry, 97],
      ['PV                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 96],
      ['PW                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 95],
      ['R                              ', clc$abbreviation_entry, clc$normal_usage_entry, 24],
      ['RA                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 105],
      ['RDC                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 98],
      ['RECORDED_VSN_LIST              ', clc$nominal_entry, clc$advanced_usage_entry, 101],
      ['RECORDS_PER_BLOCK              ', clc$nominal_entry, clc$advanced_usage_entry, 102],
      ['RECORD_DELIMITING_CHARACTER    ', clc$nominal_entry, clc$advanced_usage_entry, 98],
      ['RECORD_LIMIT                   ', clc$nominal_entry, clc$advanced_usage_entry, 99],
      ['RECORD_TYPE                    ', clc$nominal_entry, clc$advanced_usage_entry, 100],
      ['REGISTERED                     ', clc$nominal_entry, clc$normal_usage_entry, 24],
      ['REMOVABLE_MEDIA_GROUP          ', clc$nominal_entry, clc$advanced_usage_entry, 103],
      ['RETRIEVE_OPTION                ', clc$nominal_entry, clc$advanced_usage_entry, 104],
      ['RING_ATTRIBUTE                 ', clc$alias_entry, clc$advanced_usage_entry, 105],
      ['RING_ATTRIBUTES                ', clc$nominal_entry, clc$advanced_usage_entry, 105],
      ['RL                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 99],
      ['RMG                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 103],
      ['RO                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 104],
      ['RPB                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 102],
      ['RT                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 100],
      ['RVL                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 101],
      ['RVSNL                          ', clc$alias_entry, clc$advanced_usage_entry, 101],
      ['S                              ', clc$abbreviation_entry, clc$normal_usage_entry, 25],
      ['SAO                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 109],
      ['SBO                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 110],
      ['SECONDARY_RESIDENCE            ', clc$nominal_entry, clc$advanced_usage_entry, 106],
      ['SET_NAME                       ', clc$nominal_entry, clc$advanced_usage_entry, 107],
      ['SHARED_QUEUE                   ', clc$nominal_entry, clc$advanced_usage_entry, 108],
      ['SI                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 112],
      ['SITE_ARCHIVE_OPTION            ', clc$nominal_entry, clc$advanced_usage_entry, 109],
      ['SITE_BACKUP_OPTION             ', clc$nominal_entry, clc$advanced_usage_entry, 110],
      ['SITE_RELEASE_OPTION            ', clc$nominal_entry, clc$advanced_usage_entry, 111],
      ['SIZE                           ', clc$nominal_entry, clc$normal_usage_entry, 25],
      ['SN                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 107],
      ['SOURCE                         ', clc$nominal_entry, clc$hidden_entry, 119],
      ['SQ                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 108],
      ['SR                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 106],
      ['SRO                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 111],
      ['STATEMENT_IDENTIFIER           ', clc$nominal_entry, clc$advanced_usage_entry, 112],
      ['TAPE_DENSITY                   ', clc$nominal_entry, clc$advanced_usage_entry, 113],
      ['TD                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 113],
      ['UDN                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 114],
      ['UI                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 116],
      ['UN                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 115],
      ['UNIQUE_DATA_NAME               ', clc$nominal_entry, clc$advanced_usage_entry, 114],
      ['UNIQUE_NAME                    ', clc$nominal_entry, clc$advanced_usage_entry, 115],
      ['USER_INFORMATION               ', clc$nominal_entry, clc$advanced_usage_entry, 116],
      ['VERTICAL_PRINT_DENSITY         ', clc$nominal_entry, clc$advanced_usage_entry, 117],
      ['VOA                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 118],
      ['VOLUME_OVERFLOW_ALLOWED        ', clc$nominal_entry, clc$advanced_usage_entry, 118],
      ['VPD                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 117]]
      ]
    ,
    'OSD$DISFA_DISPLAY_OPTIONS',
    '(attached, file_contents, file_processor, potential_job_access, size)'],
{ PARAMETER 3
    [[1, 0, clc$file_type],
    '$output'],
{ PARAMETER 4
    [[1, 0, clc$union_type], [[clc$keyword_type, clc$name_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['NONE                           ', clc$nominal_entry, clc$normal_usage_entry, 1]]
      ],
    5, [[1, 0, clc$name_type], [1, osc$max_name_size]]
    ,
    'none'],
{ PARAMETER 5
    [[1, 0, clc$status_type]]];

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

    CONST
      p$file = 1,
      p$display_options = 2,
      p$output = 3,
      p$password = 4,
      p$status = 5;

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

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

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

      VAR
        ignore_status: ost$status;

      clp$close_display (display_control, ignore_status);

    PROCEND abort_handler;

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

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


      IF pvt [p$file].value^.kind = clc$keyword THEN
        clp$put_partial_display (display_control, 'System Default Values:', clc$trim, amc$terminate, status);
      ELSE
        clv$subtitles_built := FALSE;
        clp$put_path_reference_subtitle (current_file^.element_value^.file_value^, 'FILE ', status);
      IFEND;

    PROCEND put_subtitle;
?? OLDTITLE, EJECT ??

    CONST
      remote_path_prefix = ':$LOCAL.',
      remote_path_prefix_size = 8,
      remote_path_size = remote_path_prefix_size + osc$max_name_size;

    VAR
      all_requested: boolean,
      attrib_work_area_p: ^SEQ ( * ),
      attributes_requested: file_attribute_keys,
      block: ^clt$block,
      caller_id: ost$caller_identifier,
      current_file: ^clt$data_value,
      default_ring_attributes: amt$ring_attributes,
      display_control: clt$display_control,
      evaluated_file_reference: fst$evaluated_file_reference,
      family_name: ost$family_name,
      information_request: fst$goi_information_request,
      local_status: ost$status,
      number_of_requested_attributes: object_type_counts,
      object_info_work_area: ^SEQ ( * ),
      remote: boolean,
      remote_parameters: array [1 .. 2] of clt$parameter_substitution,
      remote_path: string (remote_path_size),
      representation: ^clt$data_representation,
      result: ^clt$data_value,
      scratch_segment: amt$segment_pointer,
      source_requested: boolean,
      unique_name: ost$name,
      validation_criteria: ^fst$goi_validation_criteria,
      work_area: ^^clt$work_area;

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

    clp$evaluate_file_reference (pvt [p$output].value^.file_value^, $clt$file_ref_parsing_options [], FALSE,
          evaluated_file_reference, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    family_name := fsp$path_element (^evaluated_file_reference, 1) ^;

    nfp$check_implicit_access (family_name, remote, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF remote THEN
      osp$set_status_abnormal (nfc$status_id, nfe$display_output_remote, 'DISPLAY_FILE_ATTRIBUTES', status);
      RETURN; {----->
    IFEND;

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

    #CALLER_ID (caller_id);

    determine_attributes_requested (pvt [p$display_options].value, attributes_requested,
          number_of_requested_attributes, all_requested, source_requested);

    information_request := initial_information_request;
    determine_object_info_requests (attributes_requested, information_request.object_information_requests);

  /form_file_attribute_display/
    BEGIN
      mmp$create_scratch_segment (amc$sequence_pointer, mmc$as_sequential, scratch_segment, status);
      IF NOT status.normal THEN
        EXIT /form_file_attribute_display/; {----->
      IFEND;

      attrib_work_area_p := scratch_segment.sequence_pointer;
      default_ring_attributes.r1 := #RING (^default_ring_attributes);
      default_ring_attributes.r2 := #RING (^default_ring_attributes);
      default_ring_attributes.r3 := #RING (^default_ring_attributes);
      clp$open_display_reference (pvt [p$output].value^.file_value^, ^clp$new_page_procedure, fsc$list,
            default_ring_attributes, display_control, status);
      IF NOT status.normal THEN
        EXIT /form_file_attribute_display/; {----->
      IFEND;
      clv$titles_built := FALSE;
      clv$command_name := 'DISPLAY_FILE_ATTRIBUTES';

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

      IF pvt [p$file].value^.kind = clc$keyword THEN { system_default_values }
        object_info_work_area := NIL;
        process_object_information (fsv$evaluated_file_reference, caller_id.ring, {validation_criteria} NIL,
              all_requested, source_requested, number_of_requested_attributes, attributes_requested,
              object_info_work_area, attrib_work_area_p, result, status);
        IF NOT status.normal THEN
          EXIT /form_file_attribute_display/; {----->
        IFEND;

        IF (display_control.page_format = amc$burstable_form) OR
              (display_control.page_format = amc$non_burstable_form) THEN
          clp$new_display_page (display_control, status);
          IF NOT status.normal THEN
            EXIT /form_file_attribute_display/; {----->
          IFEND;
        IFEND;

        WHILE result <> NIL DO
          clp$convert_data_to_string (result^.element_value, clc$labeled_elem_representation,
                display_control.page_width, attrib_work_area_p, representation, status);
          IF NOT status.normal THEN
            EXIT /form_file_attribute_display/; {----->
          IFEND;
          clp$put_data_representation (display_control, representation, status);
          IF NOT status.normal THEN
            EXIT /form_file_attribute_display/; {----->
          IFEND;
          result := result^.link;
          IF result <> NIL THEN
            clp$new_display_line (display_control, 1, status);
            IF NOT status.normal THEN
              EXIT /form_file_attribute_display/; {----->
            IFEND;
          IFEND;
        WHILEND;

      ELSE
        IF (pvt [p$password].specified) AND (pvt [p$password].value^.kind = clc$name) THEN
          PUSH validation_criteria: [1 .. 1];
          validation_criteria^ [1].validation_selection := fsc$goi_password;
          validation_criteria^ [1].password := pvt [p$password].value^.name_value;
        ELSE
          validation_criteria := NIL;
        IFEND;

        block := NIL;
        current_file := pvt [p$file].value;

      /process_file_list/
        WHILE current_file <> NIL DO
          clp$evaluate_file_reference (current_file^.element_value^.file_value^,
                $clt$file_ref_parsing_options [], FALSE, evaluated_file_reference, status);
          IF NOT status.normal THEN
            EXIT /form_file_attribute_display/; {----->
          IFEND;

          family_name := fsp$path_element (^evaluated_file_reference, 1) ^;

          nfp$check_implicit_access (family_name, remote, status);
          IF NOT status.normal THEN
            EXIT /form_file_attribute_display/; {----->
          IFEND;

          IF remote THEN
            IF block = NIL THEN
              clp$find_current_block (block);

              clp$get_work_area (#RING (^work_area), work_area, status);
              IF NOT status.normal THEN
                EXIT /form_file_attribute_display/; {----->
              IFEND;

              pmp$get_unique_name (unique_name, status);
              IF NOT status.normal THEN
                EXIT /form_file_attribute_display/; {----->
              IFEND;

              remote_path (1, remote_path_prefix_size) := remote_path_prefix;
              remote_path (remote_path_prefix_size + 1, osc$max_name_size) := unique_name;
              remote_parameters [1].text := ^remote_path;
              remote_parameters [1].name := 'OUTPUT';
              remote_parameters [2].name := 'STATUS';
              remote_parameters [2].text := NIL;
            IFEND;

            nfp$perform_implicit_access (family_name, pvt [p$output].value^.file_value^, remote_path,
                  nfc$give, 'DISPLAY_FILE_ATTRIBUTES', block^.parameters.unbundled_pdt, ^pvt,
                  ^remote_parameters, work_area^, status);
            IF NOT status.normal THEN
              EXIT /form_file_attribute_display/; {----->
            IFEND;
            current_file := current_file^.link;
            CYCLE /process_file_list/; {----->
          IFEND;

          object_info_work_area := attrib_work_area_p;

          get_object_information (evaluated_file_reference, information_request, validation_criteria,
                object_info_work_area, status);
          IF NOT status.normal AND NOT status_condition_ignorable
                (status.condition, attributes_requested, evaluated_file_reference) THEN
            EXIT /form_file_attribute_display/; {----->
          ELSE
            process_object_information (evaluated_file_reference, caller_id.ring, validation_criteria,
                  all_requested, source_requested, number_of_requested_attributes, attributes_requested,
                  attrib_work_area_p, object_info_work_area, result, status);
            IF NOT status.normal THEN
              IF status.condition = fse$attributes_not_defined THEN
                osp$append_status_file (osc$status_parameter_delimiter,
                      current_file^.element_value^.file_value^, status);
              IFEND;
              EXIT /form_file_attribute_display/; {----->
            IFEND;
          IFEND;

          IF (display_control.page_format = amc$burstable_form) OR
                (display_control.page_format = amc$non_burstable_form) THEN
            clp$new_display_page (display_control, status);
            IF NOT status.normal THEN
              EXIT /form_file_attribute_display/; {----->
            IFEND;
          ELSEIF current_file <> pvt [p$file].value THEN
            clp$new_display_line (display_control, 2, status);
            IF NOT status.normal THEN
              EXIT /form_file_attribute_display/; {----->
            IFEND;
          IFEND;
          IF pvt [p$file].value^.link <> NIL THEN
            put_subtitle (display_control, status);
            IF NOT status.normal THEN
              EXIT /form_file_attribute_display/; {----->
            IFEND;
            clp$new_display_line (display_control, 1, status);
            IF NOT status.normal THEN
              EXIT /form_file_attribute_display/; {----->
            IFEND;
          IFEND;

          WHILE result <> NIL DO
            clp$convert_data_to_string (result^.element_value, clc$labeled_elem_representation,
                  display_control.page_width, object_info_work_area, representation, status);
            IF NOT status.normal THEN
              EXIT /form_file_attribute_display/; {----->
            IFEND;

            clp$put_data_representation (display_control, representation, status);
            result := result^.link;
            IF result <> NIL THEN
              clp$new_display_line (display_control, 1, status);
              IF NOT status.normal THEN
                EXIT /form_file_attribute_display/; {----->
              IFEND;
            IFEND;
          WHILEND;

          current_file := current_file^.link;
        WHILEND /process_file_list/;
      IFEND;
      mmp$delete_scratch_segment (scratch_segment, status);
    END /form_file_attribute_display/;

    IF display_control.file_id <> amv$nil_file_identifier THEN
      clp$close_display (display_control, local_status);
      IF status.normal AND (NOT local_status.normal) THEN
        status := local_status;
      IFEND;
    IFEND;

    osp$disestablish_cond_handler;

  PROCEND clp$_display_file_attributes;
?? TITLE := 'clp$$file', EJECT ??

  PROCEDURE [XDCL] clp$$file
    (    parameter_list: clt$parameter_list;
     VAR work_area {input output} : ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);

{  FUNCTION (osm$$file) $file (
{    file: file = $required
{    attribute: key
{        (application_information, ai)
{        (assigned, a)
{        attached
{        (catalog, c)
{        (cycle_number, cn)
{        (device_class, dc)
{        (file_contents, file_content, fc)
{        (file_label_type, flt)
{        (file_organization, fo)
{        (file_processor, fp)
{        (file_structure, fs)
{        (global_file_position, gfp)
{        (opened, o)
{        (open_position, op)
{        (permanent, p)
{        (resolved_path, rp)
{        (size, s)
{        (temporary, t)
{        (user_information, ui)
{      keyend = $required
{    )

?? PUSH (LISTEXT := ON) ??

    VAR
      pdt: [STATIC, READ, cls$declaration_section] record
        header: clt$pdt_header,
        names: array [1 .. 2] of clt$pdt_parameter_name,
        parameters: array [1 .. 2] of clt$pdt_parameter,
        type1: record
          header: clt$type_specification_header,
        recend,
        type2: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 38] of clt$keyword_specification,
        recend,
      recend := [[1, [88, 8, 8, 8, 41, 17, 615], clc$function, 2, 2, 2, 0, 0, 0, 0, 'OSM$$FILE'],
            [['ATTRIBUTE                      ', clc$nominal_entry, 2],
            ['FILE                           ', clc$nominal_entry, 1]], [

{ PARAMETER 1

      [2, clc$normal_usage_entry, clc$non_secure_parameter,
            $clt$parameter_spec_methods [clc$specify_positionally], clc$pass_by_value,
            clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$required_parameter, 0, 0],

{ PARAMETER 2

      [1, clc$normal_usage_entry, clc$non_secure_parameter,
            $clt$parameter_spec_methods [clc$specify_positionally], clc$pass_by_value,
            clc$immediate_evaluation, clc$standard_parameter_checking, 1413, clc$required_parameter, 0, 0]],

{ PARAMETER 1

      [[1, 0, clc$file_type]],

{ PARAMETER 2

      [[1, 0, clc$keyword_type], [38], [['A                              ', clc$abbreviation_entry,
            clc$normal_usage_entry, 2], ['AI                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 1], ['APPLICATION_INFORMATION        ', clc$nominal_entry,
            clc$normal_usage_entry, 1], ['ASSIGNED                       ', clc$nominal_entry,
            clc$normal_usage_entry, 2], ['ATTACHED                       ', clc$nominal_entry,
            clc$normal_usage_entry, 3], ['C                              ', clc$abbreviation_entry,
            clc$normal_usage_entry, 4], ['CATALOG                        ', clc$nominal_entry,
            clc$normal_usage_entry, 4], ['CN                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 5], ['CYCLE_NUMBER                   ', clc$nominal_entry,
            clc$normal_usage_entry, 5], ['DC                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 6], ['DEVICE_CLASS                   ', clc$nominal_entry,
            clc$normal_usage_entry, 6], ['FC                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 7], ['FILE_CONTENT                   ', clc$alias_entry,
            clc$normal_usage_entry, 7], ['FILE_CONTENTS                  ', clc$nominal_entry,
            clc$normal_usage_entry, 7], ['FILE_LABEL_TYPE                ', clc$nominal_entry,
            clc$normal_usage_entry, 8], ['FILE_ORGANIZATION              ', clc$nominal_entry,
            clc$normal_usage_entry, 9], ['FILE_PROCESSOR                 ', clc$nominal_entry,
            clc$normal_usage_entry, 10], ['FILE_STRUCTURE                 ', clc$nominal_entry,
            clc$normal_usage_entry, 11], ['FLT                            ', clc$abbreviation_entry,
            clc$normal_usage_entry, 8], ['FO                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 9], ['FP                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 10], ['FS                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 11], ['GFP                            ', clc$abbreviation_entry,
            clc$normal_usage_entry, 12], ['GLOBAL_FILE_POSITION           ', clc$nominal_entry,
            clc$normal_usage_entry, 12], ['O                              ', clc$abbreviation_entry,
            clc$normal_usage_entry, 13], ['OP                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 14], ['OPENED                         ', clc$nominal_entry,
            clc$normal_usage_entry, 13], ['OPEN_POSITION                  ', clc$nominal_entry,
            clc$normal_usage_entry, 14], ['P                              ', clc$abbreviation_entry,
            clc$normal_usage_entry, 15], ['PERMANENT                      ', clc$nominal_entry,
            clc$normal_usage_entry, 15], ['RESOLVED_PATH                  ', clc$nominal_entry,
            clc$normal_usage_entry, 16], ['RP                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 16], ['S                              ', clc$abbreviation_entry,
            clc$normal_usage_entry, 17], ['SIZE                           ', clc$nominal_entry,
            clc$normal_usage_entry, 17], ['T                              ', clc$abbreviation_entry,
            clc$normal_usage_entry, 18], ['TEMPORARY                      ', clc$nominal_entry,
            clc$normal_usage_entry, 18], ['UI                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 19], ['USER_INFORMATION               ', clc$nominal_entry,
            clc$normal_usage_entry, 19]]]];

?? POP ??

    CONST
      p$file = 1,
      p$attribute = 2;

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

    VAR
      attached: boolean,
      local_file: boolean,
      evaluated_file_reference: fst$evaluated_file_reference,
      existing_file: boolean,
      ignore_contains_data: boolean,
      device_assigned: boolean,
      device_class: rmt$device_class,
      path_handle_name: fst$path_handle_name,
      file_attribute: array [1 .. 1] of amt$get_item,
      perm_file: boolean,
      str: fst$path,
      str_size: fst$path_size;


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

    get_$file_attribute_key (pvt [p$attribute].value^.keyword_value, file_attribute [1].key);

    IF (pvt [p$attribute].value^.keyword_value = 'DEVICE_CLASS') OR (pvt [p$attribute].value^.keyword_value =
          'ASSIGNED') OR (pvt [p$attribute].value^.keyword_value = 'PERMANENT') OR
          (pvt [p$attribute].value^.keyword_value = 'TEMPORARY') THEN
      rmp$get_device_class (pvt [p$file].value^.file_value^, device_assigned, device_class, status);
      IF pvt [p$attribute].value^.keyword_value = 'DEVICE_CLASS' THEN
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
        clp$make_string_value (class [device_class] (1, clp$trimmed_string_size (class [device_class])),
              work_area, result);
      ELSE
        IF NOT status.normal THEN
          device_assigned := FALSE;
          status.normal := TRUE;
        IFEND;
        IF NOT (pvt [p$attribute].value^.keyword_value = 'ASSIGNED') AND device_assigned THEN
          clp$convert_str_to_path_handle (pvt [p$file].value^.file_value^, FALSE, TRUE, FALSE,
                path_handle_name, evaluated_file_reference, status);
          device_assigned := (pvt [p$attribute].value^.keyword_value = 'PERMANENT') XOR
                (fsp$path_element (^evaluated_file_reference, 1) ^ = fsc$local);
        IFEND;
        clp$make_boolean_value (device_assigned, clc$true_false_boolean, work_area, result);

      IFEND;

    ELSEIF pvt [p$attribute].value^.keyword_value = 'CATALOG' THEN
      clp$convert_str_to_path_handle (pvt [p$file].value^.file_value^, FALSE, TRUE, FALSE, path_handle_name,
            evaluated_file_reference, status);

      clp$make_boolean_value (status.normal AND (evaluated_file_reference.path_resolution = fsc$catalog_path),
            clc$true_false_boolean, work_area, result);
      status.normal := TRUE;

    ELSEIF (pvt [p$attribute].value^.keyword_value = 'CYCLE_NUMBER') THEN
      clp$convert_str_to_path_handle (pvt [p$file].value^.file_value^, FALSE, TRUE, FALSE, path_handle_name,
            evaluated_file_reference, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;

      IF evaluated_file_reference.path_resolution = fsc$catalog_path THEN
        osp$set_status_abnormal ('CL', pfe$name_not_permanent_file, '', status);
        osp$append_status_file (osc$status_parameter_delimiter, pvt [p$file].value^.file_value^, status);
        RETURN; {----->
      IFEND;

      clp$make_integer_value (evaluated_file_reference.cycle_reference.cycle_number, 10, FALSE, work_area,
            result);

    ELSEIF pvt [p$attribute].value^.keyword_value = 'ATTACHED' THEN
      clp$convert_str_to_path_handle (pvt [p$file].value^.file_value^, FALSE, TRUE, FALSE, path_handle_name,
            evaluated_file_reference, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;

      IF evaluated_file_reference.path_resolution = fsc$catalog_path THEN
        osp$set_status_abnormal ('CL', pfe$name_not_permanent_file, '', status);
        osp$append_status_file (osc$status_parameter_delimiter, pvt [p$file].value^.file_value^, status);
        RETURN; {----->
      ELSEIF evaluated_file_reference.path_resolution = fsc$command_file_path THEN
        attached := TRUE;
      ELSE
        bap$is_file_registered (evaluated_file_reference.path_handle_info.path_handle, attached, status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
      IFEND;

      clp$make_boolean_value (attached, clc$true_false_boolean, work_area, result);

    ELSEIF pvt [p$attribute].value^.keyword_value = 'RESOLVED_PATH' THEN
      clp$convert_str_to_path_handle (pvt [p$file].value^.file_value^, FALSE, TRUE, TRUE, path_handle_name,
            evaluated_file_reference, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;

      clp$convert_file_ref_to_string (evaluated_file_reference, TRUE, str, str_size, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;

      clp$make_file_value (str (1, str_size), work_area, result);

    ELSE
      amp$get_file_attributes (pvt [p$file].value^.file_value^, file_attribute, local_file, existing_file,
            ignore_contains_data, status);
      IF NOT status.normal THEN
        RETURN {----->
      IFEND;

      CASE file_attribute [1].key OF

      = amc$application_info =
        clp$make_string_value (file_attribute [1].application_info
              (1, clp$trimmed_string_size (file_attribute [1].application_info)), work_area, result);

      = amc$file_contents =
        clp$make_string_value (file_attribute [1].file_contents
              (1, clp$trimmed_string_size (file_attribute [1].file_contents)), work_area, result);

      = amc$file_length = {SIZE}
        clp$make_integer_value (file_attribute [1].file_length, 10, FALSE, work_area, result);

      = amc$file_organization =
        clp$make_string_value (file_organizations [file_attribute [1].file_organization]
              (1, clp$trimmed_string_size (file_organizations [file_attribute [1].file_organization])),
              work_area, result);

      = amc$file_processor =
        clp$make_string_value (file_attribute [1].file_processor
              (1, clp$trimmed_string_size (file_attribute [1].file_processor)), work_area, result);

      = amc$file_structure =
        clp$make_string_value (file_attribute [1].file_structure
              (1, clp$trimmed_string_size (file_attribute [1].file_structure)), work_area, result);

      = amc$global_file_position =
        clp$make_string_value (global_file_positions [file_attribute [1].global_file_position]
              (1, clp$trimmed_string_size (global_file_positions [file_attribute [1].global_file_position])),
              work_area, result);

      = amc$label_type =
        clp$make_string_value (label_types [file_attribute [1].label_type]
              (1, clp$trimmed_string_size (label_types [file_attribute [1].label_type])), work_area, result);

      = amc$null_attribute = {OPENED}
        clp$make_boolean_value (existing_file, clc$true_false_boolean, work_area, result);

      = amc$open_position =
        clp$make_string_value (clv$open_positions [file_attribute [1].open_position]
              (1, clp$trimmed_string_size (clv$open_positions [file_attribute [1].open_position])),
              work_area, result);

      = amc$user_info =
        clp$make_string_value (file_attribute [1].user_info
              (1, clp$trimmed_string_size (file_attribute [1].user_info)), work_area, result);

      ELSE
      CASEND;
    IFEND;

    IF result = NIL THEN
      osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
    IFEND;

  PROCEND clp$$file;

?? TITLE := 'clp$$file_attributes', EJECT ??

  PROCEDURE [XDCL] clp$$file_attributes
    (    parameter_list: clt$parameter_list;
     VAR work_area {input output} : ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);

{ FUNCTION (osm$$file_attributes) $file_attributes (
{   file: any of
{       key
{         (system_default_values, system_default_value, sdv)
{       keyend
{       list of file
{     anyend = $required
{   attributes: list of key
{       all
{       (access_control_list, acl)
{       (account_project, ap)
{       (actual_job_access, am, access_modes, access_mode, aja)
{       (attached, a)
{       (catalog_registration_attributes, cra)
{       (common_file_attributes, cfa)
{       (creation_date_time, cdt)
{       (cycle_number, cn)
{       (device_class_attributes, dca)
{       (exception_conditions, exception_condition, ec)
{       (expiration_date, ed)
{       (file_contents, file_structure, fs, file_content, fc)
{       (file_processor, fp)
{       (job_environment_attributes, jea)
{       (keyed_file_attributes, kfa)
{       (last_access_date_time, ladt)
{       (last_modification_date_time, lmdt)
{       (object_type, ot)
{       (path, p)
{       (permitted_access, application_info, ai, application_information, pa)
{       (potential_job_access, global_access_mode, gam, gsm, global_access_modes, global_share_modes, ..
{       global_share_mode, pja)
{       (presentation_file_attributes, pfa)
{       (registered, r)
{       (size, s)
{     advanced_key
{       (archive_media_information, archive_media_description, ami, archive_media_descriptor, amd)
{       (attached_external_vsn_list, aevl)
{       (attached_recorded_vsn_list, arvl)
{       (attached_transfer_size, ats)
{       (attached_vol_overflow_allowed, avoa)
{       (attached_volume_number, avn)
{       (attachment_log, al)
{       (attachment_logging_selected, als)
{       (attachment_status, as)
{       (average_record_length, arl)
{       (block_type, bt)
{       (character_conversion, cc)
{       (collate_table_name, ctn)
{       complete_path
{       (compression_procedure_name, cpn)
{       (connected_files, cf)
{       (cycle_path, cp)
{       (data_padding, dp)
{       (device_class, dc)
{       (dynamic_home_block_space, dhbs)
{       (embedded_key, ek)
{       (error_exit_procedure_name, een, error_exit_name, eepn)
{       (error_limit, el)
{       (estimated_record_count, erc)
{       (external_vsn_list, evsnl, evl)
{       (file_access_procedure_name, fap, file_access_procedure, fapn)
{       (file_label_type, flt)
{       (file_limit, fl)
{       (file_organization, fo)
{       (file_previously_opened, fpo)
{       (forced_write, fw)
{       (hashing_procedure_name, hpn)
{       (index_levels, index_level, il)
{       (index_padding, ip)
{       (initial_home_block_count, ihbc)
{       (internal_code, ic)
{       (job_file_address, global_file_address, gfa, jfa)
{       (job_file_position, global_file_position, gfp, jfp)
{       (job_instances_of_open, jioo)
{       (job_write_concurrency, jwc)
{       (key_length, kl)
{       (key_position, kp)
{       (key_type, kt)
{       (last_data_modification_time, last_data_modification_date, ldmdt, ldmd, ldmt)
{       (lifetime, permanent, l)
{       (lifetime_attachment_count, lac)
{       (line_number, ln)
{       (loading_factor, lf)
{       (lock_expiration_time, let)
{       (log_residence, lr)
{       (logging_options, lo)
{       (mainframe_attachment, ma)
{       (mainframe_write_concurrency, mwc)
{       (mass_storage_allocation_size, msas)
{       (mass_storage_bytes_allocated, msba)
{       (mass_storage_class, msc)
{       (mass_storage_free_behind, msfb)
{       (mass_storage_initial_volume, msiv)
{       (mass_storage_sequential_access, mssa)
{       (mass_storage_transfer_size, msts)
{       (maximum_block_length, maxbl)
{       (maximum_record_length, maxrl)
{       (message_control, mc)
{       (minimum_block_length, minbl)
{       (minimum_record_length, minrl)
{       (open_position, op)
{       (padding_character, pc)
{       (page_format, pf)
{       (page_length, pl)
{       (page_width, pw)
{       (preset_value, pv)
{       (private_read, pr)
{       (record_delimiting_character, rdc)
{       (record_limit, rl)
{       (record_type, rt)
{       (recorded_vsn_list, rvsnl, rvl)
{       (records_per_block, rpb)
{       (removable_media_group, rmg)
{       (retrieve_option, ro)
{       (ring_attributes, ring_attribute, ra)
{       (secondary_residence, sr)
{       (set_name, sn)
{       (shared_queue, sq)
{       (site_archive_option, sao)
{       (site_backup_option, sbo)
{       (site_release_option, sro)
{       (statement_identifier, si)
{       (tape_density, td)
{       (unique_data_name, global_file_name, gfn, udn)
{       (unique_name, un)
{       (user_information, ui)
{       (vertical_print_density, vpd)
{       (volume_overflow_allowed, voa)
{     hidden_key
{       source
{     keyend = $required
{   password: (ADVANCED) any of
{       key
{         none
{       keyend
{       name
{     anyend = none
{   )

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

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 3] of clt$pdt_parameter_name,
      parameters: array [1 .. 3] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 3] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$list_type_qualifier_v2,
          element_type_spec: record
            header: clt$type_specification_header,
          recend,
        recend,
      recend,
      type2: record
        header: clt$type_specification_header,
        qualifier: clt$list_type_qualifier_v2,
        element_type_spec: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 272] of clt$keyword_specification,
        recend,
      recend,
      type3: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 1] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$name_type_qualifier,
        recend,
        default_value: string (4),
      recend,
    recend := [
    [1,
    [101, 7, 3, 13, 5, 56, 226],
    clc$function, 3, 3, 2, 1, 0, 0, 0, 'OSM$$FILE_ATTRIBUTES'], [
    ['ATTRIBUTES                     ',clc$nominal_entry, 2],
    ['FILE                           ',clc$nominal_entry, 1],
    ['PASSWORD                       ',clc$nominal_entry, 3]],
    [
{ PARAMETER 1
    [2, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 157,
  clc$required_parameter, 0, 0],
{ PARAMETER 2
    [1, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 10087,
  clc$required_parameter, 0, 0],
{ PARAMETER 3
    [3, clc$advanced_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 69,
  clc$optional_default_parameter, 0, 4]],
{ PARAMETER 1
    [[1, 0, clc$union_type], [[clc$keyword_type, clc$list_type],
    FALSE, 2],
    118, [[1, 0, clc$keyword_type], [3], [
      ['SDV                            ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
      ['SYSTEM_DEFAULT_VALUE           ', clc$alias_entry, clc$normal_usage_entry, 1],
      ['SYSTEM_DEFAULT_VALUES          ', clc$nominal_entry, clc$normal_usage_entry, 1]]
      ],
    19, [[1, 0, clc$list_type], [3, 1, clc$max_list_size, 0, FALSE, FALSE],
        [[1, 0, clc$file_type]]
      ]
    ],
{ PARAMETER 2
    [[1, 0, clc$list_type], [10071, 1, clc$max_list_size, 0, FALSE, FALSE],
      [[1, 0, clc$keyword_type], [272], [
      ['A                              ', clc$abbreviation_entry, clc$normal_usage_entry, 5],
      ['ACCESS_CONTROL_LIST            ', clc$nominal_entry, clc$normal_usage_entry, 2],
      ['ACCESS_MODE                    ', clc$alias_entry, clc$normal_usage_entry, 4],
      ['ACCESS_MODES                   ', clc$alias_entry, clc$normal_usage_entry, 4],
      ['ACCOUNT_PROJECT                ', clc$nominal_entry, clc$normal_usage_entry, 3],
      ['ACL                            ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
      ['ACTUAL_JOB_ACCESS              ', clc$nominal_entry, clc$normal_usage_entry, 4],
      ['AEVL                           ', clc$abbreviation_entry, clc$advanced_usage_entry, 27],
      ['AI                             ', clc$alias_entry, clc$normal_usage_entry, 21],
      ['AJA                            ', clc$abbreviation_entry, clc$normal_usage_entry, 4],
      ['AL                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 32],
      ['ALL                            ', clc$nominal_entry, clc$normal_usage_entry, 1],
      ['ALS                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 33],
      ['AM                             ', clc$alias_entry, clc$normal_usage_entry, 4],
      ['AMD                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 26],
      ['AMI                            ', clc$alias_entry, clc$advanced_usage_entry, 26],
      ['AP                             ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
      ['APPLICATION_INFO               ', clc$alias_entry, clc$normal_usage_entry, 21],
      ['APPLICATION_INFORMATION        ', clc$alias_entry, clc$normal_usage_entry, 21],
      ['ARCHIVE_MEDIA_DESCRIPTION      ', clc$alias_entry, clc$advanced_usage_entry, 26],
      ['ARCHIVE_MEDIA_DESCRIPTOR       ', clc$alias_entry, clc$advanced_usage_entry, 26],
      ['ARCHIVE_MEDIA_INFORMATION      ', clc$nominal_entry, clc$advanced_usage_entry, 26],
      ['ARL                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 35],
      ['ARVL                           ', clc$abbreviation_entry, clc$advanced_usage_entry, 28],
      ['AS                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 34],
      ['ATS                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 29],
      ['ATTACHED                       ', clc$nominal_entry, clc$normal_usage_entry, 5],
      ['ATTACHED_EXTERNAL_VSN_LIST     ', clc$nominal_entry, clc$advanced_usage_entry, 27],
      ['ATTACHED_RECORDED_VSN_LIST     ', clc$nominal_entry, clc$advanced_usage_entry, 28],
      ['ATTACHED_TRANSFER_SIZE         ', clc$nominal_entry, clc$advanced_usage_entry, 29],
      ['ATTACHED_VOLUME_NUMBER         ', clc$nominal_entry, clc$advanced_usage_entry, 31],
      ['ATTACHED_VOL_OVERFLOW_ALLOWED  ', clc$nominal_entry, clc$advanced_usage_entry, 30],
      ['ATTACHMENT_LOG                 ', clc$nominal_entry, clc$advanced_usage_entry, 32],
      ['ATTACHMENT_LOGGING_SELECTED    ', clc$nominal_entry, clc$advanced_usage_entry, 33],
      ['ATTACHMENT_STATUS              ', clc$nominal_entry, clc$advanced_usage_entry, 34],
      ['AVERAGE_RECORD_LENGTH          ', clc$nominal_entry, clc$advanced_usage_entry, 35],
      ['AVN                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 31],
      ['AVOA                           ', clc$abbreviation_entry, clc$advanced_usage_entry, 30],
      ['BLOCK_TYPE                     ', clc$nominal_entry, clc$advanced_usage_entry, 36],
      ['BT                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 36],
      ['CATALOG_REGISTRATION_ATTRIBUTES', clc$nominal_entry, clc$normal_usage_entry, 6],
      ['CC                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 37],
      ['CDT                            ', clc$abbreviation_entry, clc$normal_usage_entry, 8],
      ['CF                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 41],
      ['CFA                            ', clc$abbreviation_entry, clc$normal_usage_entry, 7],
      ['CHARACTER_CONVERSION           ', clc$nominal_entry, clc$advanced_usage_entry, 37],
      ['CN                             ', clc$abbreviation_entry, clc$normal_usage_entry, 9],
      ['COLLATE_TABLE_NAME             ', clc$nominal_entry, clc$advanced_usage_entry, 38],
      ['COMMON_FILE_ATTRIBUTES         ', clc$nominal_entry, clc$normal_usage_entry, 7],
      ['COMPLETE_PATH                  ', clc$nominal_entry, clc$advanced_usage_entry, 39],
      ['COMPRESSION_PROCEDURE_NAME     ', clc$nominal_entry, clc$advanced_usage_entry, 40],
      ['CONNECTED_FILES                ', clc$nominal_entry, clc$advanced_usage_entry, 41],
      ['CP                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 42],
      ['CPN                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 40],
      ['CRA                            ', clc$abbreviation_entry, clc$normal_usage_entry, 6],
      ['CREATION_DATE_TIME             ', clc$nominal_entry, clc$normal_usage_entry, 8],
      ['CTN                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 38],
      ['CYCLE_NUMBER                   ', clc$nominal_entry, clc$normal_usage_entry, 9],
      ['CYCLE_PATH                     ', clc$nominal_entry, clc$advanced_usage_entry, 42],
      ['DATA_PADDING                   ', clc$nominal_entry, clc$advanced_usage_entry, 43],
      ['DC                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 44],
      ['DCA                            ', clc$abbreviation_entry, clc$normal_usage_entry, 10],
      ['DEVICE_CLASS                   ', clc$nominal_entry, clc$advanced_usage_entry, 44],
      ['DEVICE_CLASS_ATTRIBUTES        ', clc$nominal_entry, clc$normal_usage_entry, 10],
      ['DHBS                           ', clc$abbreviation_entry, clc$advanced_usage_entry, 45],
      ['DP                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 43],
      ['DYNAMIC_HOME_BLOCK_SPACE       ', clc$nominal_entry, clc$advanced_usage_entry, 45],
      ['EC                             ', clc$abbreviation_entry, clc$normal_usage_entry, 11],
      ['ED                             ', clc$abbreviation_entry, clc$normal_usage_entry, 12],
      ['EEN                            ', clc$alias_entry, clc$advanced_usage_entry, 47],
      ['EEPN                           ', clc$abbreviation_entry, clc$advanced_usage_entry, 47],
      ['EK                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 46],
      ['EL                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 48],
      ['EMBEDDED_KEY                   ', clc$nominal_entry, clc$advanced_usage_entry, 46],
      ['ERC                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 49],
      ['ERROR_EXIT_NAME                ', clc$alias_entry, clc$advanced_usage_entry, 47],
      ['ERROR_EXIT_PROCEDURE_NAME      ', clc$nominal_entry, clc$advanced_usage_entry, 47],
      ['ERROR_LIMIT                    ', clc$nominal_entry, clc$advanced_usage_entry, 48],
      ['ESTIMATED_RECORD_COUNT         ', clc$nominal_entry, clc$advanced_usage_entry, 49],
      ['EVL                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 50],
      ['EVSNL                          ', clc$alias_entry, clc$advanced_usage_entry, 50],
      ['EXCEPTION_CONDITION            ', clc$alias_entry, clc$normal_usage_entry, 11],
      ['EXCEPTION_CONDITIONS           ', clc$nominal_entry, clc$normal_usage_entry, 11],
      ['EXPIRATION_DATE                ', clc$nominal_entry, clc$normal_usage_entry, 12],
      ['EXTERNAL_VSN_LIST              ', clc$nominal_entry, clc$advanced_usage_entry, 50],
      ['FAP                            ', clc$alias_entry, clc$advanced_usage_entry, 51],
      ['FAPN                           ', clc$abbreviation_entry, clc$advanced_usage_entry, 51],
      ['FC                             ', clc$abbreviation_entry, clc$normal_usage_entry, 13],
      ['FILE_ACCESS_PROCEDURE          ', clc$alias_entry, clc$advanced_usage_entry, 51],
      ['FILE_ACCESS_PROCEDURE_NAME     ', clc$nominal_entry, clc$advanced_usage_entry, 51],
      ['FILE_CONTENT                   ', clc$alias_entry, clc$normal_usage_entry, 13],
      ['FILE_CONTENTS                  ', clc$nominal_entry, clc$normal_usage_entry, 13],
      ['FILE_LABEL_TYPE                ', clc$nominal_entry, clc$advanced_usage_entry, 52],
      ['FILE_LIMIT                     ', clc$nominal_entry, clc$advanced_usage_entry, 53],
      ['FILE_ORGANIZATION              ', clc$nominal_entry, clc$advanced_usage_entry, 54],
      ['FILE_PREVIOUSLY_OPENED         ', clc$nominal_entry, clc$advanced_usage_entry, 55],
      ['FILE_PROCESSOR                 ', clc$nominal_entry, clc$normal_usage_entry, 14],
      ['FILE_STRUCTURE                 ', clc$alias_entry, clc$normal_usage_entry, 13],
      ['FL                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 53],
      ['FLT                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 52],
      ['FO                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 54],
      ['FORCED_WRITE                   ', clc$nominal_entry, clc$advanced_usage_entry, 56],
      ['FP                             ', clc$abbreviation_entry, clc$normal_usage_entry, 14],
      ['FPO                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 55],
      ['FS                             ', clc$alias_entry, clc$normal_usage_entry, 13],
      ['FW                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 56],
      ['GAM                            ', clc$alias_entry, clc$normal_usage_entry, 22],
      ['GFA                            ', clc$alias_entry, clc$advanced_usage_entry, 62],
      ['GFN                            ', clc$alias_entry, clc$advanced_usage_entry, 114],
      ['GFP                            ', clc$alias_entry, clc$advanced_usage_entry, 63],
      ['GLOBAL_ACCESS_MODE             ', clc$alias_entry, clc$normal_usage_entry, 22],
      ['GLOBAL_ACCESS_MODES            ', clc$alias_entry, clc$normal_usage_entry, 22],
      ['GLOBAL_FILE_ADDRESS            ', clc$alias_entry, clc$advanced_usage_entry, 62],
      ['GLOBAL_FILE_NAME               ', clc$alias_entry, clc$advanced_usage_entry, 114],
      ['GLOBAL_FILE_POSITION           ', clc$alias_entry, clc$advanced_usage_entry, 63],
      ['GLOBAL_SHARE_MODE              ', clc$alias_entry, clc$normal_usage_entry, 22],
      ['GLOBAL_SHARE_MODES             ', clc$alias_entry, clc$normal_usage_entry, 22],
      ['GSM                            ', clc$alias_entry, clc$normal_usage_entry, 22],
      ['HASHING_PROCEDURE_NAME         ', clc$nominal_entry, clc$advanced_usage_entry, 57],
      ['HPN                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 57],
      ['IC                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 61],
      ['IHBC                           ', clc$abbreviation_entry, clc$advanced_usage_entry, 60],
      ['IL                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 58],
      ['INDEX_LEVEL                    ', clc$alias_entry, clc$advanced_usage_entry, 58],
      ['INDEX_LEVELS                   ', clc$nominal_entry, clc$advanced_usage_entry, 58],
      ['INDEX_PADDING                  ', clc$nominal_entry, clc$advanced_usage_entry, 59],
      ['INITIAL_HOME_BLOCK_COUNT       ', clc$nominal_entry, clc$advanced_usage_entry, 60],
      ['INTERNAL_CODE                  ', clc$nominal_entry, clc$advanced_usage_entry, 61],
      ['IP                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 59],
      ['JEA                            ', clc$abbreviation_entry, clc$normal_usage_entry, 15],
      ['JFA                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 62],
      ['JFP                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 63],
      ['JIOO                           ', clc$abbreviation_entry, clc$advanced_usage_entry, 64],
      ['JOB_ENVIRONMENT_ATTRIBUTES     ', clc$nominal_entry, clc$normal_usage_entry, 15],
      ['JOB_FILE_ADDRESS               ', clc$nominal_entry, clc$advanced_usage_entry, 62],
      ['JOB_FILE_POSITION              ', clc$nominal_entry, clc$advanced_usage_entry, 63],
      ['JOB_INSTANCES_OF_OPEN          ', clc$nominal_entry, clc$advanced_usage_entry, 64],
      ['JOB_WRITE_CONCURRENCY          ', clc$nominal_entry, clc$advanced_usage_entry, 65],
      ['JWC                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 65],
      ['KEYED_FILE_ATTRIBUTES          ', clc$nominal_entry, clc$normal_usage_entry, 16],
      ['KEY_LENGTH                     ', clc$nominal_entry, clc$advanced_usage_entry, 66],
      ['KEY_POSITION                   ', clc$nominal_entry, clc$advanced_usage_entry, 67],
      ['KEY_TYPE                       ', clc$nominal_entry, clc$advanced_usage_entry, 68],
      ['KFA                            ', clc$abbreviation_entry, clc$normal_usage_entry, 16],
      ['KL                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 66],
      ['KP                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 67],
      ['KT                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 68],
      ['L                              ', clc$abbreviation_entry, clc$advanced_usage_entry, 70],
      ['LAC                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 71],
      ['LADT                           ', clc$abbreviation_entry, clc$normal_usage_entry, 17],
      ['LAST_ACCESS_DATE_TIME          ', clc$nominal_entry, clc$normal_usage_entry, 17],
      ['LAST_DATA_MODIFICATION_DATE    ', clc$alias_entry, clc$advanced_usage_entry, 69],
      ['LAST_DATA_MODIFICATION_TIME    ', clc$nominal_entry, clc$advanced_usage_entry, 69],
      ['LAST_MODIFICATION_DATE_TIME    ', clc$nominal_entry, clc$normal_usage_entry, 18],
      ['LDMD                           ', clc$alias_entry, clc$advanced_usage_entry, 69],
      ['LDMDT                          ', clc$alias_entry, clc$advanced_usage_entry, 69],
      ['LDMT                           ', clc$abbreviation_entry, clc$advanced_usage_entry, 69],
      ['LET                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 74],
      ['LF                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 73],
      ['LIFETIME                       ', clc$nominal_entry, clc$advanced_usage_entry, 70],
      ['LIFETIME_ATTACHMENT_COUNT      ', clc$nominal_entry, clc$advanced_usage_entry, 71],
      ['LINE_NUMBER                    ', clc$nominal_entry, clc$advanced_usage_entry, 72],
      ['LMDT                           ', clc$abbreviation_entry, clc$normal_usage_entry, 18],
      ['LN                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 72],
      ['LO                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 76],
      ['LOADING_FACTOR                 ', clc$nominal_entry, clc$advanced_usage_entry, 73],
      ['LOCK_EXPIRATION_TIME           ', clc$nominal_entry, clc$advanced_usage_entry, 74],
      ['LOGGING_OPTIONS                ', clc$nominal_entry, clc$advanced_usage_entry, 76],
      ['LOG_RESIDENCE                  ', clc$nominal_entry, clc$advanced_usage_entry, 75],
      ['LR                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 75],
      ['MA                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 77],
      ['MAINFRAME_ATTACHMENT           ', clc$nominal_entry, clc$advanced_usage_entry, 77],
      ['MAINFRAME_WRITE_CONCURRENCY    ', clc$nominal_entry, clc$advanced_usage_entry, 78],
      ['MASS_STORAGE_ALLOCATION_SIZE   ', clc$nominal_entry, clc$advanced_usage_entry, 79],
      ['MASS_STORAGE_BYTES_ALLOCATED   ', clc$nominal_entry, clc$advanced_usage_entry, 80],
      ['MASS_STORAGE_CLASS             ', clc$nominal_entry, clc$advanced_usage_entry, 81],
      ['MASS_STORAGE_FREE_BEHIND       ', clc$nominal_entry, clc$advanced_usage_entry, 82],
      ['MASS_STORAGE_INITIAL_VOLUME    ', clc$nominal_entry, clc$advanced_usage_entry, 83],
      ['MASS_STORAGE_SEQUENTIAL_ACCESS ', clc$nominal_entry, clc$advanced_usage_entry, 84],
      ['MASS_STORAGE_TRANSFER_SIZE     ', clc$nominal_entry, clc$advanced_usage_entry, 85],
      ['MAXBL                          ', clc$abbreviation_entry, clc$advanced_usage_entry, 86],
      ['MAXIMUM_BLOCK_LENGTH           ', clc$nominal_entry, clc$advanced_usage_entry, 86],
      ['MAXIMUM_RECORD_LENGTH          ', clc$nominal_entry, clc$advanced_usage_entry, 87],
      ['MAXRL                          ', clc$abbreviation_entry, clc$advanced_usage_entry, 87],
      ['MC                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 88],
      ['MESSAGE_CONTROL                ', clc$nominal_entry, clc$advanced_usage_entry, 88],
      ['MINBL                          ', clc$abbreviation_entry, clc$advanced_usage_entry, 89],
      ['MINIMUM_BLOCK_LENGTH           ', clc$nominal_entry, clc$advanced_usage_entry, 89],
      ['MINIMUM_RECORD_LENGTH          ', clc$nominal_entry, clc$advanced_usage_entry, 90],
      ['MINRL                          ', clc$abbreviation_entry, clc$advanced_usage_entry, 90],
      ['MSAS                           ', clc$abbreviation_entry, clc$advanced_usage_entry, 79],
      ['MSBA                           ', clc$abbreviation_entry, clc$advanced_usage_entry, 80],
      ['MSC                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 81],
      ['MSFB                           ', clc$abbreviation_entry, clc$advanced_usage_entry, 82],
      ['MSIV                           ', clc$abbreviation_entry, clc$advanced_usage_entry, 83],
      ['MSSA                           ', clc$abbreviation_entry, clc$advanced_usage_entry, 84],
      ['MSTS                           ', clc$abbreviation_entry, clc$advanced_usage_entry, 85],
      ['MWC                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 78],
      ['OBJECT_TYPE                    ', clc$nominal_entry, clc$normal_usage_entry, 19],
      ['OP                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 91],
      ['OPEN_POSITION                  ', clc$nominal_entry, clc$advanced_usage_entry, 91],
      ['OT                             ', clc$abbreviation_entry, clc$normal_usage_entry, 19],
      ['P                              ', clc$abbreviation_entry, clc$normal_usage_entry, 20],
      ['PA                             ', clc$abbreviation_entry, clc$normal_usage_entry, 21],
      ['PADDING_CHARACTER              ', clc$nominal_entry, clc$advanced_usage_entry, 92],
      ['PAGE_FORMAT                    ', clc$nominal_entry, clc$advanced_usage_entry, 93],
      ['PAGE_LENGTH                    ', clc$nominal_entry, clc$advanced_usage_entry, 94],
      ['PAGE_WIDTH                     ', clc$nominal_entry, clc$advanced_usage_entry, 95],
      ['PATH                           ', clc$nominal_entry, clc$normal_usage_entry, 20],
      ['PC                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 92],
      ['PERMANENT                      ', clc$alias_entry, clc$advanced_usage_entry, 70],
      ['PERMITTED_ACCESS               ', clc$nominal_entry, clc$normal_usage_entry, 21],
      ['PF                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 93],
      ['PFA                            ', clc$abbreviation_entry, clc$normal_usage_entry, 23],
      ['PJA                            ', clc$abbreviation_entry, clc$normal_usage_entry, 22],
      ['PL                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 94],
      ['POTENTIAL_JOB_ACCESS           ', clc$nominal_entry, clc$normal_usage_entry, 22],
      ['PR                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 97],
      ['PRESENTATION_FILE_ATTRIBUTES   ', clc$nominal_entry, clc$normal_usage_entry, 23],
      ['PRESET_VALUE                   ', clc$nominal_entry, clc$advanced_usage_entry, 96],
      ['PRIVATE_READ                   ', clc$nominal_entry, clc$advanced_usage_entry, 97],
      ['PV                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 96],
      ['PW                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 95],
      ['R                              ', clc$abbreviation_entry, clc$normal_usage_entry, 24],
      ['RA                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 105],
      ['RDC                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 98],
      ['RECORDED_VSN_LIST              ', clc$nominal_entry, clc$advanced_usage_entry, 101],
      ['RECORDS_PER_BLOCK              ', clc$nominal_entry, clc$advanced_usage_entry, 102],
      ['RECORD_DELIMITING_CHARACTER    ', clc$nominal_entry, clc$advanced_usage_entry, 98],
      ['RECORD_LIMIT                   ', clc$nominal_entry, clc$advanced_usage_entry, 99],
      ['RECORD_TYPE                    ', clc$nominal_entry, clc$advanced_usage_entry, 100],
      ['REGISTERED                     ', clc$nominal_entry, clc$normal_usage_entry, 24],
      ['REMOVABLE_MEDIA_GROUP          ', clc$nominal_entry, clc$advanced_usage_entry, 103],
      ['RETRIEVE_OPTION                ', clc$nominal_entry, clc$advanced_usage_entry, 104],
      ['RING_ATTRIBUTE                 ', clc$alias_entry, clc$advanced_usage_entry, 105],
      ['RING_ATTRIBUTES                ', clc$nominal_entry, clc$advanced_usage_entry, 105],
      ['RL                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 99],
      ['RMG                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 103],
      ['RO                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 104],
      ['RPB                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 102],
      ['RT                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 100],
      ['RVL                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 101],
      ['RVSNL                          ', clc$alias_entry, clc$advanced_usage_entry, 101],
      ['S                              ', clc$abbreviation_entry, clc$normal_usage_entry, 25],
      ['SAO                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 109],
      ['SBO                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 110],
      ['SECONDARY_RESIDENCE            ', clc$nominal_entry, clc$advanced_usage_entry, 106],
      ['SET_NAME                       ', clc$nominal_entry, clc$advanced_usage_entry, 107],
      ['SHARED_QUEUE                   ', clc$nominal_entry, clc$advanced_usage_entry, 108],
      ['SI                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 112],
      ['SITE_ARCHIVE_OPTION            ', clc$nominal_entry, clc$advanced_usage_entry, 109],
      ['SITE_BACKUP_OPTION             ', clc$nominal_entry, clc$advanced_usage_entry, 110],
      ['SITE_RELEASE_OPTION            ', clc$nominal_entry, clc$advanced_usage_entry, 111],
      ['SIZE                           ', clc$nominal_entry, clc$normal_usage_entry, 25],
      ['SN                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 107],
      ['SOURCE                         ', clc$nominal_entry, clc$hidden_entry, 119],
      ['SQ                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 108],
      ['SR                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 106],
      ['SRO                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 111],
      ['STATEMENT_IDENTIFIER           ', clc$nominal_entry, clc$advanced_usage_entry, 112],
      ['TAPE_DENSITY                   ', clc$nominal_entry, clc$advanced_usage_entry, 113],
      ['TD                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 113],
      ['UDN                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 114],
      ['UI                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 116],
      ['UN                             ', clc$abbreviation_entry, clc$advanced_usage_entry, 115],
      ['UNIQUE_DATA_NAME               ', clc$nominal_entry, clc$advanced_usage_entry, 114],
      ['UNIQUE_NAME                    ', clc$nominal_entry, clc$advanced_usage_entry, 115],
      ['USER_INFORMATION               ', clc$nominal_entry, clc$advanced_usage_entry, 116],
      ['VERTICAL_PRINT_DENSITY         ', clc$nominal_entry, clc$advanced_usage_entry, 117],
      ['VOA                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 118],
      ['VOLUME_OVERFLOW_ALLOWED        ', clc$nominal_entry, clc$advanced_usage_entry, 118],
      ['VPD                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 117]]
      ]
    ],
{ PARAMETER 3
    [[1, 0, clc$union_type], [[clc$keyword_type, clc$name_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['NONE                           ', clc$nominal_entry, clc$normal_usage_entry, 1]]
      ],
    5, [[1, 0, clc$name_type], [1, osc$max_name_size]]
    ,
    'none']];

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

    CONST
      p$file = 1,
      p$attributes = 2,
      p$password = 3;

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

    CONST
      nil_object_info_text = 'NEXT of object_information in sequence resulted in a NIL pointer in ' CAT
            '$FILE_ATTRIBUTES';

    VAR
      all_requested: boolean,
      attributes_requested: file_attribute_keys,
      caller_id: ost$caller_identifier,
      current_file: ^clt$data_value,
      current_value: ^clt$data_value,
      evaluated_file_reference: fst$evaluated_file_reference,
      information_request: fst$goi_information_request,
      number_of_requested_attributes: object_type_counts,
      object_info_sequence_p: ^SEQ ( * ),
      object_information_p: ^fst$goi_object_information,
      result_node: ^^clt$data_value,
      source_requested: boolean,
      validation_criteria: ^fst$goi_validation_criteria;

    #CALLER_ID (caller_id);

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

    determine_attributes_requested (pvt [p$attributes].value, attributes_requested,
          number_of_requested_attributes, all_requested, source_requested);

    information_request := initial_information_request;
    determine_object_info_requests (attributes_requested, information_request.object_information_requests);

    IF pvt [p$file].value^.kind = clc$keyword THEN { system_default_values }
      object_info_sequence_p := NIL;
      process_object_information (fsv$evaluated_file_reference, caller_id.ring, {validation_criteria} NIL,
            all_requested, source_requested, number_of_requested_attributes, attributes_requested,
            object_info_sequence_p, work_area, result, status);
    ELSE
      IF (pvt [p$password].specified) AND (pvt [p$password].value^.kind = clc$name) THEN
        PUSH validation_criteria: [1 .. 1];
        validation_criteria^ [1].validation_selection := fsc$goi_password;
        validation_criteria^ [1].password := pvt [p$password].value^.name_value;
      ELSE
        validation_criteria := NIL;
      IFEND;

      result_node := ^result;
      current_file := pvt [p$file].value;
      WHILE current_file <> NIL DO
        clp$evaluate_file_reference (current_file^.element_value^.file_value^,
              $clt$file_ref_parsing_options [], FALSE, evaluated_file_reference, status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;

        object_info_sequence_p := work_area;
        get_object_information (evaluated_file_reference, information_request, validation_criteria, work_area,
              status);
        IF NOT status.normal AND NOT status_condition_ignorable
              (status.condition, attributes_requested, evaluated_file_reference) THEN
          RETURN; {----->
        ELSE
          process_object_information (evaluated_file_reference, caller_id.ring, validation_criteria,
                all_requested, source_requested, number_of_requested_attributes, attributes_requested,
                object_info_sequence_p, work_area, result_node^, status);
          IF NOT status.normal AND (status.condition = fse$attributes_not_defined) THEN
            osp$append_status_file (osc$status_parameter_delimiter, current_file^.element_value^.file_value^,
                  status);
            RETURN; {----->
          IFEND;
        IFEND;

        current_file := current_file^.link;
        REPEAT
          result_node := ^result_node^^.link;
        UNTIL result_node^ = NIL;
      WHILEND;
    IFEND;

  PROCEND clp$$file_attributes;

?? TITLE := 'clp$$access_mode', EJECT ??

  PROCEDURE [XDCL] clp$$access_mode
    (    parameter_list: clt$parameter_list;
     VAR work_area {input, output} : ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);

{ FUNCTION (osm$$access_mode) $access_mode (
{   file: file = $required
{   access_modes: list rest of key
{       all
{       (append, a)
{       (execute, e)
{       (modify, m)
{       (read, r)
{       (shorten, s)
{       (write, w)
{     keyend = $required
{   )

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

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 2] of clt$pdt_parameter_name,
      parameters: array [1 .. 2] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
      recend,
      type2: record
        header: clt$type_specification_header,
        qualifier: clt$list_type_qualifier,
        element_type_spec: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 13] of clt$keyword_specification,
        recend,
      recend,
    recend := [
    [1,
    [89, 6, 12, 13, 46, 37, 964],
    clc$function, 2, 2, 2, 0, 0, 0, 0, 'OSM$$ACCESS_MODE'], [
    ['ACCESS_MODES                   ',clc$nominal_entry, 2],
    ['FILE                           ',clc$nominal_entry, 1]],
    [
{ PARAMETER 1
    [2, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$required_parameter, 0
  , 0],
{ PARAMETER 2
    [1, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 504,
  clc$required_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$file_type]],
{ PARAMETER 2
    [[1, 0, clc$list_type], [488, 1, clc$max_list_size, TRUE],
      [[1, 0, clc$keyword_type], [13], [
      ['A                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
      ['ALL                            ', clc$nominal_entry, clc$normal_usage_entry, 1],
      ['APPEND                         ', clc$nominal_entry, clc$normal_usage_entry, 2],
      ['E                              ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
      ['EXECUTE                        ', clc$nominal_entry, clc$normal_usage_entry, 3],
      ['M                              ', clc$abbreviation_entry, clc$normal_usage_entry, 4],
      ['MODIFY                         ', clc$nominal_entry, clc$normal_usage_entry, 4],
      ['R                              ', clc$abbreviation_entry, clc$normal_usage_entry, 5],
      ['READ                           ', clc$nominal_entry, clc$normal_usage_entry, 5],
      ['S                              ', clc$abbreviation_entry, clc$normal_usage_entry, 6],
      ['SHORTEN                        ', clc$nominal_entry, clc$normal_usage_entry, 6],
      ['W                              ', clc$abbreviation_entry, clc$normal_usage_entry, 7],
      ['WRITE                          ', clc$nominal_entry, clc$normal_usage_entry, 7]]
      ]
    ]];

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

    CONST
      p$file = 1,
      p$access_modes = 2;

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

    VAR
      ignore_local_file: boolean,
      ignore_existing_file: boolean,
      ignore_contains_data: boolean,
      file_attribute: array [1 .. 1] of amt$get_item,
      access_mode: pft$usage_selections,
      node: ^clt$data_value;


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

    file_attribute [1].key := amc$global_access_mode;
    amp$get_file_attributes (pvt [p$file].value^.file_value^, file_attribute, ignore_local_file,
          ignore_existing_file, ignore_contains_data, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    access_mode := $pft$usage_selections [];

    node := pvt [p$access_modes].value;
    WHILE node <> NIL DO
      IF node^.element_value^.keyword_value = 'ALL' THEN
        access_mode := -$pft$usage_selections [];
      ELSEIF node^.element_value^.keyword_value = 'APPEND' THEN
        access_mode := access_mode + $pft$usage_selections [pfc$append];
      ELSEIF node^.element_value^.keyword_value = 'EXECUTE' THEN
        access_mode := access_mode + $pft$usage_selections [pfc$execute];
      ELSEIF node^.element_value^.keyword_value = 'MODIFY' THEN
        access_mode := access_mode + $pft$usage_selections [pfc$modify];
      ELSEIF node^.element_value^.keyword_value = 'READ' THEN
        access_mode := access_mode + $pft$usage_selections [pfc$read];
      ELSEIF node^.element_value^.keyword_value = 'SHORTEN' THEN
        access_mode := access_mode + $pft$usage_selections [pfc$shorten];
      ELSEIF node^.element_value^.keyword_value = 'WRITE' THEN
        access_mode := access_mode + $pft$usage_selections [pfc$append, pfc$modify, pfc$shorten];
      IFEND;
      node := node^.link;
    WHILEND;

    clp$make_boolean_value (access_mode <= file_attribute [1].global_access_mode, clc$true_false_boolean,
          work_area, result);
    IF result = NIL THEN
      osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
    IFEND;

  PROCEND clp$$access_mode;

MODEND clm$display_file_attb_command;
