?? RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE File System : File Label Expansion' ??
MODULE fsm$expand_file_label;
?? RIGHT := 110 ??

{ PURPOSE:
{   This module contains the procedure that expands a compressed file label.
{
{ DESIGN:
{   First assign default values to the attributes by a record assignment and
{   then NEXT through the sequence to retrieve the non-default attribute values.

?? NEWTITLE := 'Global Declarations Referenced by this Module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc ame$attribute_validation_errors
*copyc amt$file_reference
*copyc amt$path_name
*copyc bat$static_label_attributes
*copyc fmc$unique_label_id
*copyc fmt$file_attribute_keys
*copyc fmt$static_label_header
*copyc fmt$static_label_item
?? POP ??
*copyc bap$get_default_file_attribs
*copyc fsp$convert_to_old_contents
*copyc osp$set_status_abnormal
?? OLDTITLE ??
?? NEWTITLE := 'PROCEDURE [XDCL, #GATE] fsp$expand_file_label', EJECT ??

  PROCEDURE [XDCL, #GATE] fsp$expand_file_label
    (    file_label: ^SEQ ( * );
     VAR static_label_attributes: bat$static_label_attributes;
     VAR file_previously_opened: boolean;
     VAR status: ost$status);

    VAR
      attribute_key: fmt$file_attribute_keys,
      default_new_retention: fst$retention,
      default_new_retention_specified: boolean,
      header: ^fmt$static_label_header,
      ignore_found: boolean,
      ignore_path: amt$path_name,
      split_file_contents: amt$file_contents,
      split_file_structure: amt$file_structure,
      reassign_file_contents: boolean,
      static_label: ^SEQ ( * ),
      static_label_item: ^fmt$static_label_item,
      str: ^string ( * );

?? NEWTITLE := 'PROCEDURE set_status_damaged_attributes', EJECT ??

    PROCEDURE set_status_damaged_attributes
      (    attribute_index: 1 .. fmc$highest_current_attribute + 5;
       VAR status: ost$status);

      VAR
        status_text: string (osc$max_string_size),
        text_length: integer;

      STRINGREP (status_text, text_length, 'Nexting of attribute # ', attribute_index,
            ' in LABEL resulted in a NIL pointer in FSP$EXPAND_FILE_LABEL');
      osp$set_status_abnormal (amc$access_method_id, ame$damaged_file_attributes,
            status_text (1, text_length), status);

    PROCEND set_status_damaged_attributes;
?? OLDTITLE ??
?? NEWTITLE := 'PROCEDURE [INLINE] get_entry_point_reference', EJECT ??

    PROCEDURE [INLINE] get_entry_point_reference
      (VAR name: pmt$program_name;
       VAR path: amt$file_reference;
       VAR status: ost$status);

      NEXT str: [static_label_item^.entry_point_name_length] IN static_label;
      IF str = NIL THEN
        set_status_damaged_attributes (fmc$highest_current_attribute + 1, status);
        RETURN; {----->
      IFEND;
      name := str^;
      IF static_label_item^.entry_point_path_length > 0 THEN
        NEXT str: [static_label_item^.entry_point_path_length] IN static_label;
        IF str = NIL THEN
          set_status_damaged_attributes (fmc$highest_current_attribute + 2, status);
          RETURN; {----->
        IFEND;
        path := str^;
      IFEND;

    PROCEND get_entry_point_reference;
?? OLDTITLE ??
?? NEWTITLE := 'PROCEDURE [INLINE] get_name', EJECT ??

    PROCEDURE [INLINE] get_name
      (VAR name: pmt$program_name;
       VAR status: ost$status);

      NEXT str: [static_label_item^.name_length] IN static_label;
      IF str = NIL THEN
        set_status_damaged_attributes (fmc$highest_current_attribute + 3, status);
        RETURN; {----->
      IFEND;
      name := str^;

    PROCEND get_name;
?? OLDTITLE ??
?? EJECT ??

    status.normal := TRUE;
    bap$get_default_file_attribs (static_label_attributes, default_new_retention_specified,
          default_new_retention, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF file_label = NIL THEN
      file_previously_opened := FALSE;
      RETURN; {----->
    IFEND;

    static_label := file_label;
    RESET static_label;
    NEXT header IN static_label;
    IF header = NIL THEN
      set_status_damaged_attributes (fmc$highest_current_attribute + 4, status);
      RETURN; {----->
    IFEND;
    IF header^.unique_character <> fmc$unique_label_id THEN
      set_status_damaged_attributes (fmc$highest_current_attribute + 5, status);
      RETURN; {----->
    IFEND;
    file_previously_opened := header^.file_previously_opened;
    IF header^.file_previously_opened THEN
      static_label_attributes.ring_attributes_source := header^.ring_attributes_source;
      static_label_attributes.ring_attributes := header^.ring_attributes;
    IFEND;

    IF header^.highest_attribute_present > 0 THEN
      reassign_file_contents := FALSE;

    /cycle_attributes/
      FOR attribute_key := LOWERBOUND (header^.attribute_present) TO header^.highest_attribute_present DO
        IF (attribute_key < 1) OR (attribute_key > fmc$highest_current_attribute) OR
              (NOT header^.attribute_present [attribute_key]) THEN
          CYCLE /cycle_attributes/; {----->
        IFEND;

        CASE attribute_key OF
        = fmc$block_type =
          NEXT static_label_item: [fmc$block_type] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$block_type, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.block_type_source := static_label_item^.source;
          static_label_attributes.block_type := static_label_item^.block_type;

        = fmc$character_conversion =
          NEXT static_label_item: [fmc$character_conversion] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$character_conversion, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.character_conversion_source := static_label_item^.source;
          static_label_attributes.character_conversion := static_label_item^.character_conversion;

        = fmc$clear_space =
          NEXT static_label_item: [fmc$clear_space] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$clear_space, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.clear_space_source := static_label_item^.source;
          static_label_attributes.clear_space := static_label_item^.clear_space;

        = fmc$file_access_procedure =
          NEXT static_label_item: [fmc$file_access_procedure] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$file_access_procedure, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.file_access_procedure_source := static_label_item^.source;
          get_entry_point_reference (static_label_attributes.file_access_procedure, ignore_path, status);

        = fmc$file_contents =
          NEXT static_label_item: [fmc$file_contents] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$file_contents, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.file_contents_source := static_label_item^.source;
          get_name (static_label_attributes.file_contents, status);
          fsp$convert_to_old_contents (static_label_attributes.file_contents, split_file_contents,
                split_file_structure);
          reassign_file_contents := split_file_structure <> fsc$unknown_contents;

        = fmc$file_limit =
          NEXT static_label_item: [fmc$file_limit] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$file_limit, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.file_limit_source := static_label_item^.source;
          static_label_attributes.file_limit := static_label_item^.integer_value;

        = fmc$file_organization =
          NEXT static_label_item: [fmc$file_organization] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$file_organization, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.file_organization_source := static_label_item^.source;
          static_label_attributes.file_organization := static_label_item^.file_organization;

        = fmc$file_processor =
          NEXT static_label_item: [fmc$file_processor] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$file_processor, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.file_processor_source := static_label_item^.source;
          get_name (static_label_attributes.file_processor, status);

        = fmc$file_structure =
          NEXT static_label_item: [fmc$file_structure] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$file_structure, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.file_structure_source := static_label_item^.source;
          get_name (static_label_attributes.file_structure, status);

        = fmc$forced_write =
          NEXT static_label_item: [fmc$forced_write] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$forced_write, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.forced_write_source := static_label_item^.source;
          static_label_attributes.forced_write := static_label_item^.forced_write;

        = fmc$internal_code =
          NEXT static_label_item: [fmc$internal_code] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$internal_code, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.internal_code_source := static_label_item^.source;
          static_label_attributes.internal_code := static_label_item^.internal_code;

        = fmc$label_type =
          NEXT static_label_item: [fmc$label_type] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$label_type, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.label_type_source := static_label_item^.source;
          static_label_attributes.label_type := static_label_item^.label_type;

        = fmc$line_number =
          NEXT static_label_item: [fmc$line_number] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$line_number, status);
            RETURN; {----->
          IFEND;
          IF (static_label_item^.line_number.length >= LOWERVALUE (amt$line_number_length)) AND
                (static_label_item^.line_number.length <= UPPERVALUE (amt$line_number_length)) AND
                (static_label_item^.line_number.location >= LOWERVALUE (amt$line_number_location)) AND
                (static_label_item^.line_number.location <= UPPERVALUE (amt$line_number_location)) THEN
            static_label_attributes.line_number_source := static_label_item^.source;
            static_label_attributes.line_number := static_label_item^.line_number;
          IFEND;

        = fmc$max_block_length =
          NEXT static_label_item: [fmc$max_block_length] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$max_block_length, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.max_block_length_source := static_label_item^.source;
          static_label_attributes.max_block_length := static_label_item^.integer_value;

        = fmc$max_record_length =
          NEXT static_label_item: [fmc$max_record_length] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$max_record_length, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.max_record_length_source := static_label_item^.source;
          static_label_attributes.max_record_length := static_label_item^.integer_value;

        = fmc$min_block_length =
          NEXT static_label_item: [fmc$min_block_length] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$min_block_length, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.min_block_length_source := static_label_item^.source;
          static_label_attributes.min_block_length := static_label_item^.integer_value;

        = fmc$min_record_length =
          NEXT static_label_item: [fmc$min_record_length] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$min_record_length, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.min_record_length_source := static_label_item^.source;
          static_label_attributes.min_record_length := static_label_item^.integer_value;

        = fmc$padding_character =
          NEXT static_label_item: [fmc$padding_character] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$padding_character, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.padding_character_source := static_label_item^.source;
          static_label_attributes.padding_character := static_label_item^.padding_character;

        = fmc$page_format =
          NEXT static_label_item: [fmc$page_format] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$page_format, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.page_format_source := static_label_item^.source;
          static_label_attributes.page_format := static_label_item^.page_format;

        = fmc$page_length =
          NEXT static_label_item: [fmc$page_length] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$page_length, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.page_length_source := static_label_item^.source;
          static_label_attributes.page_length := static_label_item^.integer_value;

        = fmc$page_width =
          NEXT static_label_item: [fmc$page_width] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$page_width, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.page_width_source := static_label_item^.source;
          static_label_attributes.page_width := static_label_item^.integer_value;

        = fmc$preset_value =
          NEXT static_label_item: [fmc$preset_value] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$preset_value, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.preset_value_source := static_label_item^.source;
          static_label_attributes.preset_value := static_label_item^.integer_value;

        = fmc$record_delimiting_character =
          NEXT static_label_item: [fmc$record_delimiting_character] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$record_delimiting_character, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.record_delimiting_char_source := static_label_item^.source;
          static_label_attributes.record_delimiting_character :=
                static_label_item^.record_delimiting_character;

        = fmc$record_type =
          NEXT static_label_item: [fmc$record_type] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$record_type, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.record_type_source := static_label_item^.source;
          static_label_attributes.record_type := static_label_item^.record_type;

        = fmc$ring_attributes =

{ processed above prior to FOR loop

          ;
        = fmc$statement_identifier =
          NEXT static_label_item: [fmc$statement_identifier] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$statement_identifier, status);
            RETURN; {----->
          IFEND;
          IF (static_label_item^.statement_identifier.length >= LOWERVALUE (amt$statement_id_length)) AND
                (static_label_item^.statement_identifier.length <= UPPERVALUE (amt$statement_id_length)) AND
                (static_label_item^.statement_identifier.location >=
                LOWERVALUE (amt$statement_id_location)) AND (static_label_item^.statement_identifier.
                location <= UPPERVALUE (amt$statement_id_location)) THEN
            static_label_attributes.statement_identifier_source := static_label_item^.source;
            static_label_attributes.statement_identifier := static_label_item^.statement_identifier;
          IFEND;

        = fmc$user_info =
          NEXT static_label_item: [fmc$user_info] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$user_info, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.user_info_source := static_label_item^.source;
          IF static_label_item^.user_info_present THEN
            NEXT str: [32] IN static_label;
            IF str = NIL THEN
              set_status_damaged_attributes (fmc$user_info, status);
              RETURN; {----->
            IFEND;
            static_label_attributes.user_info := str^;
          IFEND;

        = fmc$vertical_print_density =
          NEXT static_label_item: [fmc$vertical_print_density] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$vertical_print_density, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.vertical_print_density_source := static_label_item^.source;
          static_label_attributes.vertical_print_density := static_label_item^.integer_value;

        = fmc$average_record_length =
          NEXT static_label_item: [fmc$average_record_length] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$average_record_length, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.average_record_length_source := static_label_item^.source;
          static_label_attributes.average_record_length := static_label_item^.integer_value;

        = fmc$collate_table =
          NEXT static_label_item: [fmc$collate_table] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$collate_table, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.collate_table_source := static_label_item^.source;
          static_label_attributes.collate_table := static_label_item^.collate_table;

        = fmc$collate_table_name =
          NEXT static_label_item: [fmc$collate_table_name] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$collate_table_name, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.collate_table_name_source := static_label_item^.source;
          get_entry_point_reference (static_label_attributes.collate_table_name, ignore_path, status);

        = fmc$compression_procedure_name =
          NEXT static_label_item: [fmc$compression_procedure_name] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$compression_procedure_name, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.compression_proc_name_source := static_label_item^.source;
          get_entry_point_reference (static_label_attributes.compression_procedure_name.name,
                static_label_attributes.compression_procedure_name.object_library, status);

        = fmc$data_padding =
          NEXT static_label_item: [fmc$data_padding] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$data_padding, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.data_padding_source := static_label_item^.source;
          static_label_attributes.data_padding := static_label_item^.data_padding;

        = fmc$dynamic_home_block_space =
          NEXT static_label_item: [fmc$dynamic_home_block_space] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$dynamic_home_block_space, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.dynamic_home_block_space_source := static_label_item^.source;
          static_label_attributes.dynamic_home_block_space := static_label_item^.dynamic_home_block_space;

        = fmc$embedded_key =
          NEXT static_label_item: [fmc$embedded_key] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$embedded_key, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.embedded_key_source := static_label_item^.source;
          static_label_attributes.embedded_key := static_label_item^.embedded_key;

        = fmc$estimated_record_count =
          NEXT static_label_item: [fmc$estimated_record_count] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$estimated_record_count, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.estimated_record_count_source := static_label_item^.source;
          static_label_attributes.estimated_record_count := static_label_item^.integer_value;

        = fmc$hashing_procedure_name =
          NEXT static_label_item: [fmc$hashing_procedure_name] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$hashing_procedure_name, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.hashing_procedure_name_source := static_label_item^.source;
          get_entry_point_reference (static_label_attributes.hashing_procedure_name.name,
                static_label_attributes.hashing_procedure_name.object_library, status);

        = fmc$index_levels =
          NEXT static_label_item: [fmc$index_levels] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$index_levels, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.index_levels_source := static_label_item^.source;
          static_label_attributes.index_levels := static_label_item^.integer_value;

        = fmc$index_padding =
          NEXT static_label_item: [fmc$index_padding] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$index_padding, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.index_padding_source := static_label_item^.source;
          static_label_attributes.index_padding := static_label_item^.index_padding;

        = fmc$initial_home_block_count =
          NEXT static_label_item: [fmc$initial_home_block_count] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$initial_home_block_count, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.initial_home_block_count_source := static_label_item^.source;
          static_label_attributes.initial_home_block_count := static_label_item^.integer_value;

        = fmc$key_length =
          NEXT static_label_item: [fmc$key_length] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$key_length, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.key_length_source := static_label_item^.source;
          static_label_attributes.key_length := static_label_item^.integer_value;

        = fmc$key_position =
          NEXT static_label_item: [fmc$key_position] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$key_position, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.key_position_source := static_label_item^.source;
          static_label_attributes.key_position := static_label_item^.integer_value;

        = fmc$key_type =
          NEXT static_label_item: [fmc$key_type] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$key_type, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.key_type_source := static_label_item^.source;
          static_label_attributes.key_type := static_label_item^.key_type;

        = fmc$loading_factor =
          NEXT static_label_item: [fmc$loading_factor] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$loading_factor, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.loading_factor_source := static_label_item^.source;
          static_label_attributes.loading_factor := static_label_item^.loading_factor;

        = fmc$lock_expiration_time =
          NEXT static_label_item: [fmc$lock_expiration_time] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$lock_expiration_time, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.lock_expiration_time_source := static_label_item^.source;
          static_label_attributes.lock_expiration_time := static_label_item^.integer_value;

        = fmc$logging_options =
          NEXT static_label_item: [fmc$logging_options] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$logging_options, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.logging_options_source := static_label_item^.source;
          static_label_attributes.logging_options := static_label_item^.logging_options;

        = fmc$log_residence =
          NEXT static_label_item: [fmc$log_residence] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$log_residence, status);
            RETURN; {----->
          IFEND;
          NEXT str: [static_label_item^.path_length] IN static_label;
          IF str = NIL THEN
            set_status_damaged_attributes (fmc$log_residence, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.log_residence_source := static_label_item^.source;
          static_label_attributes.log_residence := str^;

        = fmc$record_limit =
          NEXT static_label_item: [fmc$record_limit] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$record_limit, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.record_limit_source := static_label_item^.source;
          static_label_attributes.record_limit := static_label_item^.integer_value;

        = fmc$records_per_block =
          NEXT static_label_item: [fmc$records_per_block] IN static_label;
          IF static_label_item = NIL THEN
            set_status_damaged_attributes (fmc$records_per_block, status);
            RETURN; {----->
          IFEND;
          static_label_attributes.records_per_block_source := static_label_item^.source;
          static_label_attributes.records_per_block := static_label_item^.integer_value;

        CASEND;
      FOREND /cycle_attributes/;

      IF reassign_file_contents AND NOT ((split_file_contents = fsc$list) AND
            (split_file_structure = fsc$data) AND (static_label_attributes.file_structure =
            fsc$unknown_contents)) THEN
        static_label_attributes.file_contents := split_file_contents;
        static_label_attributes.file_structure := split_file_structure;
        static_label_attributes.file_structure_source := static_label_attributes.file_contents_source;
      IFEND;
    IFEND;

  PROCEND fsp$expand_file_label;
?? OLDTITLE ??
MODEND fsm$expand_file_label;
