?? RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE SCL Interpreter : Set / Change File Attribute Commands' ??
MODULE clm$file_command;

{
{ PURPOSE:
{   This module contains the processors for the SET_FILE_ATTRIBUTES and
{   CHANGE_FILE_ATTRIBUTES commands.
{

?? NEWTITLE := 'Global Declarations', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc ame$tape_program_actions
*copyc amt$error_count
*copyc clc$standard_file_names
*copyc cle$all_must_be_used_alone
*copyc cle$none_must_be_used_alone
*copyc clt$parameter_list
*copyc fst$evaluated_file_reference
*copyc ost$status
*copyc pfe$error_condition_codes
?? POP ??
*copyc amp$change_file_attributes
*copyc avp$removable_media_admin
*copyc bap$change_default_file_attribs
*copyc bap$file_command
*copyc bap$set_file_reference_abnormal
*copyc clp$convert_str_to_path_handle
*copyc clp$evaluate_file_reference
*copyc clp$evaluate_parameters
*copyc clp$find_current_block
*copyc clp$get_work_area
*copyc clp$verify_time_increment
*copyc fsp$path_element
*copyc nfp$check_implicit_access
*copyc nfp$perform_implicit_access
*copyc osp$append_status_file
*copyc osp$set_status_abnormal
*copyc pmp$compute_date_time
*copyc pmp$get_compact_date_time
*copyc pmp$verify_compact_date
*copyc pmp$verify_compact_time
?? TITLE := 'clp$_set_file_attributes', EJECT ??

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

{ PROCEDURE (osm$setfa) set_file_attributes, set_file_attribute, setfa (
{   file, f: file = $required
{   access_modes, access_mode, am: (BY_NAME) list of key
{       none, read, execute, append, modify, shorten, write
{     keyend = $optional
{   average_record_length, arl: (BY_NAME) integer 1..amc$maximum_record = $optional
{   block_type, bt: (BY_NAME) key
{       (user_specified, us)
{       (system_specified, ss)
{     keyend = $optional
{   character_conversion, cc: (BY_NAME) boolean = $optional
{   collate_table_name, ctn: (BY_NAME) any of
{       key
{         none
{       keyend
{       name
{     anyend = $optional
{   compression_procedure_name, cpn: (BY_NAME) any of
{       key
{         none
{       keyend
{       entry_point_reference
{     anyend = $optional
{   data_padding, dp: (BY_NAME) integer 0..99 = $optional
{   dynamic_home_block_space, dhbs: (BY_NAME) boolean = $optional
{   embedded_key, ek: (BY_NAME) boolean = $optional
{   error_exit_procedure_name, eepn, error_exit_name, een: (BY_NAME) any of
{       key
{         none
{       keyend
{       name
{     anyend = $optional
{   error_limit, el: (BY_NAME) integer 0..amc$max_error_count = $optional
{   estimated_record_count, erc: (BY_NAME) integer 0..amc$file_byte_limit = $optional
{   file_access_procedure_name, fapn, file_access_procedure, fap: (BY_NAME) any of
{       key
{         none
{       keyend
{       name
{     anyend = $optional
{   file_contents, file_content, fc: (BY_NAME) any of
{       key
{         ascii_log, binary_log, data, file_backup, legible_data, legible_library, legible_scl_include
{         legible_scl_job, legible_scl_procedure, list, object_data, object_library, screen_form, source_map
{         unknown
{       keyend
{       name
{     anyend = $optional
{   file_label_type, flt: (BY_NAME) any of
{       key
{         (labeled, labelled, l)
{         (unlabeled, unlabelled, u)
{       advanced_key
{         (non_standard_labeled, nsl)
{       keyend
{     anyend = $optional
{   file_limit, fl: (BY_NAME) integer 0..amc$file_byte_limit = $optional
{   file_organization, fo: (BY_NAME) key
{       (sequential, sq)
{       (byte_addressable, ba)
{       (indexed_sequential, is)
{       (direct_access, da)
{       (system_key, sk)
{     keyend = $optional
{   file_processor, fp: (BY_NAME) any of
{       key
{         ada, apl, assembler, basic, c, cobol, cybil, debugger, fortran, lisp, pascal, pli, ppu_assembler
{         prolog, scl, scu, vs, unknown
{       keyend
{       name
{     anyend = $optional
{   file_structure, fs: (BY_NAME, HIDDEN) any of
{       key
{         data, library, unknown
{       keyend
{       name
{     anyend = $optional
{   forced_write, fw: (BY_NAME) any of
{       key
{         (forced_if_structure_change, fisc)
{       keyend
{       boolean
{     anyend = $optional
{   hashing_procedure_name, hpn: (BY_NAME) any of
{       key
{         none
{       keyend
{       entry_point_reference
{     anyend = $optional
{   index_levels, index_level, il: (BY_NAME) integer 0..amc$max_index_level = $optional
{   initial_home_block_count, ihbc: (BY_NAME) integer 1..amc$max_home_blocks = $optional
{   index_padding, ip: (BY_NAME) integer 0..99 = $optional
{   internal_code, ic: (BY_NAME) key
{       a6, a8, ascii, d63, d64, ebcdic, ftam1_general, ftam1_graphic, ftam1_ia5, ftam1_visible, ftam2_general
{       ftam2_graphic, ftam2_ia5, ftam2_visible
{     keyend = $optional
{   key_length, kl: (BY_NAME) integer 1..amc$max_key_length = $optional
{   key_position, kp: (BY_NAME) integer 0..amc$max_key_position = $optional
{   key_type, kt: (BY_NAME) key
{       (integer, i)
{       (collated, c)
{       (uncollated, uc)
{     keyend = $optional
{   line_number, ln: (BY_NAME) record
{       location: integer 1..amc$max_page_width
{       length: integer 1..amc$max_line_number
{     recend = $optional
{   loading_factor, lf: (BY_NAME) integer 0..100 = $optional
{   lock_expiration_time, let: (BY_NAME) integer 0..604800000 = $optional
{   logging_options, logging_option, lo: (BY_NAME) list of key
{       (enable_parcels, ep)
{       (enable_media_recovery, emr)
{       (enable_request_recovery, err)
{       all, none
{     keyend = $optional
{   log_residence, lr: (BY_NAME) any of
{       key
{         none
{       keyend
{       file
{     anyend = $optional
{   maximum_block_length, maxbl: (BY_NAME) integer 1..amc$maximum_block-1 = $optional
{   maximum_record_length, maxrl: (BY_NAME) integer 0..amc$maximum_record = $optional
{   message_control, mc: (BY_NAME) list of key
{       (messages, m)
{       (statistics, s)
{       (trivial_errors, t)
{       none
{     keyend = $optional
{   minimum_block_length, minbl: (BY_NAME) integer 1..amc$maximum_block-1 = $optional
{   minimum_record_length, minrl: (BY_NAME) integer 0..amc$maximum_record = $optional
{   open_position, op: (BY_NAME) key
{       $asis, $boi, $bop, $eoi
{     keyend = $optional
{   padding_character, pc: (BY_NAME) any of
{       name 1..1
{       string 1
{     anyend = $optional
{   page_format, pf: (BY_NAME) key
{       (burstable, b)
{       (continuous, c)
{       (non_burstable, nb)
{       (untitled, u)
{     keyend = $optional
{   page_length, pl: (BY_NAME) integer 1..amc$file_byte_limit = $optional
{   page_width, pw: (BY_NAME) integer 1..amc$max_page_width = $optional
{   preset_value, pv: (BY_NAME) integer = $optional
{   record_limit, rl: (BY_NAME) integer 1..amc$file_byte_limit = $optional
{   record_type, rt: (BY_NAME) key
{       (ansi_fixed, fixed, f, af)
{       (ansi_spanned, s, as)
{       (ansi_variable, d, av)
{       (variable, v)
{       (undefined, u)
{       (trailing_character_delimited, tcd, trailing, t)
{     keyend = $optional
{   records_per_block, rpb: (BY_NAME) integer 1..amc$max_records_per_block = $optional
{   statement_identifier, si: (BY_NAME) record
{       location: integer 1..amc$max_page_width
{       length: integer 1..amc$max_statement_id_length
{     recend = $optional
{   user_information, ui: (BY_NAME) string 0..amc$max_user_info = $optional
{   status)

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

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 109] of clt$pdt_parameter_name,
      parameters: array [1 .. 51] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
      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 .. 7] of clt$keyword_specification,
        recend,
      recend,
      type3: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type4: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 4] of clt$keyword_specification,
      recend,
      type5: record
        header: clt$type_specification_header,
      recend,
      type6: 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,
      recend,
      type7: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 1] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
        recend,
      recend,
      type8: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type9: record
        header: clt$type_specification_header,
      recend,
      type10: record
        header: clt$type_specification_header,
      recend,
      type11: 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,
      recend,
      type12: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type13: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type14: 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,
      recend,
      type15: 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 .. 15] 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,
      recend,
      type16: 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 .. 8] of clt$keyword_specification,
        recend,
      recend,
      type17: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type18: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 10] of clt$keyword_specification,
      recend,
      type19: 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 .. 18] 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,
      recend,
      type20: 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$name_type_qualifier,
        recend,
      recend,
      type21: 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 .. 2] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
        recend,
      recend,
      type22: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 1] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
        recend,
      recend,
      type23: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type24: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type25: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type26: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 14] of clt$keyword_specification,
      recend,
      type27: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type28: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type29: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 6] of clt$keyword_specification,
      recend,
      type30: record
        header: clt$type_specification_header,
        qualifier: clt$record_type_qualifier,
        field_spec_1: clt$field_specification,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$integer_type_qualifier,
        recend,
        field_spec_2: clt$field_specification,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$integer_type_qualifier,
        recend,
      recend,
      type31: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type32: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type33: 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 .. 8] of clt$keyword_specification,
        recend,
      recend,
      type34: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 1] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
        recend,
      recend,
      type35: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type36: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type37: 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 .. 7] of clt$keyword_specification,
        recend,
      recend,
      type38: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type39: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type40: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 4] of clt$keyword_specification,
      recend,
      type41: 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$name_type_qualifier,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$string_type_qualifier,
        recend,
      recend,
      type42: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 8] of clt$keyword_specification,
      recend,
      type43: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type44: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type45: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type46: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type47: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 18] of clt$keyword_specification,
      recend,
      type48: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type49: record
        header: clt$type_specification_header,
        qualifier: clt$record_type_qualifier,
        field_spec_1: clt$field_specification,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$integer_type_qualifier,
        recend,
        field_spec_2: clt$field_specification,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$integer_type_qualifier,
        recend,
      recend,
      type50: record
        header: clt$type_specification_header,
        qualifier: clt$string_type_qualifier,
      recend,
      type51: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [92, 10, 13, 11, 30, 8, 616],
    clc$command, 109, 51, 1, 0, 1, 0, 51, 'OSM$SETFA'], [
    ['ACCESS_MODE                    ',clc$alias_entry, 2],
    ['ACCESS_MODES                   ',clc$nominal_entry, 2],
    ['AM                             ',clc$abbreviation_entry, 2],
    ['ARL                            ',clc$abbreviation_entry, 3],
    ['AVERAGE_RECORD_LENGTH          ',clc$nominal_entry, 3],
    ['BLOCK_TYPE                     ',clc$nominal_entry, 4],
    ['BT                             ',clc$abbreviation_entry, 4],
    ['CC                             ',clc$abbreviation_entry, 5],
    ['CHARACTER_CONVERSION           ',clc$nominal_entry, 5],
    ['COLLATE_TABLE_NAME             ',clc$nominal_entry, 6],
    ['COMPRESSION_PROCEDURE_NAME     ',clc$nominal_entry, 7],
    ['CPN                            ',clc$abbreviation_entry, 7],
    ['CTN                            ',clc$abbreviation_entry, 6],
    ['DATA_PADDING                   ',clc$nominal_entry, 8],
    ['DHBS                           ',clc$abbreviation_entry, 9],
    ['DP                             ',clc$abbreviation_entry, 8],
    ['DYNAMIC_HOME_BLOCK_SPACE       ',clc$nominal_entry, 9],
    ['EEN                            ',clc$abbreviation_entry, 11],
    ['EEPN                           ',clc$alias_entry, 11],
    ['EK                             ',clc$abbreviation_entry, 10],
    ['EL                             ',clc$abbreviation_entry, 12],
    ['EMBEDDED_KEY                   ',clc$nominal_entry, 10],
    ['ERC                            ',clc$abbreviation_entry, 13],
    ['ERROR_EXIT_NAME                ',clc$alias_entry, 11],
    ['ERROR_EXIT_PROCEDURE_NAME      ',clc$nominal_entry, 11],
    ['ERROR_LIMIT                    ',clc$nominal_entry, 12],
    ['ESTIMATED_RECORD_COUNT         ',clc$nominal_entry, 13],
    ['F                              ',clc$abbreviation_entry, 1],
    ['FAP                            ',clc$abbreviation_entry, 14],
    ['FAPN                           ',clc$alias_entry, 14],
    ['FC                             ',clc$abbreviation_entry, 15],
    ['FILE                           ',clc$nominal_entry, 1],
    ['FILE_ACCESS_PROCEDURE          ',clc$alias_entry, 14],
    ['FILE_ACCESS_PROCEDURE_NAME     ',clc$nominal_entry, 14],
    ['FILE_CONTENT                   ',clc$alias_entry, 15],
    ['FILE_CONTENTS                  ',clc$nominal_entry, 15],
    ['FILE_LABEL_TYPE                ',clc$nominal_entry, 16],
    ['FILE_LIMIT                     ',clc$nominal_entry, 17],
    ['FILE_ORGANIZATION              ',clc$nominal_entry, 18],
    ['FILE_PROCESSOR                 ',clc$nominal_entry, 19],
    ['FILE_STRUCTURE                 ',clc$nominal_entry, 20],
    ['FL                             ',clc$abbreviation_entry, 17],
    ['FLT                            ',clc$abbreviation_entry, 16],
    ['FO                             ',clc$abbreviation_entry, 18],
    ['FORCED_WRITE                   ',clc$nominal_entry, 21],
    ['FP                             ',clc$abbreviation_entry, 19],
    ['FS                             ',clc$abbreviation_entry, 20],
    ['FW                             ',clc$abbreviation_entry, 21],
    ['HASHING_PROCEDURE_NAME         ',clc$nominal_entry, 22],
    ['HPN                            ',clc$abbreviation_entry, 22],
    ['IC                             ',clc$abbreviation_entry, 26],
    ['IHBC                           ',clc$abbreviation_entry, 24],
    ['IL                             ',clc$abbreviation_entry, 23],
    ['INDEX_LEVEL                    ',clc$alias_entry, 23],
    ['INDEX_LEVELS                   ',clc$nominal_entry, 23],
    ['INDEX_PADDING                  ',clc$nominal_entry, 25],
    ['INITIAL_HOME_BLOCK_COUNT       ',clc$nominal_entry, 24],
    ['INTERNAL_CODE                  ',clc$nominal_entry, 26],
    ['IP                             ',clc$abbreviation_entry, 25],
    ['KEY_LENGTH                     ',clc$nominal_entry, 27],
    ['KEY_POSITION                   ',clc$nominal_entry, 28],
    ['KEY_TYPE                       ',clc$nominal_entry, 29],
    ['KL                             ',clc$abbreviation_entry, 27],
    ['KP                             ',clc$abbreviation_entry, 28],
    ['KT                             ',clc$abbreviation_entry, 29],
    ['LET                            ',clc$abbreviation_entry, 32],
    ['LF                             ',clc$abbreviation_entry, 31],
    ['LINE_NUMBER                    ',clc$nominal_entry, 30],
    ['LN                             ',clc$abbreviation_entry, 30],
    ['LO                             ',clc$abbreviation_entry, 33],
    ['LOADING_FACTOR                 ',clc$nominal_entry, 31],
    ['LOCK_EXPIRATION_TIME           ',clc$nominal_entry, 32],
    ['LOGGING_OPTION                 ',clc$alias_entry, 33],
    ['LOGGING_OPTIONS                ',clc$nominal_entry, 33],
    ['LOG_RESIDENCE                  ',clc$nominal_entry, 34],
    ['LR                             ',clc$abbreviation_entry, 34],
    ['MAXBL                          ',clc$abbreviation_entry, 35],
    ['MAXIMUM_BLOCK_LENGTH           ',clc$nominal_entry, 35],
    ['MAXIMUM_RECORD_LENGTH          ',clc$nominal_entry, 36],
    ['MAXRL                          ',clc$abbreviation_entry, 36],
    ['MC                             ',clc$abbreviation_entry, 37],
    ['MESSAGE_CONTROL                ',clc$nominal_entry, 37],
    ['MINBL                          ',clc$abbreviation_entry, 38],
    ['MINIMUM_BLOCK_LENGTH           ',clc$nominal_entry, 38],
    ['MINIMUM_RECORD_LENGTH          ',clc$nominal_entry, 39],
    ['MINRL                          ',clc$abbreviation_entry, 39],
    ['OP                             ',clc$abbreviation_entry, 40],
    ['OPEN_POSITION                  ',clc$nominal_entry, 40],
    ['PADDING_CHARACTER              ',clc$nominal_entry, 41],
    ['PAGE_FORMAT                    ',clc$nominal_entry, 42],
    ['PAGE_LENGTH                    ',clc$nominal_entry, 43],
    ['PAGE_WIDTH                     ',clc$nominal_entry, 44],
    ['PC                             ',clc$abbreviation_entry, 41],
    ['PF                             ',clc$abbreviation_entry, 42],
    ['PL                             ',clc$abbreviation_entry, 43],
    ['PRESET_VALUE                   ',clc$nominal_entry, 45],
    ['PV                             ',clc$abbreviation_entry, 45],
    ['PW                             ',clc$abbreviation_entry, 44],
    ['RECORDS_PER_BLOCK              ',clc$nominal_entry, 48],
    ['RECORD_LIMIT                   ',clc$nominal_entry, 46],
    ['RECORD_TYPE                    ',clc$nominal_entry, 47],
    ['RL                             ',clc$abbreviation_entry, 46],
    ['RPB                            ',clc$abbreviation_entry, 48],
    ['RT                             ',clc$abbreviation_entry, 47],
    ['SI                             ',clc$abbreviation_entry, 49],
    ['STATEMENT_IDENTIFIER           ',clc$nominal_entry, 49],
    ['STATUS                         ',clc$nominal_entry, 51],
    ['UI                             ',clc$abbreviation_entry, 50],
    ['USER_INFORMATION               ',clc$nominal_entry, 50]],
    [
{ PARAMETER 1
    [32, 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$required_parameter, 0
  , 0],
{ PARAMETER 2
    [2, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 282,
  clc$optional_parameter, 0, 0],
{ PARAMETER 3
    [5, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 4
    [6, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 155,
  clc$optional_parameter, 0, 0],
{ PARAMETER 5
    [9, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$optional_parameter, 0
  , 0],
{ PARAMETER 6
    [10, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 69, clc$optional_parameter,
  0, 0],
{ PARAMETER 7
    [11, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 67, clc$optional_parameter,
  0, 0],
{ PARAMETER 8
    [14, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 9
    [17, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$optional_parameter, 0
  , 0],
{ PARAMETER 10
    [22, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$optional_parameter, 0
  , 0],
{ PARAMETER 11
    [25, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 69, clc$optional_parameter,
  0, 0],
{ PARAMETER 12
    [26, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 13
    [27, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 14
    [34, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 69, clc$optional_parameter,
  0, 0],
{ PARAMETER 15
    [36, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 587,
  clc$optional_parameter, 0, 0],
{ PARAMETER 16
    [37, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 319,
  clc$optional_parameter, 0, 0],
{ PARAMETER 17
    [38, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 18
    [39, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 377,
  clc$optional_parameter, 0, 0],
{ PARAMETER 19
    [40, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 698,
  clc$optional_parameter, 0, 0],
{ PARAMETER 20
    [41, clc$hidden_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 143,
  clc$optional_parameter, 0, 0],
{ PARAMETER 21
    [45, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 104,
  clc$optional_parameter, 0, 0],
{ PARAMETER 22
    [49, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 67, clc$optional_parameter,
  0, 0],
{ PARAMETER 23
    [55, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 24
    [57, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 25
    [56, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 26
    [58, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 525,
  clc$optional_parameter, 0, 0],
{ PARAMETER 27
    [60, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 28
    [61, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 29
    [62, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 229,
  clc$optional_parameter, 0, 0],
{ PARAMETER 30
    [68, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 119,
  clc$optional_parameter, 0, 0],
{ PARAMETER 31
    [71, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 32
    [72, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 33
    [74, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 319,
  clc$optional_parameter, 0, 0],
{ PARAMETER 34
    [75, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 67, clc$optional_parameter,
  0, 0],
{ PARAMETER 35
    [78, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 36
    [79, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 37
    [82, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 282,
  clc$optional_parameter, 0, 0],
{ PARAMETER 38
    [84, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 39
    [85, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 40
    [88, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 155,
  clc$optional_parameter, 0, 0],
{ PARAMETER 41
    [89, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 33, clc$optional_parameter,
  0, 0],
{ PARAMETER 42
    [90, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 303,
  clc$optional_parameter, 0, 0],
{ PARAMETER 43
    [91, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 44
    [92, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 45
    [96, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 46
    [100, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 47
    [101, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 673,
  clc$optional_parameter, 0, 0],
{ PARAMETER 48
    [99, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 49
    [106, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 119,
  clc$optional_parameter, 0, 0],
{ PARAMETER 50
    [109, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 8, clc$optional_parameter, 0
  , 0],
{ PARAMETER 51
    [107, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$file_type]],
{ PARAMETER 2
    [[1, 0, clc$list_type], [266, 1, clc$max_list_size, 0, FALSE, FALSE],
      [[1, 0, clc$keyword_type], [7], [
      ['APPEND                         ', clc$nominal_entry, clc$normal_usage_entry, 4],
      ['EXECUTE                        ', clc$nominal_entry, clc$normal_usage_entry, 3],
      ['MODIFY                         ', clc$nominal_entry, clc$normal_usage_entry, 5],
      ['NONE                           ', clc$nominal_entry, clc$normal_usage_entry, 1],
      ['READ                           ', clc$nominal_entry, clc$normal_usage_entry, 2],
      ['SHORTEN                        ', clc$nominal_entry, clc$normal_usage_entry, 6],
      ['WRITE                          ', clc$nominal_entry, clc$normal_usage_entry, 7]]
      ]
    ],
{ PARAMETER 3
    [[1, 0, clc$integer_type], [1, amc$maximum_record, 10]],
{ PARAMETER 4
    [[1, 0, clc$keyword_type], [4], [
    ['SS                             ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
    ['SYSTEM_SPECIFIED               ', clc$nominal_entry, clc$normal_usage_entry, 2],
    ['US                             ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
    ['USER_SPECIFIED                 ', clc$nominal_entry, clc$normal_usage_entry, 1]]
    ],
{ PARAMETER 5
    [[1, 0, clc$boolean_type]],
{ PARAMETER 6
    [[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]]
    ],
{ PARAMETER 7
    [[1, 0, clc$union_type], [[clc$entry_point_reference_type, clc$keyword_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['NONE                           ', clc$nominal_entry, clc$normal_usage_entry, 1]]
      ],
    3, [[1, 0, clc$entry_point_reference_type]]
    ],
{ PARAMETER 8
    [[1, 0, clc$integer_type], [0, 99, 10]],
{ PARAMETER 9
    [[1, 0, clc$boolean_type]],
{ PARAMETER 10
    [[1, 0, clc$boolean_type]],
{ PARAMETER 11
    [[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]]
    ],
{ PARAMETER 12
    [[1, 0, clc$integer_type], [0, amc$max_error_count, 10]],
{ PARAMETER 13
    [[1, 0, clc$integer_type], [0, amc$file_byte_limit, 10]],
{ PARAMETER 14
    [[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]]
    ],
{ PARAMETER 15
    [[1, 0, clc$union_type], [[clc$keyword_type, clc$name_type],
    FALSE, 2],
    562, [[1, 0, clc$keyword_type], [15], [
      ['ASCII_LOG                      ', clc$nominal_entry, clc$normal_usage_entry, 1],
      ['BINARY_LOG                     ', clc$nominal_entry, clc$normal_usage_entry, 2],
      ['DATA                           ', clc$nominal_entry, clc$normal_usage_entry, 3],
      ['FILE_BACKUP                    ', clc$nominal_entry, clc$normal_usage_entry, 4],
      ['LEGIBLE_DATA                   ', clc$nominal_entry, clc$normal_usage_entry, 5],
      ['LEGIBLE_LIBRARY                ', clc$nominal_entry, clc$normal_usage_entry, 6],
      ['LEGIBLE_SCL_INCLUDE            ', clc$nominal_entry, clc$normal_usage_entry, 7],
      ['LEGIBLE_SCL_JOB                ', clc$nominal_entry, clc$normal_usage_entry, 8],
      ['LEGIBLE_SCL_PROCEDURE          ', clc$nominal_entry, clc$normal_usage_entry, 9],
      ['LIST                           ', clc$nominal_entry, clc$normal_usage_entry, 10],
      ['OBJECT_DATA                    ', clc$nominal_entry, clc$normal_usage_entry, 11],
      ['OBJECT_LIBRARY                 ', clc$nominal_entry, clc$normal_usage_entry, 12],
      ['SCREEN_FORM                    ', clc$nominal_entry, clc$normal_usage_entry, 13],
      ['SOURCE_MAP                     ', clc$nominal_entry, clc$normal_usage_entry, 14],
      ['UNKNOWN                        ', clc$nominal_entry, clc$normal_usage_entry, 15]]
      ],
    5, [[1, 0, clc$name_type], [1, osc$max_name_size]]
    ],
{ PARAMETER 16
    [[1, 0, clc$union_type], [[clc$keyword_type],
    FALSE, 1],
    303, [[1, 0, clc$keyword_type], [8], [
      ['L                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
      ['LABELED                        ', clc$nominal_entry, clc$normal_usage_entry, 1],
      ['LABELLED                       ', clc$alias_entry, clc$normal_usage_entry, 1],
      ['NON_STANDARD_LABELED           ', clc$nominal_entry, clc$advanced_usage_entry, 3],
      ['NSL                            ', clc$abbreviation_entry, clc$advanced_usage_entry, 3],
      ['U                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
      ['UNLABELED                      ', clc$nominal_entry, clc$normal_usage_entry, 2],
      ['UNLABELLED                     ', clc$alias_entry, clc$normal_usage_entry, 2]]
      ]
    ],
{ PARAMETER 17
    [[1, 0, clc$integer_type], [0, amc$file_byte_limit, 10]],
{ PARAMETER 18
    [[1, 0, clc$keyword_type], [10], [
    ['BA                             ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
    ['BYTE_ADDRESSABLE               ', clc$nominal_entry, clc$normal_usage_entry, 2],
    ['DA                             ', clc$abbreviation_entry, clc$normal_usage_entry, 4],
    ['DIRECT_ACCESS                  ', clc$nominal_entry, clc$normal_usage_entry, 4],
    ['INDEXED_SEQUENTIAL             ', clc$nominal_entry, clc$normal_usage_entry, 3],
    ['IS                             ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
    ['SEQUENTIAL                     ', clc$nominal_entry, clc$normal_usage_entry, 1],
    ['SK                             ', clc$abbreviation_entry, clc$normal_usage_entry, 5],
    ['SQ                             ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
    ['SYSTEM_KEY                     ', clc$nominal_entry, clc$normal_usage_entry, 5]]
    ],
{ PARAMETER 19
    [[1, 0, clc$union_type], [[clc$keyword_type, clc$name_type],
    FALSE, 2],
    673, [[1, 0, clc$keyword_type], [18], [
      ['ADA                            ', clc$nominal_entry, clc$normal_usage_entry, 1],
      ['APL                            ', clc$nominal_entry, clc$normal_usage_entry, 2],
      ['ASSEMBLER                      ', clc$nominal_entry, clc$normal_usage_entry, 3],
      ['BASIC                          ', clc$nominal_entry, clc$normal_usage_entry, 4],
      ['C                              ', clc$nominal_entry, clc$normal_usage_entry, 5],
      ['COBOL                          ', clc$nominal_entry, clc$normal_usage_entry, 6],
      ['CYBIL                          ', clc$nominal_entry, clc$normal_usage_entry, 7],
      ['DEBUGGER                       ', clc$nominal_entry, clc$normal_usage_entry, 8],
      ['FORTRAN                        ', clc$nominal_entry, clc$normal_usage_entry, 9],
      ['LISP                           ', clc$nominal_entry, clc$normal_usage_entry, 10],
      ['PASCAL                         ', clc$nominal_entry, clc$normal_usage_entry, 11],
      ['PLI                            ', clc$nominal_entry, clc$normal_usage_entry, 12],
      ['PPU_ASSEMBLER                  ', clc$nominal_entry, clc$normal_usage_entry, 13],
      ['PROLOG                         ', clc$nominal_entry, clc$normal_usage_entry, 14],
      ['SCL                            ', clc$nominal_entry, clc$normal_usage_entry, 15],
      ['SCU                            ', clc$nominal_entry, clc$normal_usage_entry, 16],
      ['UNKNOWN                        ', clc$nominal_entry, clc$normal_usage_entry, 18],
      ['VS                             ', clc$nominal_entry, clc$normal_usage_entry, 17]]
      ],
    5, [[1, 0, clc$name_type], [1, osc$max_name_size]]
    ],
{ PARAMETER 20
    [[1, 0, clc$union_type], [[clc$keyword_type, clc$name_type],
    FALSE, 2],
    118, [[1, 0, clc$keyword_type], [3], [
      ['DATA                           ', clc$nominal_entry, clc$normal_usage_entry, 1],
      ['LIBRARY                        ', clc$nominal_entry, clc$normal_usage_entry, 2],
      ['UNKNOWN                        ', clc$nominal_entry, clc$normal_usage_entry, 3]]
      ],
    5, [[1, 0, clc$name_type], [1, osc$max_name_size]]
    ],
{ PARAMETER 21
    [[1, 0, clc$union_type], [[clc$boolean_type, clc$keyword_type],
    FALSE, 2],
    81, [[1, 0, clc$keyword_type], [2], [
      ['FISC                           ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
      ['FORCED_IF_STRUCTURE_CHANGE     ', clc$nominal_entry, clc$normal_usage_entry, 1]]
      ],
    3, [[1, 0, clc$boolean_type]]
    ],
{ PARAMETER 22
    [[1, 0, clc$union_type], [[clc$entry_point_reference_type, clc$keyword_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['NONE                           ', clc$nominal_entry, clc$normal_usage_entry, 1]]
      ],
    3, [[1, 0, clc$entry_point_reference_type]]
    ],
{ PARAMETER 23
    [[1, 0, clc$integer_type], [0, amc$max_index_level, 10]],
{ PARAMETER 24
    [[1, 0, clc$integer_type], [1, amc$max_home_blocks, 10]],
{ PARAMETER 25
    [[1, 0, clc$integer_type], [0, 99, 10]],
{ PARAMETER 26
    [[1, 0, clc$keyword_type], [14], [
    ['A6                             ', clc$nominal_entry, clc$normal_usage_entry, 1],
    ['A8                             ', clc$nominal_entry, clc$normal_usage_entry, 2],
    ['ASCII                          ', clc$nominal_entry, clc$normal_usage_entry, 3],
    ['D63                            ', clc$nominal_entry, clc$normal_usage_entry, 4],
    ['D64                            ', clc$nominal_entry, clc$normal_usage_entry, 5],
    ['EBCDIC                         ', clc$nominal_entry, clc$normal_usage_entry, 6],
    ['FTAM1_GENERAL                  ', clc$nominal_entry, clc$normal_usage_entry, 7],
    ['FTAM1_GRAPHIC                  ', clc$nominal_entry, clc$normal_usage_entry, 8],
    ['FTAM1_IA5                      ', clc$nominal_entry, clc$normal_usage_entry, 9],
    ['FTAM1_VISIBLE                  ', clc$nominal_entry, clc$normal_usage_entry, 10],
    ['FTAM2_GENERAL                  ', clc$nominal_entry, clc$normal_usage_entry, 11],
    ['FTAM2_GRAPHIC                  ', clc$nominal_entry, clc$normal_usage_entry, 12],
    ['FTAM2_IA5                      ', clc$nominal_entry, clc$normal_usage_entry, 13],
    ['FTAM2_VISIBLE                  ', clc$nominal_entry, clc$normal_usage_entry, 14]]
    ],
{ PARAMETER 27
    [[1, 0, clc$integer_type], [1, amc$max_key_length, 10]],
{ PARAMETER 28
    [[1, 0, clc$integer_type], [0, amc$max_key_position, 10]],
{ PARAMETER 29
    [[1, 0, clc$keyword_type], [6], [
    ['C                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
    ['COLLATED                       ', clc$nominal_entry, clc$normal_usage_entry, 2],
    ['I                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
    ['INTEGER                        ', clc$nominal_entry, clc$normal_usage_entry, 1],
    ['UC                             ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
    ['UNCOLLATED                     ', clc$nominal_entry, clc$normal_usage_entry, 3]]
    ],
{ PARAMETER 30
    [[1, 0, clc$record_type], [2],
    ['LOCATION                       ', clc$required_field, 20], [[1, 0, clc$integer_type], [1,
  amc$max_page_width, 10]],
    ['LENGTH                         ', clc$required_field, 20], [[1, 0, clc$integer_type], [1,
  amc$max_line_number, 10]]
    ],
{ PARAMETER 31
    [[1, 0, clc$integer_type], [0, 100, 10]],
{ PARAMETER 32
    [[1, 0, clc$integer_type], [0, 604800000, 10]],
{ PARAMETER 33
    [[1, 0, clc$list_type], [303, 1, clc$max_list_size, 0, FALSE, FALSE],
      [[1, 0, clc$keyword_type], [8], [
      ['ALL                            ', clc$nominal_entry, clc$normal_usage_entry, 4],
      ['EMR                            ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
      ['ENABLE_MEDIA_RECOVERY          ', clc$nominal_entry, clc$normal_usage_entry, 2],
      ['ENABLE_PARCELS                 ', clc$nominal_entry, clc$normal_usage_entry, 1],
      ['ENABLE_REQUEST_RECOVERY        ', clc$nominal_entry, clc$normal_usage_entry, 3],
      ['EP                             ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
      ['ERR                            ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
      ['NONE                           ', clc$nominal_entry, clc$normal_usage_entry, 5]]
      ]
    ],
{ PARAMETER 34
    [[1, 0, clc$union_type], [[clc$file_type, clc$keyword_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['NONE                           ', clc$nominal_entry, clc$normal_usage_entry, 1]]
      ],
    3, [[1, 0, clc$file_type]]
    ],
{ PARAMETER 35
    [[1, 0, clc$integer_type], [1, amc$maximum_block-1, 10]],
{ PARAMETER 36
    [[1, 0, clc$integer_type], [0, amc$maximum_record, 10]],
{ PARAMETER 37
    [[1, 0, clc$list_type], [266, 1, clc$max_list_size, 0, FALSE, FALSE],
      [[1, 0, clc$keyword_type], [7], [
      ['M                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
      ['MESSAGES                       ', clc$nominal_entry, clc$normal_usage_entry, 1],
      ['NONE                           ', clc$nominal_entry, clc$normal_usage_entry, 4],
      ['S                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
      ['STATISTICS                     ', clc$nominal_entry, clc$normal_usage_entry, 2],
      ['T                              ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
      ['TRIVIAL_ERRORS                 ', clc$nominal_entry, clc$normal_usage_entry, 3]]
      ]
    ],
{ PARAMETER 38
    [[1, 0, clc$integer_type], [1, amc$maximum_block-1, 10]],
{ PARAMETER 39
    [[1, 0, clc$integer_type], [0, amc$maximum_record, 10]],
{ PARAMETER 40
    [[1, 0, clc$keyword_type], [4], [
    ['$ASIS                          ', clc$nominal_entry, clc$normal_usage_entry, 1],
    ['$BOI                           ', clc$nominal_entry, clc$normal_usage_entry, 2],
    ['$BOP                           ', clc$nominal_entry, clc$normal_usage_entry, 3],
    ['$EOI                           ', clc$nominal_entry, clc$normal_usage_entry, 4]]
    ],
{ PARAMETER 41
    [[1, 0, clc$union_type], [[clc$name_type, clc$string_type],
    FALSE, 2],
    5, [[1, 0, clc$name_type], [1, 1]],
    8, [[1, 0, clc$string_type], [1, 1, FALSE]]
    ],
{ PARAMETER 42
    [[1, 0, clc$keyword_type], [8], [
    ['B                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
    ['BURSTABLE                      ', clc$nominal_entry, clc$normal_usage_entry, 1],
    ['C                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
    ['CONTINUOUS                     ', clc$nominal_entry, clc$normal_usage_entry, 2],
    ['NB                             ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
    ['NON_BURSTABLE                  ', clc$nominal_entry, clc$normal_usage_entry, 3],
    ['U                              ', clc$abbreviation_entry, clc$normal_usage_entry, 4],
    ['UNTITLED                       ', clc$nominal_entry, clc$normal_usage_entry, 4]]
    ],
{ PARAMETER 43
    [[1, 0, clc$integer_type], [1, amc$file_byte_limit, 10]],
{ PARAMETER 44
    [[1, 0, clc$integer_type], [1, amc$max_page_width, 10]],
{ PARAMETER 45
    [[1, 0, clc$integer_type], [clc$min_integer, clc$max_integer, 10]],
{ PARAMETER 46
    [[1, 0, clc$integer_type], [1, amc$file_byte_limit, 10]],
{ PARAMETER 47
    [[1, 0, clc$keyword_type], [18], [
    ['AF                             ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
    ['ANSI_FIXED                     ', clc$nominal_entry, clc$normal_usage_entry, 1],
    ['ANSI_SPANNED                   ', clc$nominal_entry, clc$normal_usage_entry, 2],
    ['ANSI_VARIABLE                  ', clc$nominal_entry, clc$normal_usage_entry, 3],
    ['AS                             ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
    ['AV                             ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
    ['D                              ', clc$alias_entry, clc$normal_usage_entry, 3],
    ['F                              ', clc$alias_entry, clc$normal_usage_entry, 1],
    ['FIXED                          ', clc$alias_entry, clc$normal_usage_entry, 1],
    ['S                              ', clc$alias_entry, clc$normal_usage_entry, 2],
    ['T                              ', clc$abbreviation_entry, clc$normal_usage_entry, 6],
    ['TCD                            ', clc$alias_entry, clc$normal_usage_entry, 6],
    ['TRAILING                       ', clc$alias_entry, clc$normal_usage_entry, 6],
    ['TRAILING_CHARACTER_DELIMITED   ', clc$nominal_entry, clc$normal_usage_entry, 6],
    ['U                              ', clc$abbreviation_entry, clc$normal_usage_entry, 5],
    ['UNDEFINED                      ', clc$nominal_entry, clc$normal_usage_entry, 5],
    ['V                              ', clc$abbreviation_entry, clc$normal_usage_entry, 4],
    ['VARIABLE                       ', clc$nominal_entry, clc$normal_usage_entry, 4]]
    ],
{ PARAMETER 48
    [[1, 0, clc$integer_type], [1, amc$max_records_per_block, 10]],
{ PARAMETER 49
    [[1, 0, clc$record_type], [2],
    ['LOCATION                       ', clc$required_field, 20], [[1, 0, clc$integer_type], [1,
  amc$max_page_width, 10]],
    ['LENGTH                         ', clc$required_field, 20], [[1, 0, clc$integer_type], [1,
  amc$max_statement_id_length, 10]]
    ],
{ PARAMETER 50
    [[1, 0, clc$string_type], [0, amc$max_user_info, FALSE]],
{ PARAMETER 51
    [[1, 0, clc$status_type]]];

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

    CONST
      p$file = 1,
      p$access_modes = 2,
      p$average_record_length = 3,
      p$block_type = 4,
      p$character_conversion = 5,
      p$collate_table_name = 6,
      p$compression_procedure_name = 7,
      p$data_padding = 8,
      p$dynamic_home_block_space = 9,
      p$embedded_key = 10,
      p$error_exit_procedure_name = 11,
      p$error_limit = 12,
      p$estimated_record_count = 13,
      p$file_access_procedure_name = 14,
      p$file_contents = 15,
      p$file_label_type = 16,
      p$file_limit = 17,
      p$file_organization = 18,
      p$file_processor = 19,
      p$file_structure = 20,
      p$forced_write = 21,
      p$hashing_procedure_name = 22,
      p$index_levels = 23,
      p$initial_home_block_count = 24,
      p$index_padding = 25,
      p$internal_code = 26,
      p$key_length = 27,
      p$key_position = 28,
      p$key_type = 29,
      p$line_number = 30,
      p$loading_factor = 31,
      p$lock_expiration_time = 32,
      p$logging_options = 33,
      p$log_residence = 34,
      p$maximum_block_length = 35,
      p$maximum_record_length = 36,
      p$message_control = 37,
      p$minimum_block_length = 38,
      p$minimum_record_length = 39,
      p$open_position = 40,
      p$padding_character = 41,
      p$page_format = 42,
      p$page_length = 43,
      p$page_width = 44,
      p$preset_value = 45,
      p$record_limit = 46,
      p$record_type = 47,
      p$records_per_block = 48,
      p$statement_identifier = 49,
      p$user_information = 50,
      p$status = 51;

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

    VAR
      access_mode: pft$usage_selections,
      attributes: ^amt$file_attributes,
      attribute_count: 0 .. p$status - 2,
      attribute_index: 0 .. p$status - 1,
      compression_procedure_name_ptr: ^amt$compression_procedure_name,
      current_access_mode: ^clt$data_value,
      current_message: ^clt$data_value,
      evaluated_file_reference: fst$evaluated_file_reference,
      hashing_procedure_name_ptr: ^amt$hashing_procedure_name,
      label_option: amt$label_options,
      logging_options: amt$logging_options,
      log_options: ^clt$data_value,
      log_residence_ptr: ^amt$log_residence,
      message_control: amt$message_control,
      path_handle_name: fst$path_handle_name,
      remote: boolean;


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

    evaluate_path_and_handle_remote ('SET_FILE_ATTRIBUTES', pvt [p$file].value^.file_value^, ^pvt, remote,
          status);
    IF (NOT status.normal) OR remote THEN
      RETURN;
    IFEND;

    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;

  /determine_attributes/
    BEGIN

      attribute_count := 0;
      FOR attribute_index := 2 TO p$status - 1 DO
        IF pvt [attribute_index].specified THEN
          attribute_count := attribute_count + 1;
        IFEND;
      FOREND;
      IF attribute_count = 0 THEN
        attributes := NIL;
        EXIT /determine_attributes/;
      ELSE
        PUSH attributes: [1 .. attribute_count];
      IFEND;
      attribute_index := 0;

      IF pvt [p$access_modes].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$access_mode;
        attributes^ [attribute_index].access_mode := $pft$usage_selections [];

        current_access_mode := pvt [p$access_modes].value;

      /get_access_mode/
        WHILE current_access_mode <> NIL DO
          IF current_access_mode^.element_value^.keyword_value = 'APPEND' THEN
            access_mode := $pft$usage_selections [pfc$append];
          ELSEIF current_access_mode^.element_value^.keyword_value = 'EXECUTE' THEN
            access_mode := $pft$usage_selections [pfc$execute];
          ELSEIF current_access_mode^.element_value^.keyword_value = 'MODIFY' THEN
            access_mode := $pft$usage_selections [pfc$modify];
          ELSEIF current_access_mode^.element_value^.keyword_value = 'NONE' THEN
            IF pvt [p$access_modes].value^.link <> NIL THEN
              osp$set_status_abnormal ('CL', cle$none_must_be_used_alone, 'ACCESS_MODE', status);
              RETURN;
            IFEND;
            EXIT /get_access_mode/;
          ELSEIF current_access_mode^.element_value^.keyword_value = 'READ' THEN
            access_mode := $pft$usage_selections [pfc$read];
          ELSEIF current_access_mode^.element_value^.keyword_value = 'SHORTEN' THEN
            access_mode := $pft$usage_selections [pfc$shorten];
          ELSEIF current_access_mode^.element_value^.keyword_value = 'WRITE' THEN
            access_mode := $pft$usage_selections [pfc$append, pfc$modify, pfc$shorten];
          IFEND;
          attributes^ [attribute_index].access_mode := attributes^ [attribute_index].access_mode +
                access_mode;
          current_access_mode := current_access_mode^.link;
        WHILEND /get_access_mode/;
      IFEND;

      IF pvt [p$average_record_length].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$average_record_length;
        attributes^ [attribute_index].average_record_length :=
              pvt [p$average_record_length].value^.integer_value.value;
      IFEND;

      IF pvt [p$block_type].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$block_type;
        IF pvt [p$block_type].value^.keyword_value = 'USER_SPECIFIED' THEN
          attributes^ [attribute_index].block_type := amc$user_specified;
        ELSE {SYSTEM_SPECIFIED
          attributes^ [attribute_index].block_type := amc$system_specified;
        IFEND;
      IFEND;

      IF pvt [p$character_conversion].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$character_conversion;
        attributes^ [attribute_index].character_conversion :=
              pvt [p$character_conversion].value^.boolean_value.value;
      IFEND;

      IF pvt [p$collate_table_name].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$collate_table_name;
        IF pvt [p$collate_table_name].value^.kind = clc$keyword {AND keyword = NONE} THEN
          attributes^ [attribute_index].collate_table_name := osc$null_name;
        ELSE
          attributes^ [attribute_index].collate_table_name := pvt [p$collate_table_name].value^.name_value;
        IFEND;
      IFEND;

      IF pvt [p$compression_procedure_name].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$compression_procedure_name;
        PUSH compression_procedure_name_ptr;

        IF pvt [p$compression_procedure_name].value^.kind = clc$keyword {AND keyword = NONE} THEN
          compression_procedure_name_ptr^.name := osc$null_name;
          compression_procedure_name_ptr^.object_library := '';
        ELSE {clc$entry_point_reference}
          compression_procedure_name_ptr^.name := pvt [p$compression_procedure_name].value^.
                entry_point_reference_value^.entry_point;
          compression_procedure_name_ptr^.object_library := pvt [p$compression_procedure_name].value^.
                entry_point_reference_value^.object_library;
        IFEND;

        attributes^ [attribute_index].compression_procedure_name := compression_procedure_name_ptr;
      IFEND;

      IF pvt [p$data_padding].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$data_padding;
        attributes^ [attribute_index].data_padding := pvt [p$data_padding].value^.integer_value.value;
      IFEND;

      IF pvt [p$dynamic_home_block_space].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$dynamic_home_block_space;
        attributes^ [attribute_index].dynamic_home_block_space :=
              pvt [p$dynamic_home_block_space].value^.boolean_value.value;
      IFEND;

      IF pvt [p$embedded_key].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$embedded_key;
        attributes^ [attribute_index].embedded_key := pvt [p$embedded_key].value^.boolean_value.value;
      IFEND;

      IF pvt [p$error_exit_procedure_name].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$error_exit_name;
        IF pvt [p$error_exit_procedure_name].value^.kind = clc$keyword {AND keyword = NONE} THEN
          attributes^ [attribute_index].error_exit_name := osc$null_name;
        ELSE
          attributes^ [attribute_index].error_exit_name := pvt [p$error_exit_procedure_name].value^.
                name_value;
        IFEND;
      IFEND;

      IF pvt [p$error_limit].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$error_limit;
        attributes^ [attribute_index].error_limit := pvt [p$error_limit].value^.integer_value.value;
      IFEND;

      IF pvt [p$estimated_record_count].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$estimated_record_count;
        attributes^ [attribute_index].estimated_record_count :=
              pvt [p$estimated_record_count].value^.integer_value.value;
      IFEND;

      IF pvt [p$file_access_procedure_name].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$file_access_procedure;
        IF pvt [p$file_access_procedure_name].value^.kind = clc$keyword {AND keyword = NONE} THEN
          attributes^ [attribute_index].file_access_procedure := osc$null_name;
        ELSE
          attributes^ [attribute_index].file_access_procedure :=
                pvt [p$file_access_procedure_name].value^.name_value;
        IFEND;
      IFEND;

      IF pvt [p$file_contents].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$file_contents;
        IF pvt [p$file_contents].value^.kind = clc$keyword {AND keyword = NONE} THEN
          attributes^ [attribute_index].file_contents := pvt [p$file_contents].value^.keyword_value;
        ELSE
          attributes^ [attribute_index].file_contents := pvt [p$file_contents].value^.name_value;
        IFEND;
      IFEND;

      IF pvt [p$file_label_type].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$label_type;
        IF pvt [p$file_label_type].value^.keyword_value = 'LABELED' THEN
          attributes^ [attribute_index].label_type := amc$labelled;
        ELSEIF pvt [p$file_label_type].value^.keyword_value = 'UNLABELED' THEN
          attributes^ [attribute_index].label_type := amc$unlabelled;
        ELSEIF pvt [p$file_label_type].value^.keyword_value = 'NON_STANDARD_LABELED' THEN
          IF avp$removable_media_admin () THEN
            attributes^ [attribute_index].label_type := amc$non_standard_labelled;
          ELSE
            bap$set_file_reference_abnormal (pvt [p$file].value^.file_value^, ame$security_conflict,
                  '', 'FILE_LABEL_TYPE', status);
            RETURN;
          IFEND;
        IFEND;
      IFEND;

      IF pvt [p$file_limit].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$file_limit;
        attributes^ [attribute_index].file_limit := pvt [p$file_limit].value^.integer_value.value;
      IFEND;

      IF pvt [p$file_organization].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$file_organization;
        IF pvt [p$file_organization].value^.keyword_value = 'SEQUENTIAL' THEN
          attributes^ [attribute_index].file_organization := amc$sequential;
        ELSEIF pvt [p$file_organization].value^.keyword_value = 'BYTE_ADDRESSABLE' THEN
          attributes^ [attribute_index].file_organization := amc$byte_addressable;
        ELSEIF pvt [p$file_organization].value^.keyword_value = 'INDEXED_SEQUENTIAL' THEN
          attributes^ [attribute_index].file_organization := amc$indexed_sequential;
        ELSEIF pvt [p$file_organization].value^.keyword_value = 'DIRECT_ACCESS' THEN
          attributes^ [attribute_index].file_organization := amc$direct_access;
        ELSEIF pvt [p$file_organization].value^.keyword_value = 'SYSTEM_KEY' THEN
          attributes^ [attribute_index].file_organization := amc$system_key;
        IFEND;
      IFEND;

      IF pvt [p$file_processor].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$file_processor;
        IF pvt [p$file_processor].value^.kind = clc$keyword {AND keyword = NONE} THEN
          attributes^ [attribute_index].file_processor := pvt [p$file_processor].value^.keyword_value;
        ELSE
          attributes^ [attribute_index].file_processor := pvt [p$file_processor].value^.name_value;
        IFEND;
      IFEND;

      IF pvt [p$file_structure].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$file_structure;
        IF pvt [p$file_structure].value^.kind = clc$keyword {AND keyword = NONE} THEN
          attributes^ [attribute_index].file_structure := pvt [p$file_structure].value^.keyword_value;
        ELSE
          attributes^ [attribute_index].file_structure := pvt [p$file_structure].value^.name_value;
        IFEND;
      IFEND;

      IF pvt [p$forced_write].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$forced_write;
        IF pvt [p$forced_write].value^.kind = clc$keyword {AND keyword = NONE} THEN
          attributes^ [attribute_index].forced_write := amc$forced_if_structure_change;
        ELSEIF pvt [p$forced_write].value^.boolean_value.value THEN
          attributes^ [attribute_index].forced_write := amc$forced;
        ELSE
          attributes^ [attribute_index].forced_write := amc$unforced;
        IFEND;
      IFEND;

      IF pvt [p$hashing_procedure_name].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$hashing_procedure_name;
        PUSH hashing_procedure_name_ptr;
        IF pvt [p$hashing_procedure_name].value^.kind = clc$keyword {AND keyword = NONE} THEN
          hashing_procedure_name_ptr^.name := osc$null_name;
          hashing_procedure_name_ptr^.object_library := '';
        ELSE {clc$entry_point_reference}
          hashing_procedure_name_ptr^.name := pvt [p$hashing_procedure_name].value^.
                entry_point_reference_value^.entry_point;
          hashing_procedure_name_ptr^.object_library := pvt [p$hashing_procedure_name].value^.
                entry_point_reference_value^.object_library;
        IFEND;
        attributes^ [attribute_index].hashing_procedure_name := hashing_procedure_name_ptr;
      IFEND;

      IF pvt [p$index_levels].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$index_levels;
        attributes^ [attribute_index].index_levels := pvt [p$index_levels].value^.integer_value.value;
      IFEND;

      IF pvt [p$index_padding].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$index_padding;
        attributes^ [attribute_index].index_padding := pvt [p$index_padding].value^.integer_value.value;
      IFEND;

      IF pvt [p$initial_home_block_count].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$initial_home_block_count;
        attributes^ [attribute_index].initial_home_block_count :=
              pvt [p$initial_home_block_count].value^.integer_value.value;
      IFEND;

      IF pvt [p$internal_code].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$internal_code;
        IF pvt [p$internal_code].value^.keyword_value = 'A6' THEN
          attributes^ [attribute_index].internal_code := amc$as6;
        ELSEIF pvt [p$internal_code].value^.keyword_value = 'A8' THEN
          attributes^ [attribute_index].internal_code := amc$as8;
        ELSEIF pvt [p$internal_code].value^.keyword_value = 'ASCII' THEN
          attributes^ [attribute_index].internal_code := amc$ascii;
        ELSEIF pvt [p$internal_code].value^.keyword_value = 'D63' THEN
          attributes^ [attribute_index].internal_code := amc$d63;
        ELSEIF pvt [p$internal_code].value^.keyword_value = 'D64' THEN
          attributes^ [attribute_index].internal_code := amc$d64;
        ELSEIF pvt [p$internal_code].value^.keyword_value = 'EBCDIC' THEN
          attributes^ [attribute_index].internal_code := amc$ebcdic;
        ELSEIF pvt [p$internal_code].value^.keyword_value = 'FTAM1_GENERAL' THEN
          attributes^ [attribute_index].internal_code := amc$ftam1_general;
        ELSEIF pvt [p$internal_code].value^.keyword_value = 'FTAM1_GRAPHIC' THEN
          attributes^ [attribute_index].internal_code := amc$ftam1_graphic;
        ELSEIF pvt [p$internal_code].value^.keyword_value = 'FTAM1_IA5' THEN
          attributes^ [attribute_index].internal_code := amc$ftam1_ia5;
        ELSEIF pvt [p$internal_code].value^.keyword_value = 'FTAM1_VISIBLE' THEN
          attributes^ [attribute_index].internal_code := amc$ftam1_visible;
        ELSEIF pvt [p$internal_code].value^.keyword_value = 'FTAM2_GENERAL' THEN
          attributes^ [attribute_index].internal_code := amc$ftam2_general;
        ELSEIF pvt [p$internal_code].value^.keyword_value = 'FTAM2_GRAPHIC' THEN
          attributes^ [attribute_index].internal_code := amc$ftam2_graphic;
        ELSEIF pvt [p$internal_code].value^.keyword_value = 'FTAM2_IA5' THEN
          attributes^ [attribute_index].internal_code := amc$ftam2_ia5;
        ELSEIF pvt [p$internal_code].value^.keyword_value = 'FTAM2_VISIBLE' THEN
          attributes^ [attribute_index].internal_code := amc$ftam2_visible;
        IFEND;
      IFEND;

      IF pvt [p$key_length].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$key_length;
        attributes^ [attribute_index].key_length := pvt [p$key_length].value^.integer_value.value;
      IFEND;

      IF pvt [p$key_position].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$key_position;
        attributes^ [attribute_index].key_position := pvt [p$key_position].value^.integer_value.value;
      IFEND;

      IF pvt [p$key_type].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$key_type;
        IF pvt [p$key_type].value^.keyword_value = 'INTEGER' THEN
          attributes^ [attribute_index].key_type := amc$integer_key;
        ELSEIF pvt [p$key_type].value^.keyword_value = 'COLLATED' THEN
          attributes^ [attribute_index].key_type := amc$collated_key;
        ELSEIF pvt [p$key_type].value^.keyword_value = 'UNCOLLATED' THEN
          attributes^ [attribute_index].key_type := amc$uncollated_key;
        IFEND;
      IFEND;

      IF pvt [p$line_number].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$line_number;
        attributes^ [attribute_index].line_number.location :=
              pvt [p$line_number].value^.field_values^ [1].value^.integer_value.value;
        attributes^ [attribute_index].line_number.length := pvt [p$line_number].value^.field_values^ [2].
              value^.integer_value.value;
      IFEND;

      IF pvt [p$loading_factor].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$loading_factor;
        attributes^ [attribute_index].loading_factor := pvt [p$loading_factor].value^.integer_value.value;
      IFEND;

      IF pvt [p$lock_expiration_time].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$lock_expiration_time;
        attributes^ [attribute_index].lock_expiration_time :=
              pvt [p$lock_expiration_time].value^.integer_value.value;
      IFEND;

      IF pvt [p$logging_options].specified THEN
        attribute_index := attribute_index + 1;
        log_options := pvt [p$logging_options].value;
        attributes^ [attribute_index].key := amc$logging_options;
        attributes^ [attribute_index].logging_options := $amt$logging_options [];

      /get_logging_options/
        WHILE log_options <> NIL DO
          IF log_options^.element_value^.keyword_value = 'ALL' THEN
            IF pvt [p$logging_options].value^.link <> NIL THEN
              osp$set_status_abnormal ('CL', cle$all_must_be_used_alone, 'LOGGING_OPTIONS', status);
              RETURN;
            IFEND;
            logging_options := $amt$logging_options [amc$enable_parcels, amc$enable_media_recovery,
                  amc$enable_request_recovery];
          ELSEIF log_options^.element_value^.keyword_value = 'ENABLE_PARCELS' THEN
            logging_options := $amt$logging_options [amc$enable_parcels];
          ELSEIF log_options^.element_value^.keyword_value = 'ENABLE_MEDIA_RECOVERY' THEN
            logging_options := $amt$logging_options [amc$enable_media_recovery];
          ELSEIF log_options^.element_value^.keyword_value = 'ENABLE_REQUEST_RECOVERY' THEN
            logging_options := $amt$logging_options [amc$enable_request_recovery];
          ELSEIF log_options^.element_value^.keyword_value = 'NONE' THEN
            IF pvt [p$logging_options].value^.link <> NIL THEN
              osp$set_status_abnormal ('CL', cle$none_must_be_used_alone, 'LOGGING_OPTIONS', status);
              RETURN;
            IFEND;
            EXIT /get_logging_options/;
          IFEND;
          attributes^ [attribute_index].logging_options := attributes^ [attribute_index].logging_options +
                logging_options;
          log_options := log_options^.link;
        WHILEND /get_logging_options/;
      IFEND;

      IF pvt [p$log_residence].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$log_residence;
        PUSH log_residence_ptr;
        IF pvt [p$log_residence].value^.kind = clc$keyword {AND keyword = NONE} THEN
          log_residence_ptr^ := '';
        ELSE
          log_residence_ptr^ := pvt [p$log_residence].value^.file_value^;
        IFEND;
        attributes^ [attribute_index].log_residence := log_residence_ptr;
      IFEND;

      IF pvt [p$maximum_block_length].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$max_block_length;
        attributes^ [attribute_index].max_block_length := pvt [p$maximum_block_length].value^.integer_value.
              value;
      IFEND;

      IF pvt [p$maximum_record_length].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$max_record_length;
        attributes^ [attribute_index].max_record_length := pvt [p$maximum_record_length].value^.integer_value.
              value;
      IFEND;

      IF pvt [p$message_control].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$message_control;
        attributes^ [attribute_index].message_control := $amt$message_control [];
        current_message := pvt [p$message_control].value;

      /get_message_control/
        WHILE current_message <> NIL DO
          IF current_message^.element_value^.keyword_value = 'TRIVIAL_ERRORS' THEN
            message_control := $amt$message_control [amc$trivial_errors];
          ELSEIF current_message^.element_value^.keyword_value = 'MESSAGES' THEN
            message_control := $amt$message_control [amc$messages];
          ELSEIF current_message^.element_value^.keyword_value = 'STATISTICS' THEN
            message_control := $amt$message_control [amc$statistics];
          ELSEIF current_message^.element_value^.keyword_value = 'NONE' THEN
            IF pvt [p$message_control].value^.link <> NIL THEN
              osp$set_status_abnormal ('CL', cle$none_must_be_used_alone, 'MESSAGE_CONTROL', status);
              RETURN;
            IFEND;
            EXIT /get_message_control/;
          IFEND;
          attributes^ [attribute_index].message_control := attributes^ [attribute_index].message_control +
                message_control;
          current_message := current_message^.link;
        WHILEND /get_message_control/;
      IFEND;

      IF pvt [p$minimum_block_length].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$min_block_length;
        attributes^ [attribute_index].min_block_length := pvt [p$minimum_block_length].value^.integer_value.
              value;
      IFEND;

      IF pvt [p$minimum_record_length].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$min_record_length;
        attributes^ [attribute_index].min_record_length := pvt [p$minimum_record_length].value^.integer_value.
              value;
      IFEND;

      IF pvt [p$open_position].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$open_position;
        IF pvt [p$open_position].value^.keyword_value = '$ASIS' THEN
          attributes^ [attribute_index].open_position := amc$open_no_positioning;
        ELSEIF pvt [p$open_position].value^.keyword_value = '$BOI' THEN
          attributes^ [attribute_index].open_position := amc$open_at_boi;
        ELSEIF pvt [p$open_position].value^.keyword_value = '$BOP' THEN
          attributes^ [attribute_index].open_position := amc$open_at_bop;
        ELSEIF pvt [p$open_position].value^.keyword_value = '$EOI' THEN
          attributes^ [attribute_index].open_position := amc$open_at_eoi;
        IFEND;
      IFEND;

      IF pvt [p$padding_character].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$padding_character;
        IF pvt [p$padding_character].value^.kind = clc$name THEN
          attributes^ [attribute_index].padding_character := pvt [p$padding_character].value^.name_value (1);
        ELSE
          attributes^ [attribute_index].padding_character := pvt [p$padding_character].value^.
                string_value^ (1);
        IFEND;
      IFEND;

      IF pvt [p$page_format].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$page_format;
        IF pvt [p$page_format].value^.keyword_value = 'BURSTABLE' THEN
          attributes^ [attribute_index].page_format := amc$burstable_form;
        ELSEIF pvt [p$page_format].value^.keyword_value = 'CONTINUOUS' THEN
          attributes^ [attribute_index].page_format := amc$continuous_form;
        ELSEIF pvt [p$page_format].value^.keyword_value = 'NON_BURSTABLE' THEN
          attributes^ [attribute_index].page_format := amc$non_burstable_form;
        ELSEIF pvt [p$page_format].value^.keyword_value = 'UNTITLED' THEN
          attributes^ [attribute_index].page_format := amc$untitled_form;
        IFEND;
      IFEND;

      IF pvt [p$page_length].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$page_length;
        attributes^ [attribute_index].page_length := pvt [p$page_length].value^.integer_value.value;
      IFEND;

      IF pvt [p$page_width].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$page_width;
        attributes^ [attribute_index].page_width := pvt [p$page_width].value^.integer_value.value;
      IFEND;

      IF pvt [p$preset_value].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$preset_value;
        attributes^ [attribute_index].preset_value := pvt [p$preset_value].value^.integer_value.value;
      IFEND;

      IF pvt [p$record_limit].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$record_limit;
        attributes^ [attribute_index].record_limit := pvt [p$record_limit].value^.integer_value.value;
      IFEND;

      IF pvt [p$record_type].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$record_type;
        IF pvt [p$record_type].value^.keyword_value = 'ANSI_FIXED' THEN
          attributes^ [attribute_index].record_type := amc$ansi_fixed;
        ELSEIF pvt [p$record_type].value^.keyword_value = 'ANSI_SPANNED' THEN
          attributes^ [attribute_index].record_type := amc$ansi_spanned;
        ELSEIF pvt [p$record_type].value^.keyword_value = 'ANSI_VARIABLE' THEN
          attributes^ [attribute_index].record_type := amc$ansi_variable;
        ELSEIF pvt [p$record_type].value^.keyword_value = 'UNDEFINED' THEN
          attributes^ [attribute_index].record_type := amc$undefined;
        ELSEIF pvt [p$record_type].value^.keyword_value = 'TRAILING_CHARACTER_DELIMITED' THEN
          attributes^ [attribute_index].record_type := amc$trailing_char_delimited;
        ELSEIF pvt [p$record_type].value^.keyword_value = 'VARIABLE' THEN
          attributes^ [attribute_index].record_type := amc$variable;
        IFEND;
      IFEND;

      IF pvt [p$records_per_block].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$records_per_block;
        attributes^ [attribute_index].records_per_block := pvt [p$records_per_block].value^.integer_value.
              value;
      IFEND;

      IF pvt [p$statement_identifier].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$statement_identifier;
        attributes^ [attribute_index].statement_identifier.location :=
              pvt [p$statement_identifier].value^.field_values^ [1].value^.integer_value.value;
        attributes^ [attribute_index].statement_identifier.length :=
              pvt [p$statement_identifier].value^.field_values^ [2].value^.integer_value.value;
      IFEND;

      IF pvt [p$user_information].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$user_info;
        attributes^ [attribute_index].user_info := pvt [p$user_information].value^.string_value^;
      IFEND;

    END /determine_attributes/;

    bap$file_command (pvt [p$file].value^.file_value^, attributes, status);

  PROCEND clp$_set_file_attributes;
?? TITLE := 'clp$_change_file_attributes', EJECT ??

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

{ PROCEDURE (osm$chafa) change_file_attributes, change_file_attribute, chafa (
{   file, f: file = $required
{   file_access_procedure_name, fapn, file_access_procedure, fap: (BY_NAME) any of
{       key
{         none
{       keyend
{       name
{     anyend = $optional
{   file_contents, file_content, fc: (BY_NAME) any of
{       key
{         ascii_log, binary_log, data, file_backup, legible_data, legible_library, legible_scl_include
{         legible_scl_job, legible_scl_procedure, list, object_data, object_library, screen_form, source_map
{         unknown
{       keyend
{       name
{     anyend = $optional
{   file_limit, fl: (BY_NAME) integer 0..amc$file_byte_limit = $optional
{   file_processor, fp: (BY_NAME) any of
{       key
{         ada, apl, assembler, basic, c, cobol, cybil, debugger, fortran, lisp, pascal, pli, ppu_assembler
{         prolog, scl, scu, vs, unknown
{       keyend
{       name
{     anyend = $optional
{   file_structure, fs: (BY_NAME, HIDDEN) any of
{       key
{         data, library, unknown
{       keyend
{       name
{     anyend = $optional
{   forced_write, fw: (BY_NAME) any of
{       key
{         (forced_if_structure_change, fisc)
{       keyend
{       boolean
{     anyend = $optional
{   line_number, ln: (BY_NAME) record
{       location: integer 1..amc$max_page_width
{       length: integer 1..amc$max_line_number
{     recend = $optional
{   loading_factor, lf: (BY_NAME) integer 0..100 = $optional
{   lock_expiration_time, let: (BY_NAME) integer 0..604800000 = $optional
{   logging_options, logging_option, lo: (BY_NAME) list of key
{       (enable_parcels, ep)
{       (enable_media_recovery, emr)
{       (enable_request_recovery, err)
{       all, none
{     keyend = $optional
{   log_residence, lr: (BY_NAME) any of
{       key
{         none
{       keyend
{       file
{     anyend = $optional
{   record_limit, rl: (BY_NAME) integer 1..amc$file_byte_limit = $optional
{   ring_attributes, ring_attribute, ra: (BY_NAME) list 1..3 of integer osc$min_ring..osc$max_ring = $optional
{   statement_identifier, si: (BY_NAME) record
{       location: integer 1..amc$max_page_width
{       length: integer 1..amc$max_statement_id_length
{     recend = $optional
{   user_information, ui: (BY_NAME) string 0..amc$max_user_info = $optional
{   status)

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

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 38] of clt$pdt_parameter_name,
      parameters: array [1 .. 17] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
      recend,
      type2: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 1] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$name_type_qualifier,
        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 .. 15] 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,
      recend,
      type4: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type5: 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 .. 18] 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,
      recend,
      type6: 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$name_type_qualifier,
        recend,
      recend,
      type7: 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 .. 2] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
        recend,
      recend,
      type8: record
        header: clt$type_specification_header,
        qualifier: clt$record_type_qualifier,
        field_spec_1: clt$field_specification,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$integer_type_qualifier,
        recend,
        field_spec_2: clt$field_specification,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$integer_type_qualifier,
        recend,
      recend,
      type9: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type10: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type11: 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 .. 8] of clt$keyword_specification,
        recend,
      recend,
      type12: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 1] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
        recend,
      recend,
      type13: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type14: record
        header: clt$type_specification_header,
        qualifier: clt$list_type_qualifier,
        element_type_spec: record
          header: clt$type_specification_header,
          qualifier: clt$integer_type_qualifier,
        recend,
      recend,
      type15: record
        header: clt$type_specification_header,
        qualifier: clt$record_type_qualifier,
        field_spec_1: clt$field_specification,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$integer_type_qualifier,
        recend,
        field_spec_2: clt$field_specification,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$integer_type_qualifier,
        recend,
      recend,
      type16: record
        header: clt$type_specification_header,
        qualifier: clt$string_type_qualifier,
      recend,
      type17: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [90, 1, 8, 15, 27, 50, 559],
    clc$command, 38, 17, 1, 0, 1, 0, 17, 'OSM$CHAFA'], [
    ['F                              ',clc$abbreviation_entry, 1],
    ['FAP                            ',clc$abbreviation_entry, 2],
    ['FAPN                           ',clc$alias_entry, 2],
    ['FC                             ',clc$abbreviation_entry, 3],
    ['FILE                           ',clc$nominal_entry, 1],
    ['FILE_ACCESS_PROCEDURE          ',clc$alias_entry, 2],
    ['FILE_ACCESS_PROCEDURE_NAME     ',clc$nominal_entry, 2],
    ['FILE_CONTENT                   ',clc$alias_entry, 3],
    ['FILE_CONTENTS                  ',clc$nominal_entry, 3],
    ['FILE_LIMIT                     ',clc$nominal_entry, 4],
    ['FILE_PROCESSOR                 ',clc$nominal_entry, 5],
    ['FILE_STRUCTURE                 ',clc$nominal_entry, 6],
    ['FL                             ',clc$abbreviation_entry, 4],
    ['FORCED_WRITE                   ',clc$nominal_entry, 7],
    ['FP                             ',clc$abbreviation_entry, 5],
    ['FS                             ',clc$abbreviation_entry, 6],
    ['FW                             ',clc$abbreviation_entry, 7],
    ['LET                            ',clc$abbreviation_entry, 10],
    ['LF                             ',clc$abbreviation_entry, 9],
    ['LINE_NUMBER                    ',clc$nominal_entry, 8],
    ['LN                             ',clc$abbreviation_entry, 8],
    ['LO                             ',clc$abbreviation_entry, 11],
    ['LOADING_FACTOR                 ',clc$nominal_entry, 9],
    ['LOCK_EXPIRATION_TIME           ',clc$nominal_entry, 10],
    ['LOGGING_OPTION                 ',clc$alias_entry, 11],
    ['LOGGING_OPTIONS                ',clc$nominal_entry, 11],
    ['LOG_RESIDENCE                  ',clc$nominal_entry, 12],
    ['LR                             ',clc$abbreviation_entry, 12],
    ['RA                             ',clc$abbreviation_entry, 14],
    ['RECORD_LIMIT                   ',clc$nominal_entry, 13],
    ['RING_ATTRIBUTE                 ',clc$alias_entry, 14],
    ['RING_ATTRIBUTES                ',clc$nominal_entry, 14],
    ['RL                             ',clc$abbreviation_entry, 13],
    ['SI                             ',clc$abbreviation_entry, 15],
    ['STATEMENT_IDENTIFIER           ',clc$nominal_entry, 15],
    ['STATUS                         ',clc$nominal_entry, 17],
    ['UI                             ',clc$abbreviation_entry, 16],
    ['USER_INFORMATION               ',clc$nominal_entry, 16]],
    [
{ 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, 3, clc$required_parameter, 0
  , 0],
{ PARAMETER 2
    [7, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 69, clc$optional_parameter,
  0, 0],
{ PARAMETER 3
    [9, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 587,
  clc$optional_parameter, 0, 0],
{ PARAMETER 4
    [10, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 5
    [11, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 698,
  clc$optional_parameter, 0, 0],
{ PARAMETER 6
    [12, clc$hidden_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 143,
  clc$optional_parameter, 0, 0],
{ PARAMETER 7
    [14, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 104,
  clc$optional_parameter, 0, 0],
{ PARAMETER 8
    [20, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 119,
  clc$optional_parameter, 0, 0],
{ PARAMETER 9
    [23, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 10
    [24, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 11
    [26, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 319,
  clc$optional_parameter, 0, 0],
{ PARAMETER 12
    [27, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 67, clc$optional_parameter,
  0, 0],
{ PARAMETER 13
    [30, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 14
    [32, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 36, clc$optional_parameter,
  0, 0],
{ PARAMETER 15
    [35, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 119,
  clc$optional_parameter, 0, 0],
{ PARAMETER 16
    [38, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 8, clc$optional_parameter, 0
  , 0],
{ PARAMETER 17
    [36, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$file_type]],
{ PARAMETER 2
    [[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]]
    ],
{ PARAMETER 3
    [[1, 0, clc$union_type], [[clc$keyword_type, clc$name_type],
    FALSE, 2],
    562, [[1, 0, clc$keyword_type], [15], [
      ['ASCII_LOG                      ', clc$nominal_entry, clc$normal_usage_entry, 1],
      ['BINARY_LOG                     ', clc$nominal_entry, clc$normal_usage_entry, 2],
      ['DATA                           ', clc$nominal_entry, clc$normal_usage_entry, 3],
      ['FILE_BACKUP                    ', clc$nominal_entry, clc$normal_usage_entry, 4],
      ['LEGIBLE_DATA                   ', clc$nominal_entry, clc$normal_usage_entry, 5],
      ['LEGIBLE_LIBRARY                ', clc$nominal_entry, clc$normal_usage_entry, 6],
      ['LEGIBLE_SCL_INCLUDE            ', clc$nominal_entry, clc$normal_usage_entry, 7],
      ['LEGIBLE_SCL_JOB                ', clc$nominal_entry, clc$normal_usage_entry, 8],
      ['LEGIBLE_SCL_PROCEDURE          ', clc$nominal_entry, clc$normal_usage_entry, 9],
      ['LIST                           ', clc$nominal_entry, clc$normal_usage_entry, 10],
      ['OBJECT_DATA                    ', clc$nominal_entry, clc$normal_usage_entry, 11],
      ['OBJECT_LIBRARY                 ', clc$nominal_entry, clc$normal_usage_entry, 12],
      ['SCREEN_FORM                    ', clc$nominal_entry, clc$normal_usage_entry, 13],
      ['SOURCE_MAP                     ', clc$nominal_entry, clc$normal_usage_entry, 14],
      ['UNKNOWN                        ', clc$nominal_entry, clc$normal_usage_entry, 15]]
      ],
    5, [[1, 0, clc$name_type], [1, osc$max_name_size]]
    ],
{ PARAMETER 4
    [[1, 0, clc$integer_type], [0, amc$file_byte_limit, 10]],
{ PARAMETER 5
    [[1, 0, clc$union_type], [[clc$keyword_type, clc$name_type],
    FALSE, 2],
    673, [[1, 0, clc$keyword_type], [18], [
      ['ADA                            ', clc$nominal_entry, clc$normal_usage_entry, 1],
      ['APL                            ', clc$nominal_entry, clc$normal_usage_entry, 2],
      ['ASSEMBLER                      ', clc$nominal_entry, clc$normal_usage_entry, 3],
      ['BASIC                          ', clc$nominal_entry, clc$normal_usage_entry, 4],
      ['C                              ', clc$nominal_entry, clc$normal_usage_entry, 5],
      ['COBOL                          ', clc$nominal_entry, clc$normal_usage_entry, 6],
      ['CYBIL                          ', clc$nominal_entry, clc$normal_usage_entry, 7],
      ['DEBUGGER                       ', clc$nominal_entry, clc$normal_usage_entry, 8],
      ['FORTRAN                        ', clc$nominal_entry, clc$normal_usage_entry, 9],
      ['LISP                           ', clc$nominal_entry, clc$normal_usage_entry, 10],
      ['PASCAL                         ', clc$nominal_entry, clc$normal_usage_entry, 11],
      ['PLI                            ', clc$nominal_entry, clc$normal_usage_entry, 12],
      ['PPU_ASSEMBLER                  ', clc$nominal_entry, clc$normal_usage_entry, 13],
      ['PROLOG                         ', clc$nominal_entry, clc$normal_usage_entry, 14],
      ['SCL                            ', clc$nominal_entry, clc$normal_usage_entry, 15],
      ['SCU                            ', clc$nominal_entry, clc$normal_usage_entry, 16],
      ['UNKNOWN                        ', clc$nominal_entry, clc$normal_usage_entry, 18],
      ['VS                             ', clc$nominal_entry, clc$normal_usage_entry, 17]]
      ],
    5, [[1, 0, clc$name_type], [1, osc$max_name_size]]
    ],
{ PARAMETER 6
    [[1, 0, clc$union_type], [[clc$keyword_type, clc$name_type],
    FALSE, 2],
    118, [[1, 0, clc$keyword_type], [3], [
      ['DATA                           ', clc$nominal_entry, clc$normal_usage_entry, 1],
      ['LIBRARY                        ', clc$nominal_entry, clc$normal_usage_entry, 2],
      ['UNKNOWN                        ', clc$nominal_entry, clc$normal_usage_entry, 3]]
      ],
    5, [[1, 0, clc$name_type], [1, osc$max_name_size]]
    ],
{ PARAMETER 7
    [[1, 0, clc$union_type], [[clc$boolean_type, clc$keyword_type],
    FALSE, 2],
    81, [[1, 0, clc$keyword_type], [2], [
      ['FISC                           ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
      ['FORCED_IF_STRUCTURE_CHANGE     ', clc$nominal_entry, clc$normal_usage_entry, 1]]
      ],
    3, [[1, 0, clc$boolean_type]]
    ],
{ PARAMETER 8
    [[1, 0, clc$record_type], [2],
    ['LOCATION                       ', clc$required_field, 20], [[1, 0, clc$integer_type], [1,
  amc$max_page_width, 10]],
    ['LENGTH                         ', clc$required_field, 20], [[1, 0, clc$integer_type], [1,
  amc$max_line_number, 10]]
    ],
{ PARAMETER 9
    [[1, 0, clc$integer_type], [0, 100, 10]],
{ PARAMETER 10
    [[1, 0, clc$integer_type], [0, 604800000, 10]],
{ PARAMETER 11
    [[1, 0, clc$list_type], [303, 1, clc$max_list_size, FALSE],
      [[1, 0, clc$keyword_type], [8], [
      ['ALL                            ', clc$nominal_entry, clc$normal_usage_entry, 4],
      ['EMR                            ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
      ['ENABLE_MEDIA_RECOVERY          ', clc$nominal_entry, clc$normal_usage_entry, 2],
      ['ENABLE_PARCELS                 ', clc$nominal_entry, clc$normal_usage_entry, 1],
      ['ENABLE_REQUEST_RECOVERY        ', clc$nominal_entry, clc$normal_usage_entry, 3],
      ['EP                             ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
      ['ERR                            ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
      ['NONE                           ', clc$nominal_entry, clc$normal_usage_entry, 5]]
      ]
    ],
{ PARAMETER 12
    [[1, 0, clc$union_type], [[clc$file_type, clc$keyword_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['NONE                           ', clc$nominal_entry, clc$normal_usage_entry, 1]]
      ],
    3, [[1, 0, clc$file_type]]
    ],
{ PARAMETER 13
    [[1, 0, clc$integer_type], [1, amc$file_byte_limit, 10]],
{ PARAMETER 14
    [[1, 0, clc$list_type], [20, 1, 3, FALSE],
      [[1, 0, clc$integer_type], [osc$min_ring, osc$max_ring, 10]]
    ],
{ PARAMETER 15
    [[1, 0, clc$record_type], [2],
    ['LOCATION                       ', clc$required_field, 20], [[1, 0, clc$integer_type], [1,
  amc$max_page_width, 10]],
    ['LENGTH                         ', clc$required_field, 20], [[1, 0, clc$integer_type], [1,
  amc$max_statement_id_length, 10]]
    ],
{ PARAMETER 16
    [[1, 0, clc$string_type], [0, amc$max_user_info, FALSE]],
{ PARAMETER 17
    [[1, 0, clc$status_type]]];

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

    CONST
      p$file = 1,
      p$file_access_procedure_name = 2,
      p$file_contents = 3,
      p$file_limit = 4,
      p$file_processor = 5,
      p$file_structure = 6,
      p$forced_write = 7,
      p$line_number = 8,
      p$loading_factor = 9,
      p$lock_expiration_time = 10,
      p$logging_options = 11,
      p$log_residence = 12,
      p$record_limit = 13,
      p$ring_attributes = 14,
      p$statement_identifier = 15,
      p$user_information = 16,
      p$status = 17;

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

    VAR
      access_mode: pft$usage_selections,
      attributes: ^amt$file_attributes,
      attribute_count: 0 .. p$status - 2,
      attribute_index: 0 .. p$status - 1,
      compression_procedure_name_ptr: ^amt$compression_procedure_name,
      current_access_mode: ^clt$data_value,
      current_message: ^clt$data_value,
      evaluated_file_reference: fst$evaluated_file_reference,
      hashing_procedure_name_ptr: ^amt$hashing_procedure_name,
      label_option: amt$label_options,
      logging_options: amt$logging_options,
      log_options: ^clt$data_value,
      log_residence_ptr: ^amt$log_residence,
      message_control: amt$message_control,
      path_handle_name: fst$path_handle_name,
      remote: boolean,
      ring: ^clt$data_value;


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

    evaluate_path_and_handle_remote ('CHANGE_FILE_ATTRIBUTES', pvt [p$file].value^.file_value^, ^pvt, remote,
          status);
    IF (NOT status.normal) OR remote THEN
      RETURN;
    IFEND;

    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;

  /determine_attributes/
    BEGIN

      attribute_count := 0;
      FOR attribute_index := 2 TO p$status - 1 DO
        IF pvt [attribute_index].specified THEN
          attribute_count := attribute_count + 1;
        IFEND;
      FOREND;
      IF attribute_count = 0 THEN
        attributes := NIL;
        EXIT /determine_attributes/;
      ELSE
        PUSH attributes: [1 .. attribute_count];
      IFEND;
      attribute_index := 0;

      IF pvt [p$file_access_procedure_name].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$file_access_procedure;
        IF pvt [p$file_access_procedure_name].value^.kind = clc$keyword {AND keyword = NONE} THEN
          attributes^ [attribute_index].file_access_procedure := osc$null_name;
        ELSE
          attributes^ [attribute_index].file_access_procedure :=
                pvt [p$file_access_procedure_name].value^.name_value;
        IFEND;
      IFEND;

      IF pvt [p$file_contents].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$file_contents;
        IF pvt [p$file_contents].value^.kind = clc$keyword {AND keyword = NONE} THEN
          attributes^ [attribute_index].file_contents := pvt [p$file_contents].value^.keyword_value;
        ELSE
          attributes^ [attribute_index].file_contents := pvt [p$file_contents].value^.name_value;
        IFEND;
      IFEND;

      IF pvt [p$file_limit].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$file_limit;
        attributes^ [attribute_index].file_limit := pvt [p$file_limit].value^.integer_value.value;
      IFEND;

      IF pvt [p$file_processor].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$file_processor;
        IF pvt [p$file_processor].value^.kind = clc$keyword {AND keyword = NONE} THEN
          attributes^ [attribute_index].file_processor := pvt [p$file_processor].value^.keyword_value;
        ELSE
          attributes^ [attribute_index].file_processor := pvt [p$file_processor].value^.name_value;
        IFEND;
      IFEND;

      IF pvt [p$file_structure].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$file_structure;
        IF pvt [p$file_structure].value^.kind = clc$keyword {AND keyword = NONE} THEN
          attributes^ [attribute_index].file_structure := pvt [p$file_structure].value^.keyword_value;
        ELSE
          attributes^ [attribute_index].file_structure := pvt [p$file_structure].value^.name_value;
        IFEND;
      IFEND;

      IF pvt [p$forced_write].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$forced_write;
        IF pvt [p$forced_write].value^.kind = clc$keyword {AND keyword = NONE} THEN
          attributes^ [attribute_index].forced_write := amc$forced_if_structure_change;
        ELSEIF pvt [p$forced_write].value^.boolean_value.value THEN
          attributes^ [attribute_index].forced_write := amc$forced;
        ELSE
          attributes^ [attribute_index].forced_write := amc$unforced;
        IFEND;
      IFEND;

      IF pvt [p$line_number].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$line_number;
        attributes^ [attribute_index].line_number.location :=
              pvt [p$line_number].value^.field_values^ [1].value^.integer_value.value;
        attributes^ [attribute_index].line_number.length := pvt [p$line_number].value^.field_values^ [2].
              value^.integer_value.value;
      IFEND;

      IF pvt [p$loading_factor].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$loading_factor;
        attributes^ [attribute_index].loading_factor := pvt [p$loading_factor].value^.integer_value.value;
      IFEND;

      IF pvt [p$lock_expiration_time].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$lock_expiration_time;
        attributes^ [attribute_index].lock_expiration_time :=
              pvt [p$lock_expiration_time].value^.integer_value.value;
      IFEND;

      IF pvt [p$logging_options].specified THEN
        attribute_index := attribute_index + 1;
        log_options := pvt [p$logging_options].value;
        attributes^ [attribute_index].key := amc$logging_options;
        attributes^ [attribute_index].logging_options := $amt$logging_options [];

      /get_logging_options/
        WHILE log_options <> NIL DO
          IF log_options^.element_value^.keyword_value = 'ALL' THEN
            IF pvt [p$logging_options].value^.link <> NIL THEN
              osp$set_status_abnormal ('CL', cle$all_must_be_used_alone, 'LOGGING_OPTIONS', status);
              RETURN;
            IFEND;
            logging_options := $amt$logging_options [amc$enable_parcels, amc$enable_media_recovery,
                  amc$enable_request_recovery];
          ELSEIF log_options^.element_value^.keyword_value = 'ENABLE_PARCELS' THEN
            logging_options := $amt$logging_options [amc$enable_parcels];
          ELSEIF log_options^.element_value^.keyword_value = 'ENABLE_MEDIA_RECOVERY' THEN
            logging_options := $amt$logging_options [amc$enable_media_recovery];
          ELSEIF log_options^.element_value^.keyword_value = 'ENABLE_REQUEST_RECOVERY' THEN
            logging_options := $amt$logging_options [amc$enable_request_recovery];
          ELSEIF log_options^.element_value^.keyword_value = 'NONE' THEN
            IF pvt [p$logging_options].value^.link <> NIL THEN
              osp$set_status_abnormal ('CL', cle$none_must_be_used_alone, 'LOGGING_OPTIONS', status);
              RETURN;
            IFEND;
            EXIT /get_logging_options/;
          IFEND;
          attributes^ [attribute_index].logging_options := attributes^ [attribute_index].logging_options +
                logging_options;
          log_options := log_options^.link;
        WHILEND /get_logging_options/;
      IFEND;

      IF pvt [p$log_residence].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$log_residence;
        PUSH log_residence_ptr;
        IF pvt [p$log_residence].value^.kind = clc$keyword {AND keyword = NONE} THEN
          log_residence_ptr^ := '';
        ELSE
          log_residence_ptr^ := pvt [p$log_residence].value^.file_value^;
        IFEND;
        attributes^ [attribute_index].log_residence := log_residence_ptr;
      IFEND;

      IF pvt [p$record_limit].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$record_limit;
        attributes^ [attribute_index].record_limit := pvt [p$record_limit].value^.integer_value.value;
      IFEND;

      IF pvt [p$ring_attributes].specified THEN
        ring := pvt [p$ring_attributes].value;
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$ring_attributes;
        attributes^ [attribute_index].ring_attributes.r1 := ring^.element_value^.integer_value.value;
        IF ring^.link = NIL THEN
          attributes^ [attribute_index].ring_attributes.r2 := attributes^ [attribute_index].ring_attributes.
                r1;
          attributes^ [attribute_index].ring_attributes.r3 := attributes^ [attribute_index].ring_attributes.
                r2;
        ELSE
          ring := ring^.link;
          attributes^ [attribute_index].ring_attributes.r2 := ring^.element_value^.integer_value.value;
          IF ring^.link = NIL THEN
            attributes^ [attribute_index].ring_attributes.r3 :=
                  attributes^ [attribute_index].ring_attributes.r2;
          ELSE
            ring := ring^.link;
            attributes^ [attribute_index].ring_attributes.r3 := ring^.element_value^.integer_value.value;
          IFEND;
        IFEND;
      IFEND;

      IF pvt [p$statement_identifier].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$statement_identifier;
        attributes^ [attribute_index].statement_identifier.location :=
              pvt [p$statement_identifier].value^.field_values^ [1].value^.integer_value.value;
        attributes^ [attribute_index].statement_identifier.length :=
              pvt [p$statement_identifier].value^.field_values^ [2].value^.integer_value.value;
      IFEND;

      IF pvt [p$user_information].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$user_info;
        attributes^ [attribute_index].user_info := pvt [p$user_information].value^.string_value^;
      IFEND;

    END /determine_attributes/;

    amp$change_file_attributes (pvt [p$file].value^.file_value^, attributes, status);

  PROCEND clp$_change_file_attributes;
?? TITLE := '[XDCL, #GATE] clp$_change_default_file_attbs' ??
?? EJECT ??

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

{ PROCEDURE (osm$chadfa) change_default_file_attributes, chadfa (
{   lock_expiration_time, let: (BY_NAME) integer 0..604800000 = $optional
{   page_length, pl: (BY_NAME) integer 1..amc$file_byte_limit = $optional
{   page_width, pw: (BY_NAME) integer 1..amc$max_page_width = $optional
{   record_type, rt: (BY_NAME) key
{       (ansi_fixed, fixed, f, af)
{       (ansi_spanned, s, as)
{       (ansi_variable, d, av)
{       (variable, v)
{       (undefined, u)
{       (trailing_character_delimited, tcd, trailing, t)
{     keyend = $optional
{   retention, new_retention, r, nr: any of
{       integer pfc$minimum_retention..pfc$maximum_retention
{       date
{       date_time
{       time_increment
{     anyend = $optional
{   reset_system_defaults, rsd: boolean = false
{   status)

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

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 15] of clt$pdt_parameter_name,
      parameters: array [1 .. 7] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type2: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type3: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type4: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 18] of clt$keyword_specification,
      recend,
      type5: 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$integer_type_qualifier,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$date_time_type_qualifier,
        recend,
        type_size_3: clt$type_specification_size,
        element_type_spec_3: record
          header: clt$type_specification_header,
          qualifier: clt$date_time_type_qualifier,
        recend,
        type_size_4: clt$type_specification_size,
        element_type_spec_4: record
          header: clt$type_specification_header,
        recend,
      recend,
      type6: record
        header: clt$type_specification_header,
        default_value: string (5),
      recend,
      type7: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [97, 1, 14, 14, 1, 19, 214],
    clc$command, 15, 7, 0, 0, 0, 0, 7, 'OSM$CHADFA'], [
    ['LET                            ',clc$abbreviation_entry, 1],
    ['LOCK_EXPIRATION_TIME           ',clc$nominal_entry, 1],
    ['NEW_RETENTION                  ',clc$alias_entry, 5],
    ['NR                             ',clc$abbreviation_entry, 5],
    ['PAGE_LENGTH                    ',clc$nominal_entry, 2],
    ['PAGE_WIDTH                     ',clc$nominal_entry, 3],
    ['PL                             ',clc$abbreviation_entry, 2],
    ['PW                             ',clc$abbreviation_entry, 3],
    ['R                              ',clc$alias_entry, 5],
    ['RECORD_TYPE                    ',clc$nominal_entry, 4],
    ['RESET_SYSTEM_DEFAULTS          ',clc$nominal_entry, 6],
    ['RETENTION                      ',clc$nominal_entry, 5],
    ['RSD                            ',clc$abbreviation_entry, 6],
    ['RT                             ',clc$abbreviation_entry, 4],
    ['STATUS                         ',clc$nominal_entry, 7]],
    [
{ PARAMETER 1
    [2, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 2
    [5, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 3
    [6, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 4
    [10, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 673,
  clc$optional_parameter, 0, 0],
{ PARAMETER 5
    [12, 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, 61, clc$optional_parameter,
  0, 0],
{ PARAMETER 6
    [11, 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, 5],
{ PARAMETER 7
    [15, 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$integer_type], [0, 604800000, 10]],
{ PARAMETER 2
    [[1, 0, clc$integer_type], [1, amc$file_byte_limit, 10]],
{ PARAMETER 3
    [[1, 0, clc$integer_type], [1, amc$max_page_width, 10]],
{ PARAMETER 4
    [[1, 0, clc$keyword_type], [18], [
    ['AF                             ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
    ['ANSI_FIXED                     ', clc$nominal_entry, clc$normal_usage_entry, 1],
    ['ANSI_SPANNED                   ', clc$nominal_entry, clc$normal_usage_entry, 2],
    ['ANSI_VARIABLE                  ', clc$nominal_entry, clc$normal_usage_entry, 3],
    ['AS                             ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
    ['AV                             ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
    ['D                              ', clc$alias_entry, clc$normal_usage_entry, 3],
    ['F                              ', clc$alias_entry, clc$normal_usage_entry, 1],
    ['FIXED                          ', clc$alias_entry, clc$normal_usage_entry, 1],
    ['S                              ', clc$alias_entry, clc$normal_usage_entry, 2],
    ['T                              ', clc$abbreviation_entry, clc$normal_usage_entry, 6],
    ['TCD                            ', clc$alias_entry, clc$normal_usage_entry, 6],
    ['TRAILING                       ', clc$alias_entry, clc$normal_usage_entry, 6],
    ['TRAILING_CHARACTER_DELIMITED   ', clc$nominal_entry, clc$normal_usage_entry, 6],
    ['U                              ', clc$abbreviation_entry, clc$normal_usage_entry, 5],
    ['UNDEFINED                      ', clc$nominal_entry, clc$normal_usage_entry, 5],
    ['V                              ', clc$abbreviation_entry, clc$normal_usage_entry, 4],
    ['VARIABLE                       ', clc$nominal_entry, clc$normal_usage_entry, 4]]
    ],
{ PARAMETER 5
    [[1, 0, clc$union_type], [[clc$date_time_type, clc$integer_type, clc$time_increment_type],
    FALSE, 4],
    20, [[1, 0, clc$integer_type], [pfc$minimum_retention, pfc$maximum_retention, 10]],
    5, [[1, 0, clc$date_time_type], [$clt$date_and_or_time [clc$date], $clt$date_time_tenses [clc$past,
  clc$present, clc$future]]],
    5, [[1, 0, clc$date_time_type], [$clt$date_and_or_time [clc$date, clc$time], $clt$date_time_tenses [
  clc$past, clc$present, clc$future]]],
    3, [[1, 0, clc$time_increment_type]]
    ],
{ PARAMETER 6
    [[1, 0, clc$boolean_type],
    'false'],
{ PARAMETER 7
    [[1, 0, clc$status_type]]];

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

    CONST
      p$lock_expiration_time = 1,
      p$page_length = 2,
      p$page_width = 3,
      p$record_type = 4,
      p$retention = 5,
      p$reset_system_defaults = 6,
      p$status = 7;

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

    VAR
      attributes: ^amt$file_attributes,
      attribute_count: 0 .. p$reset_system_defaults - 1,
      attribute_index: 0 .. p$reset_system_defaults - 1,
      date_time: ost$date_time,
      expiration_date: ost$date_time,
      ignore_status: ost$status,
      reset_system_defaults: boolean,
      retention: ^fst$retention;

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

    reset_system_defaults := pvt [p$reset_system_defaults].value^.boolean_value.value;

  /determine_attributes/
    BEGIN

      attribute_count := 0;
      FOR attribute_index := 1 TO p$reset_system_defaults - 1 DO
        IF pvt [attribute_index].specified THEN
          attribute_count := attribute_count + 1;
        IFEND;
      FOREND;
      IF attribute_count = 0 THEN
        attributes := NIL;
        retention := NIL;
        EXIT /determine_attributes/;
      ELSE
        IF pvt [p$retention].specified THEN
          attribute_count := attribute_count - 1;
          PUSH retention;
          IF pvt [p$retention].value^.kind = clc$integer THEN
            retention^.selector := fsc$retention_day_increment;
            retention^.day_increment := pvt [p$retention].value^.integer_value.value;
          ELSEIF pvt [p$retention].value^.kind = clc$time_increment THEN
            retention^.selector := fsc$retention_time_increment;
            retention^.time_increment := pvt [p$retention].value^.time_increment_value^;
            clp$verify_time_increment (retention^.time_increment, status);
            IF NOT status.normal THEN
              RETURN;
            IFEND;
            pmp$get_compact_date_time (date_time, ignore_status);
            pmp$compute_date_time (date_time, retention^.time_increment, expiration_date, status);
            IF NOT status.normal THEN
              RETURN;
            IFEND;
          ELSE
            retention^.selector := fsc$retention_expiration_date;
            retention^.expiration_date := pvt [p$retention].value^.date_time_value.value;
            IF pvt [p$retention].value^.date_time_value.date_specified THEN
              pmp$verify_compact_date (retention^.expiration_date, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
            IF pvt [p$retention].value^.date_time_value.time_specified THEN
              pmp$verify_compact_time (retention^.expiration_date, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          IFEND;
        ELSE
          retention := NIL;
        IFEND;

        IF attribute_count = 0 THEN
          attributes := NIL;
          EXIT /determine_attributes/;
        ELSE
          PUSH attributes: [1 .. attribute_count];
        IFEND;
      IFEND;
      attribute_index := 0;

      IF pvt [p$lock_expiration_time].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$lock_expiration_time;
        attributes^ [attribute_index].lock_expiration_time :=
              pvt [p$lock_expiration_time].value^.integer_value.value;
      IFEND;

      IF pvt [p$page_length].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$page_length;
        attributes^ [attribute_index].page_length := pvt [p$page_length].value^.integer_value.value;
      IFEND;

      IF pvt [p$page_width].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$page_width;
        attributes^ [attribute_index].page_width := pvt [p$page_width].value^.integer_value.value;
      IFEND;

      IF pvt [p$record_type].specified THEN
        attribute_index := attribute_index + 1;
        attributes^ [attribute_index].key := amc$record_type;
        IF pvt [p$record_type].value^.keyword_value = 'ANSI_FIXED' THEN
          attributes^ [attribute_index].record_type := amc$ansi_fixed;
        ELSEIF pvt [p$record_type].value^.keyword_value = 'ANSI_SPANNED' THEN
          attributes^ [attribute_index].record_type := amc$ansi_spanned;
        ELSEIF pvt [p$record_type].value^.keyword_value = 'ANSI_VARIABLE' THEN
          attributes^ [attribute_index].record_type := amc$ansi_variable;
        ELSEIF pvt [p$record_type].value^.keyword_value = 'UNDEFINED' THEN
          attributes^ [attribute_index].record_type := amc$undefined;
        ELSEIF pvt [p$record_type].value^.keyword_value = 'TRAILING_CHARACTER_DELIMITED' THEN
          attributes^ [attribute_index].record_type := amc$trailing_char_delimited;
        ELSEIF pvt [p$record_type].value^.keyword_value = 'VARIABLE' THEN
          attributes^ [attribute_index].record_type := amc$variable;
        IFEND;
      IFEND;

    END /determine_attributes/;

    bap$change_default_file_attribs (attributes, retention, reset_system_defaults, status);

  PROCEND clp$_change_default_file_attbs;
?? TITLE := 'evaluate_path_and_handle_remote', EJECT ??

{
{ PURPOSE:
{   This procedure parses a path for a command and determines whether it
{   represents a file on a remote system.  If so it performs the appropriate
{   remote operation.
{

  PROCEDURE evaluate_path_and_handle_remote
    (    command_name: ost$name_reference;
         path: fst$file_reference;
         pvt: ^clt$parameter_value_table;
     VAR remote: boolean;
     VAR status: ost$status);

    VAR
      block: ^clt$block,
      evaluated_file_reference: fst$evaluated_file_reference,
      family_name: ost$family_name,
      remote_parameter: array [1 .. 1] of clt$parameter_substitution,
      work_area: ^^clt$work_area;


    clp$evaluate_file_reference (path, $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
      clp$get_work_area (#RING (^work_area), work_area, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$find_current_block (block);

      remote_parameter [1].name := 'STATUS';
      remote_parameter [1].text := NIL;

      nfp$perform_implicit_access (family_name, clc$null_file, path, nfc$null, command_name,
            block^.parameters.unbundled_pdt, pvt, ^remote_parameter, work_area^, status);
    IFEND;

  PROCEND evaluate_path_and_handle_remote;

MODEND clm$file_command;
