*copyc osd$default_pragmats
?? NEWTITLE := 'NOS/VE : Basic Access Methods : Table Displays' ??

MODULE sym$display_bam_tables;

{  PURPOSE:
{    This module contains procedures called by syp$jobfileprc (the
{    procedure which interprets the display_job_tables(disjt)
{    system_core_debugger command.  These procedures display
{    symbolically the contents of a BAM table.
{
{  DESIGN:
{    The XDCLed procedures set up what is to be displayed and call internal
{    procedures to do the displaying.  Each internal procedure is passed
{    the record (or a pointer to it) that is to be displayed and the column
{    (indention) at which the display should start.


?? NEWTITLE := 'Global Declarations Referenced by This Module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc amt$file_reference
*copyc bat$task_file_table
*copyc bat$display_tables_indention
*copyc cyc$max_string_size
*copyc fmc$cycle_table_allocation_size
*copyc fmc$entry_assigned
*copyc fmc$number_of_init_cycle_descs
*copyc fmc$number_of_init_path_descs
*copyc fmc$path_table_allocation_size
*copyc fmc$pde_unique_identifier
*copyc fme$file_management_errors
*copyc fmt$cd_attachment_options
*copyc fmt$cycle_description
*copyc fmt$cycle_description_unit
*copyc fmt$path_description_entry
*copyc fmt$path_description_unit
*copyc fmt$path_element_type
*copyc fmt$path_handle
*copyc fmt$static_label_header
*copyc fmt$static_label_item
*copyc fmt$system_file_label
*copyc fsc$max_path_elements
*copyc fst$path
*copyc fst$path_handle_name
*copyc fst$path_table_expansion_limit
*copyc osd$random_name
*copyc ost$status
?? POP ??
*copyc clp$construct_path_handle_name
*copyc clp$convert_integer_to_string
*copyc clp$trimmed_string_size
*copyc osp$set_status_abnormal
*copyc syp$write_output_line

?? TITLE := 'Global Declarations Declared by This Module', EJECT ??

  CONST
    title_length = 70;

?? TITLE := 'PROCEDURE [XDCL] syp$display_bam_tables', EJECT ??

  PROCEDURE [XDCL] syp$display_bam_tables
    (    initial_pdu_pointer: ^fmt$path_description_unit;
     VAR status: ost$status);

    status.normal := TRUE;

    syp$display_paths (initial_pdu_pointer, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    display_path_table (initial_pdu_pointer, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

  PROCEND syp$display_bam_tables;

?? TITLE := 'PROCEDURE [XDCL] syp$display_files', EJECT ??

  PROCEDURE [XDCL] syp$display_files
    (    initial_pdu_pointer: ^fmt$path_description_unit;
     VAR status: ost$status);

    VAR
      entry: 1 .. cyc$max_string_size,
      output_length: integer,
      output_path: string (fsc$max_path_size + 8),
      output_string: string (bat$display_tables_str_length),
      path: string (fsc$max_path_size),
      path_handle: fmt$path_handle,
      path_handle_name: amt$local_file_name,
      path_length: fst$path_size,
      pde: ^fmt$path_description_entry,
      pdu: ^fmt$path_description_unit,
      temp_pde: ^fmt$path_description_entry;

    status.normal := TRUE;

    { get pointer first entry in the first path_description_unit }
    pdu := initial_pdu_pointer;

    display_title ('FILES IN PATH TABLE', status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    WHILE pdu <> NIL DO

      { look at every assigned entry in a path_description_unit }
      FOR entry := 1 TO #SIZE (pdu^.entry_assignment^) DO
        IF pdu^.entry_assignment^ (entry) = fmc$entry_assigned THEN
          pde := ^pdu^.entries^ [entry];
          IF (pde^.entry_type = fmc$file_cycle_object) AND
                (pde^.cycle_description <> NIL) THEN
            get_path (pde, path, path_length, status);
            IF NOT status.normal THEN
              RETURN;
            IFEND;

            STRINGREP (output_path, output_length, ' path = ',
                  path (1, path_length));
            syp$write_output_line (output_path (1, output_length), status);
            IF NOT status.normal THEN
              RETURN;
            IFEND;
            { create a path_handle_name for the cycle_object }
            path_handle := pde^.cycle_description^.path_handle;
            clp$construct_path_handle_name (path_handle, path_handle_name);
            STRINGREP (output_string, output_length, ' ': 5,
                  'attached = ', pde^.cycle_description^.attached_file,
                  '    path_handle_name = ', path_handle_name( 1,
                  clp$trimmed_string_size( path_handle_name)));
            syp$write_output_line (output_string (1, output_length), status);
            IF NOT status.normal THEN
              RETURN;
            IFEND;
            temp_pde := pde^.first_cycle_alias_entry;
            WHILE temp_pde <> NIL DO
              { create a path_handle_name for the alias }
              path_handle.segment_offset := #OFFSET (temp_pde);
              path_handle.assignment_counter :=
                    temp_pde^.entry_assignment_counter;
              path_handle.open_position.specified := FALSE;
              clp$construct_path_handle_name (path_handle, path_handle_name);
              STRINGREP (output_string, output_length, ' ': 9, 'alias = ',
                    temp_pde^.path_node_name.value, ' phn = ',
                    path_handle_name( 1,
                    clp$trimmed_string_size( path_handle_name)));
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              temp_pde := temp_pde^.next_cycle_alias_entry;
            WHILEND;
          IFEND;
        IFEND;
      FOREND;

      { move on to next unit if pointer is not NIL}
      pdu := pdu^.next_path_description_unit;
    WHILEND;

  PROCEND syp$display_files;

?? TITLE := 'PROCEDURE [XDCL] syp$display_paths', EJECT ??

  PROCEDURE [XDCL] syp$display_paths
    (    initial_pdu_pointer: ^fmt$path_description_unit;
     VAR status: ost$status);

    status.normal := TRUE;

    display_pt_stats (initial_pdu_pointer, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    syp$display_files (initial_pdu_pointer, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    display_unused_paths (initial_pdu_pointer, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

  PROCEND syp$display_paths;
?? TITLE := 'PROCEDURE display_path_table', EJECT ??

  PROCEDURE display_path_table
    (    initial_pdu_pointer: ^fmt$path_description_unit;
     VAR status: ost$status);

    CONST
      entry_assignment_display_size = 50;

    VAR
      i: integer,
      indent: bat$display_tables_indention,
      output_length: integer,
      output_string: string (bat$display_tables_str_length),
      pde: ^fmt$path_description_entry,
      pdu: ^fmt$path_description_unit,
      unit: integer;

    status.normal := TRUE;

    display_title ('PATH TABLE', status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    indent := 5;
    unit := 1;
    pdu := initial_pdu_pointer;

    WHILE pdu <> NIL DO
      IF unit = 1 THEN
        STRINGREP (output_string, output_length, ' ',
              'PATH_DESCRIPTION_UNIT : ', pdu, '   UNIT # : ', unit: 4);
      ELSE
        STRINGREP (output_string, output_length, '1',
              'PATH_DESCRIPTION_UNIT : ', pdu, '   UNIT # : ', unit: 4);
      IFEND;
      syp$write_output_line (output_string (1, output_length), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      STRINGREP (output_string, output_length, ' ': indent,
            'next_path_description_unit : ', pdu^.next_path_description_unit);
      syp$write_output_line (output_string (1, output_length), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      STRINGREP (output_string, output_length, ' ': indent, 'total_count : ',
            pdu^.total_count);
      syp$write_output_line (output_string (1, output_length), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      STRINGREP (output_string, output_length, ' ': indent, 'current_count : ',
            pdu^.current_count);
      syp$write_output_line (output_string (1, output_length), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      STRINGREP (output_string, output_length, ' ': indent,
            '                   ', '         111111111122222222223333333333',
            '44444444445');
      syp$write_output_line (output_string (1, output_length), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      STRINGREP (output_string, output_length, ' ': indent,
            '                   ', '123456789012345678901234567890123456789',
            '01234567890');
      syp$write_output_line (output_string (1, output_length), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      i := 0;
      WHILE i < ((#SIZE (pdu^.entry_assignment^) - 1) DIV entry_assignment_display_size) DO
        i := i + 1;
        STRINGREP (output_string, output_length, ' ': indent,
              'entry_assignment : ', pdu^.entry_assignment^
              (((i - 1) * entry_assignment_display_size + 1),
              entry_assignment_display_size));
        syp$write_output_line (output_string (1, output_length), status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;
      WHILEND;

      STRINGREP (output_string, output_length, ' ': indent,
            'entry_assignment : ', pdu^.entry_assignment^
            ((i * entry_assignment_display_size + 1), * ));
      syp$write_output_line (output_string (1, output_length), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      FOR i := 1 TO #SIZE (pdu^.entry_assignment^) DO
        IF pdu^.entry_assignment^ (i) = fmc$entry_assigned THEN
          pde := ^pdu^.entries^ [i];
          STRINGREP (output_string, output_length, '-', ' ': indent - 1,
                'PATH_DESCRIPTION_ENTRY : ', pde, '   ENTRY # : ', i,
                '   UNIT # : ', unit: 4);
          syp$write_output_line (output_string (1, output_length), status);
          IF NOT status.normal THEN
            RETURN;
          IFEND;

          display_pde (pde, indent + 4, status);
          IF NOT status.normal THEN
            RETURN;
          IFEND;
        IFEND
      FOREND;
      unit := unit + 1;
      pdu := pdu^.next_path_description_unit;
    WHILEND;

  PROCEND display_path_table;

?? TITLE := 'PROCEDURE [XDCL] syp$display_pde', EJECT ??

  PROCEDURE [XDCL] syp$display_pde
    (    path_description_entry: ^fmt$path_description_entry;
     VAR status: ost$status);

    VAR
      indent: bat$display_tables_indention,
      output_length: integer,
      output_path: string (fsc$max_path_size + 8),
      output_string: string (bat$display_tables_str_length),
      path: string (fsc$max_path_size),
      path_length: fst$path_size,
      pde: ^fmt$path_description_entry;

    status.normal := TRUE;

    display_title ('PATH DESCRIPTION ENTRY', status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    pde := path_description_entry;

    get_path (pde, path, path_length, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_path, output_length, ' path = ', path (1, path_length));
    syp$write_output_line (output_path (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    indent := 5;
    STRINGREP (output_string, output_length, '-', 'PATH_DESCRIPTION_ENTRY : ',
          pde);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    display_pde (pde, indent, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    { display back up full path }
    WHILE pde^.parental_path_entry <> NIL DO
      pde := pde^.parental_path_entry;
      STRINGREP (output_string, output_length, '-',
            'PARENT PATH_DESCRIPTION_ENTRY : ', pde);
      syp$write_output_line (output_string (1, output_length), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      display_pde (pde, indent, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
    WHILEND;

    IF (path_description_entry^.entry_type = fmc$file_cycle_object) AND
          (path_description_entry^.first_cycle_alias_entry <> NIL) THEN
      pde := path_description_entry^.first_cycle_alias_entry;
      WHILE pde <> NIL DO
        STRINGREP (output_string, output_length, '-',
              'ALIAS PATH_DESCRIPTION_ENTRY : ', pde);
        syp$write_output_line (output_string (1, output_length), status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;
        display_pde (pde, indent, status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;
        pde := pde^.next_cycle_alias_entry;
      WHILEND;
    IFEND; {cycle_object}

  PROCEND syp$display_pde;

?? TITLE := 'PROCEDURE display_pt_stats', EJECT ??

  PROCEDURE display_pt_stats
    (    initial_pdu_pointer: ^fmt$path_description_unit;
     VAR status: ost$status);

    VAR
      cdu: ^fmt$cycle_description_unit,
      cdu_number: integer,
      depth: 1 .. fsc$max_path_elements,
      indent: bat$display_tables_indention,
      output_length: integer,
      output_string: string (bat$display_tables_str_length),
      pdu: ^fmt$path_description_unit,
      pdu_number: integer;

    status.normal := TRUE;

    display_title ('PATH TABLE STATISTICS', status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    indent := 5;

    STRINGREP (output_string, output_length, ' ': indent,
          'fmv$initial_pdu_pointer : ', initial_pdu_pointer);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': indent,
          'path_table_sizes (initial/allocated) : ',
          fmc$number_of_init_path_descs, '/', fmc$path_table_allocation_size);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    pdu := initial_pdu_pointer;
    pdu_number := 1;
    WHILE pdu <> NIL DO
      STRINGREP (output_string, output_length, ' ': indent,
            'total number of entries used in pdu ', pdu_number, ' : ',
            pdu^.total_count);
      syp$write_output_line (output_string (1, output_length), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      STRINGREP (output_string, output_length, ' ': indent,
            'number of active entries in pdu ', pdu_number, ' : ',
            pdu^.current_count);
      syp$write_output_line (output_string (1, output_length), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      pdu := pdu^.next_path_description_unit;
      pdu_number := pdu_number + 1;
    WHILEND;

    STRINGREP (output_string, output_length, ' ': indent,
          'cycle_table_sizes (initial/allocated) : ',
          fmc$number_of_init_cycle_descs, '/', fmc$cycle_table_allocation_size);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

  PROCEND display_pt_stats;

?? TITLE := 'PROCEDURE display_unused_paths', EJECT ??

  PROCEDURE display_unused_paths
    (    initial_pdu_pointer: ^fmt$path_description_unit;
     VAR status: ost$status);

    VAR
      entry: 1 .. cyc$max_string_size,
      output_length: integer,
      output_string: string (bat$display_tables_str_length),
      output_path: string (fsc$max_path_size + 8),
      path: string (fsc$max_path_size),
      path_handle: fmt$path_handle,
      path_handle_name: amt$local_file_name,
      path_length: fst$path_size,
      pde: ^fmt$path_description_entry,
      pdu: ^fmt$path_description_unit;

    status.normal := TRUE;

    { get pointer first entry in the first path_description_unit }
    pdu := initial_pdu_pointer;

    display_title ('PATH TABLE UNUSED PATHS', status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    WHILE pdu <> NIL DO

      { look at every assigned entry in a path_description_unit }
      FOR entry := 1 TO #SIZE (pdu^.entry_assignment^) DO
        IF pdu^.entry_assignment^ (entry) = fmc$entry_assigned THEN
          pde := ^pdu^.entries^ [entry];
          IF ((pde^.entry_type = fmc$file_cycle_object) AND
                (pde^.cycle_description = NIL)) OR
                ((pde^.entry_type = fmc$named_object) AND
                (pde^.active_path_participation_count = 0) AND
                (pde^.highest_cycle = NIL)) THEN
            get_path (pde, path, path_length, status);
            IF NOT status.normal THEN
              RETURN;
            IFEND;

            STRINGREP (output_path, output_length, ' path = ',
                  path (1, path_length));
            syp$write_output_line (output_path (1, output_length), status);
            IF NOT status.normal THEN
              RETURN;
            IFEND;

            { create a path_handle_name for the cycle_object }
            path_handle.segment_offset := #OFFSET (pde);
            path_handle.assignment_counter := pde^.entry_assignment_counter;
            path_handle.open_position.specified := FALSE;
            clp$construct_path_handle_name (path_handle, path_handle_name);
            STRINGREP (output_string, output_length, ' ': 5,
                  'externalized = ', pde^.path_handle_name_externalized,
                  '    path_handle_name = ', path_handle_name( 1,
                  clp$trimmed_string_size( path_handle_name)));
            syp$write_output_line (output_string (1, output_length), status);
            IF NOT status.normal THEN
              RETURN;
            IFEND;

          IFEND; {end of a path}
        IFEND; {assigned}
      FOREND;

      { move on to next unit if pointer is not NIL}
      pdu := pdu^.next_path_description_unit;
    WHILEND;

  PROCEND display_unused_paths;

?? TITLE := ' PROCEDURE append_cycle_damage_symptoms', EJECT ??

  PROCEDURE append_cycle_damage_symptoms
    (    cycle_damage_symptoms: fst$cycle_damage_symptoms;
     VAR str: {i/o} string (300);
     VAR str_length: {i/o} integer);

    IF cycle_damage_symptoms = $fst$cycle_damage_symptoms [] THEN
      STRINGREP (str, str_length, str (1, str_length), 'NONE');
    ELSE
      STRINGREP (str, str_length, str (1, str_length), '(');
      IF fsc$media_image_inconsistent IN cycle_damage_symptoms THEN
        STRINGREP (str, str_length, str (1, str_length),
              'fsc$media_image_inconsistant, ');
      IFEND;
      IF fsc$respf_modification_mismatch IN cycle_damage_symptoms THEN
        STRINGREP (str, str_length, str (1, str_length),
              'fsc$respf_modification_mismatch, ');
      IFEND;
      IF fsc$cycle_restored IN cycle_damage_symptoms THEN
        STRINGREP (str, str_length, str (1, str_length), 'fsc$cycle_restored, ');
      IFEND;
      IF fsc$parent_catalog_restored IN cycle_damage_symptoms THEN
        STRINGREP (str, str_length, str (1, str_length), 'fsc$parent_catalog_restored, ');
      IFEND;
      str_length := str_length - 1;
      str (str_length) := ')';
    IFEND;

  PROCEND append_cycle_damage_symptoms;

?? TITLE := ' PROCEDURE append_file_access_options ', EJECT ??

  PROCEDURE append_file_access_options
    (    access_or_share_modes: fst$file_access_options;
     VAR str: {i/o} string (bat$display_tables_str_length);
     VAR str_length: {i/o} integer);

    IF access_or_share_modes = $fst$file_access_options [] THEN
      STRINGREP (str, str_length, str (1, str_length), 'NONE');
    ELSE
      STRINGREP (str, str_length, str (1, str_length), '(');
      IF fsc$read IN access_or_share_modes THEN
        STRINGREP (str, str_length, str (1, str_length), 'READ, ');
      IFEND;
      IF fsc$shorten IN access_or_share_modes THEN
        STRINGREP (str, str_length, str (1, str_length), 'SHORTEN, ');
      IFEND;
      IF fsc$append IN access_or_share_modes THEN
        STRINGREP (str, str_length, str (1, str_length), 'APPEND, ');
      IFEND;
      IF fsc$modify IN access_or_share_modes THEN
        STRINGREP (str, str_length, str (1, str_length), 'MODIFY, ');
      IFEND;
      IF fsc$execute IN access_or_share_modes THEN
        STRINGREP (str, str_length, str (1, str_length), 'EXECUTE, ');
      IFEND;
      str_length := str_length - 1;
      str (str_length) := ')';
    IFEND;

  PROCEND append_file_access_options;

?? TITLE := ' PROCEDURE append_message_control ', EJECT ??

  PROCEDURE append_logging_options
    (    logging_options: amt$logging_options;
     VAR str: {i/o} string (bat$display_tables_str_length);
     VAR str_length: {i/o} integer);

    IF logging_options = $amt$logging_options [] THEN
      STRINGREP (str, str_length, str (1, str_length), 'NONE');
    ELSE
      STRINGREP (str, str_length, str (1, str_length), '(');
      IF amc$enable_parcels IN logging_options THEN
        STRINGREP (str, str_length, str (1, str_length),
              'AMC$ENABLE_PARCELS, ');
      IFEND;
      IF amc$enable_media_recovery IN logging_options THEN
        STRINGREP (str, str_length, str (1, str_length),
              'AMC$ENABLE_MEDIA_RECOVERY, ');
      IFEND;
      IF amc$enable_request_recovery IN logging_options THEN
        STRINGREP (str, str_length, str (1, str_length),
              'AMC$ENABLE_REQUEST_RECOVERY, ');
      IFEND;
      str_length := str_length - 1;
      str (str_length) := ')';
    IFEND;

  PROCEND append_logging_options;

?? TITLE := ' PROCEDURE append_message_control ', EJECT ??

  PROCEDURE append_message_control
    (    message_control: amt$message_control;
     VAR str: {i/o} string (bat$display_tables_str_length);
     VAR str_length: {i/o} integer);

    IF message_control = $amt$message_control [] THEN
      STRINGREP (str, str_length, str (1, str_length), 'NONE');
    ELSE
      STRINGREP (str, str_length, str (1, str_length), '(');
      IF amc$trivial_errors IN message_control THEN
        STRINGREP (str, str_length, str (1, str_length),
              'AMC$TRIVIAL_ERRORS, ');
      IFEND;
      IF amc$messages IN message_control THEN
        STRINGREP (str, str_length, str (1, str_length), 'AMC$MESSAGES, ');
      IFEND;
      IF amc$statistics IN message_control THEN
        STRINGREP (str, str_length, str (1, str_length), 'AMC$STATISTICS, ');
      IFEND;
      str_length := str_length - 1;
      str (str_length) := ')';
    IFEND;

  PROCEND append_message_control;

?? TITLE := ' PROCEDURE append_usage_selections ', EJECT ??

  PROCEDURE append_usage_selections
    (    access_or_share_modes: pft$usage_selections;
     VAR str: {i/o} string (bat$display_tables_str_length);
     VAR str_length: {i/o} integer);

    IF access_or_share_modes = $pft$usage_selections [] THEN
      STRINGREP (str, str_length, str (1, str_length), 'NONE');
    ELSE
      STRINGREP (str, str_length, str (1, str_length), '(');
      IF pfc$read IN access_or_share_modes THEN
        STRINGREP (str, str_length, str (1, str_length), 'READ, ');
      IFEND;
      IF pfc$shorten IN access_or_share_modes THEN
        STRINGREP (str, str_length, str (1, str_length), 'SHORTEN, ');
      IFEND;
      IF pfc$append IN access_or_share_modes THEN
        STRINGREP (str, str_length, str (1, str_length), 'APPEND, ');
      IFEND;
      IF pfc$modify IN access_or_share_modes THEN
        STRINGREP (str, str_length, str (1, str_length), 'MODIFY, ');
      IFEND;
      IF pfc$execute IN access_or_share_modes THEN
        STRINGREP (str, str_length, str (1, str_length), 'EXECUTE, ');
      IFEND;
      IF pfc$cycle IN access_or_share_modes THEN
        STRINGREP (str, str_length, str (1, str_length), 'CYCLE, ');
      IFEND;
      IF pfc$control IN access_or_share_modes THEN
        STRINGREP (str, str_length, str (1, str_length), 'CONTROL, ');
      IFEND;
      str_length := str_length - 1;
      str (str_length) := ')';
    IFEND;

  PROCEND append_usage_selections;

?? TITLE := ' PROCEDURE display_apfid ', EJECT ??

  PROCEDURE display_apfid
    (    apfid: pft$attached_permanent_file_id,
         indent: bat$display_tables_indention;
     VAR status: ost$status);

    VAR
      output_length: integer,
      output_string: string (bat$display_tables_str_length);


    status.normal := TRUE;
    CASE apfid.family_location OF
    = pfc$local_mainframe =
      STRINGREP (output_string, output_length, ' ': indent,
            'pfc$local_mainframe - index : ', apfid.attached_pf_table_index);
      syp$write_output_line (output_string (1, output_length), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
    = pfc$server_mainframe =
      STRINGREP (output_string, output_length, ' ': indent,
            'pfc$server_mainframe - index : ', apfid.
            server_attached_pf_table_index);
      syp$write_output_line (output_string (1, output_length), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      STRINGREP (output_string, output_length, ' ': indent,
            'Served family index : ', apfid.served_family_table_index.
            pointers_index, ' ', apfid.served_family_table_index.
            family_list_index);
      syp$write_output_line (output_string (1, output_length), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      STRINGREP (output_string, output_length, ' ': indent,
            'Server lifetime : ', apfid.server_lifetime);
      syp$write_output_line (output_string (1, output_length), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

    ELSE
      STRINGREP (output_string, output_length, ' ': indent,
            ' UNKNOWN residence ');
      syp$write_output_line (output_string (1, output_length), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

    CASEND;
  PROCEND display_apfid;

?? TITLE := 'PROCEDURE display_cd_entry', EJECT ??

  PROCEDURE display_cd_entry
    (    cde: ^fmt$cycle_description;
         indent: bat$display_tables_indention;
     VAR status: ost$status);

    VAR
      local_indent: bat$display_tables_indention,
      output_length: integer,
      output_string: string (bat$display_tables_str_length),
      path_handle_name: fst$path_handle_name;

    status.normal := TRUE;

    IF cde^.entry_assignment^ = fmc$entry_assigned THEN
      clp$construct_path_handle_name (cde^.path_handle, path_handle_name);
      STRINGREP (output_string, output_length, ' ': indent, 'path_handle_name : ',
            path_handle_name);
      syp$write_output_line (output_string (1, output_length), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      STRINGREP (output_string, output_length, ' ': indent,
            'global_file_information : ', cde^.global_file_information);
      syp$write_output_line (output_string (1, output_length), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      IF cde^.global_file_information <> NIL THEN
        syp$display_global_file_info (cde^.global_file_information,
              indent + 4, status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;
      IFEND;

      STRINGREP (output_string, output_length, ' ': indent,
            'static_setfa_entries : ',
            cde^.static_setfa_entries);
      syp$write_output_line (output_string (1, output_length), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      STRINGREP (output_string, output_length, ' ': indent,
            'dynamic_setfa_entries : ',
            cde^.dynamic_setfa_entries);
      syp$write_output_line (output_string (1, output_length), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      STRINGREP (output_string, output_length, ' ': indent, 'cd_attachment_options : ',
            cde^.cd_attachment_options);
      syp$write_output_line (output_string (1, output_length), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      IF cde^.cd_attachment_options <> NIL THEN
        IF cde^.cd_attachment_options^.free_behind_specified THEN
          STRINGREP (output_string, output_length, ' ': indent+4, 'free_behind : ',
                cde^.cd_attachment_options^.free_behind);
          syp$write_output_line (output_string (1, output_length), status);
          IF NOT status.normal THEN
            RETURN;
          IFEND;
        IFEND;
        IF cde^.cd_attachment_options^.job_write_concurrency_specified THEN
          STRINGREP (output_string, output_length, ' ': indent+4, 'job_write_concurrency : ',
                cde^.cd_attachment_options^.job_write_concurrency);
          syp$write_output_line (output_string (1, output_length), status);
          IF NOT status.normal THEN
            RETURN;
          IFEND;
        IFEND;
        IF cde^.cd_attachment_options^.private_read_specified THEN
          STRINGREP (output_string, output_length, ' ': indent+4, 'private_read : ',
                cde^.cd_attachment_options^.private_read);
          syp$write_output_line (output_string (1, output_length), status);
          IF NOT status.normal THEN
            RETURN;
          IFEND;
        IFEND;
        IF cde^.cd_attachment_options^.sequential_access_specified THEN
          STRINGREP (output_string, output_length, ' ': indent+4, 'sequential_access : ',
                cde^.cd_attachment_options^.sequential_access);
          syp$write_output_line (output_string (1, output_length), status);
          IF NOT status.normal THEN
            RETURN;
          IFEND;
        IFEND;
        IF cde^.cd_attachment_options^.transfer_size_specified THEN
          STRINGREP (output_string, output_length, ' ': indent+4, 'transfer_size : ',
                cde^.cd_attachment_options^.transfer_size);
          syp$write_output_line (output_string (1, output_length), status);
          IF NOT status.normal THEN
            RETURN;
          IFEND;
        IFEND;
      IFEND;

      STRINGREP (output_string, output_length, ' ': indent,
            'attached_file : ', cde^.attached_file);
      syp$write_output_line (output_string (1, output_length), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      IF cde^.attached_file THEN
        local_indent := indent + 4;
        STRINGREP (output_string, output_length, ' ': local_indent,
              'system_file_label  ');
        syp$write_output_line (output_string (1, output_length), status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;

        display_system_file_label (^cde^.system_file_label, local_indent + 4,
              status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;

        put_device_class (cde^.device_class, local_indent, status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;
        local_indent := local_indent + 4;
        CASE cde^.device_class OF
        = rmc$magnetic_tape_device, rmc$mass_storage_device =
          STRINGREP (output_string, output_length, ' ': local_indent,
                'job_routing_label : ', cde^.job_routing_label);
          syp$write_output_line (output_string (1, output_length), status);
          IF NOT status.normal THEN
            RETURN;
          IFEND;

          STRINGREP (output_string, output_length, ' ': local_indent,
                'job_routing_label_length : ', cde^.job_routing_label_length);
          syp$write_output_line (output_string (1, output_length), status);
          IF NOT status.normal THEN
            RETURN;
          IFEND;

          STRINGREP (output_string, output_length, ' ': local_indent,
                'system_file_id : ',
                cde^.system_file_id.file_entry_index, ' ',
                cde^.system_file_id.residence, ' ',
                cde^.system_file_id.file_hash);
          syp$write_output_line (output_string (1, output_length), status);
          IF NOT status.normal THEN
            RETURN;
          IFEND;

          STRINGREP (output_string, output_length, ' ': local_indent,
                'permanent_file : ', cde^.permanent_file);
          syp$write_output_line (output_string (1, output_length), status);
          IF NOT status.normal THEN
            RETURN;
          IFEND;

          IF cde^.permanent_file THEN
            local_indent := local_indent + 4;
            display_apfid (cde^.apfid, local_indent, status);
            IF NOT status.normal THEN
              RETURN;
            IFEND;

            STRINGREP (output_string, output_length, ' ': local_indent,
                  'attached_access_modes : ');
            append_file_access_options (cde^.attached_access_modes,
                  output_string, output_length);
            syp$write_output_line (output_string (1, output_length), status);
            IF NOT status.normal THEN
              RETURN;
            IFEND;

            STRINGREP (output_string, output_length, ' ': local_indent,
                  'attached_share_modes : ');
            append_file_access_options (cde^.attached_share_modes, output_string,
                  output_length);
            syp$write_output_line (output_string (1, output_length), status);
            IF NOT status.normal THEN
              RETURN;
            IFEND;

            STRINGREP (output_string, output_length, ' ': local_indent,
                  'password_protected : ', cde^.password_protected);
            syp$write_output_line (output_string (1, output_length), status);
            IF NOT status.normal THEN
              RETURN;
            IFEND;

            STRINGREP (output_string, output_length, ' ': local_indent,
                  'system_file_label_catalogued : ', cde^.system_file_label_catalogued);
            syp$write_output_line (output_string (1, output_length), status);
            IF NOT status.normal THEN
              RETURN;
            IFEND;
          IFEND;
        ELSE
        CASEND;
      IFEND;
    ELSE
      STRINGREP (output_string, output_length, ' ': indent,
            'cycle_description_entry not assigned');
      syp$write_output_line (output_string (1, output_length), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
    IFEND;

  PROCEND display_cd_entry;

?? TITLE := 'PROCEDURE display_descriptive_attr', EJECT ??

  PROCEDURE display_descriptive_attr
    (    descriptive: ^bat$descriptive_file_attributes;
         indent: bat$display_tables_indention;
     VAR status: ost$status);

    VAR
      global_file_name: ost$name,
      output_length: integer,
      output_string: string (bat$display_tables_str_length);

    status.normal := TRUE;

    STRINGREP (output_string, output_length, ' ': indent,
          'application_info : ', descriptive^.application_info);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    put_source (descriptive^.application_info_source, indent, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': indent,
          'global_access_mode : ');
    append_usage_selections (descriptive^.global_access_mode, output_string,
          output_length);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    put_source (descriptive^.global_access_mode_source, indent, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    global_file_name := 'NOT DISPLAYED';
{   pmp$convert_binary_unique_name (descriptive^.global_file_name,
{        global_file_name, status);
{   IF NOT status.normal THEN
{     RETURN;
{   IFEND;
    STRINGREP (output_string, output_length, ' ': indent,
          'global_file_name : ', global_file_name);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    put_source (descriptive^.global_file_name_source, indent, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    global_file_name := 'NOT DISPLAYED';
{   pmp$convert_binary_unique_name (descriptive^.global_file_name,
{        global_file_name, status);
{   IF NOT status.normal THEN
{     RETURN;
{   IFEND;
    STRINGREP (output_string, output_length, ' ': indent,
          'internal_cycle_name : ', global_file_name);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    put_source (descriptive^.global_file_name_source, indent, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': indent,
          'global_share_mode : ');
    append_usage_selections (descriptive^.global_share_mode, output_string,
          output_length);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    put_source (descriptive^.global_share_mode_source, indent, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': indent, 'permanent_file : ',
          descriptive^.permanent_file);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    put_source (descriptive^.permanent_file_source, indent, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

  PROCEND display_descriptive_attr;

?? TITLE := 'PROCEDURE display_file_cycle_object', EJECT ??

  PROCEDURE display_file_cycle_object
    (    pde: ^fmt$path_description_entry;
         indent: bat$display_tables_indention;
     VAR status: ost$status);

    VAR
      output_length: integer,
      output_string: string (bat$display_tables_str_length);

    status.normal := TRUE;

    STRINGREP (output_string, output_length, ' ': indent, 'cycle_number : ',
          pde^.cycle_number);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': indent,
          'next_lower_cycle : ', pde^.next_lower_cycle);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': indent,
          'next_higher_cycle : ', pde^.next_higher_cycle);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': indent,
          'first_cycle_alias_entry : ', pde^.first_cycle_alias_entry);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': indent,
          'cycle_description : ', pde^.cycle_description);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    IF pde^.cycle_description <> NIL THEN
      display_cd_entry (pde^.cycle_description, indent + 4, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
    IFEND;

  PROCEND display_file_cycle_object;

?? TITLE := 'PROCEDURE [XDCL] syp$display_global_file_info', EJECT ??

  PROCEDURE [XDCL] syp$display_global_file_info
    (    gfi: ^bat$global_file_information;
         indent: bat$display_tables_indention;
     VAR status: ost$status);

    VAR
      cycle_damage_string: string (300),
      local_indent: bat$display_tables_indention,
      output_length: integer,
      output_string: string (bat$display_tables_str_length);

    status.normal := TRUE;

    STRINGREP (output_string, output_length, ' ': indent, 'open_count : ',
          gfi^.open_count);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': indent, 'open_lock : ',
          gfi^.open_lock.lock_id);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': indent,
          'implicit_detach_inhibited : ',
          gfi^.implicit_detach_inhibited);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (cycle_damage_string, output_length, ' ': indent,
          'cycle_damage_symptoms : ');
    append_cycle_damage_symptoms (gfi^.cycle_damage_symptoms,
          cycle_damage_string, output_length);
    syp$write_output_line (cycle_damage_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;


    STRINGREP (output_string, output_length, ' ': indent,
          'device_dependent_info');
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    put_device_class (gfi^.device_dependent_info.device_class, indent + 4,
           status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': indent,
          'eoi_byte_address : ', gfi^.eoi_byte_address);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': indent, 'eoi_set : ',
          gfi^.eoi_set);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': indent, 'file_limit : ',
          gfi^.file_limit);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': indent, 'max_block_size : ',
          gfi^.max_block_size);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': indent, 'max_data_size : ',
          gfi^.max_data_size);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': indent,
          'max_record_length : ', gfi^.max_record_length);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': indent,
          'min_block_length : ', gfi^.min_block_length);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': indent,
          'opened_access_modes : read=', gfi^.opened_access_modes [fsc$read],
          ' shorten=', gfi^.opened_access_modes [fsc$shorten], ' append=',
          gfi^.opened_access_modes [fsc$append], ' modify=',
          gfi^.opened_access_modes [fsc$modify], ' execute=',
          gfi^.opened_access_modes [fsc$execute]);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': indent, 'padding_character : ',
          $INTEGER (gfi^.padding_character): #(16), '(16)');
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': indent,
          'positioning_info : ');
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    local_indent := indent + 4;
    STRINGREP (output_string, output_length, ' ': local_indent,
          'block_info ');
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    local_indent := local_indent + 4;
    STRINGREP (output_string, output_length, ' ': local_indent,
          'block_number : ', gfi^.positioning_info.block_info.block_number);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': local_indent,
          'block_position : ', gfi^.positioning_info.block_info.block_position);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': local_indent,
          'current_block_byte_address : ', gfi^.positioning_info.block_info.
          current_block_byte_address);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': local_indent,
          'current_block_length : ', gfi^.positioning_info.block_info.
          current_block_length);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': local_indent,
          'previous_block_header_fba : ', gfi^.positioning_info.block_info.
          previous_block_header_fba);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': local_indent,
          'residual_block_length : ', gfi^.positioning_info.block_info.
          residual_block_length);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    local_indent := indent + 4;
    STRINGREP (output_string, output_length, ' ': local_indent,
          'record_info ');
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    local_indent := local_indent + 4;
    STRINGREP (output_string, output_length, ' ': local_indent, 'bor_address : ',
          gfi^.positioning_info.record_info.bor_address);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': local_indent,
          'current_byte_address : ', gfi^.positioning_info.record_info.
          current_byte_address);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': local_indent, 'file_position : ',
          gfi^.positioning_info.record_info.file_position);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': local_indent,
          'record_header_fba : ', gfi^.positioning_info.record_info.
          record_header_fba);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': local_indent,
          'record_length : ', gfi^.positioning_info.record_info.record_length);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': local_indent,
          'residual_record_length : ', gfi^.positioning_info.record_info.
          residual_record_length);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': local_indent,
          'transfer_count : ', gfi^.positioning_info.record_info.
          transfer_count);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': indent,
          'prevented_open_access_modes : read=',
          gfi^.prevented_open_access_modes [fsc$read], ' shorten=',
          gfi^.prevented_open_access_modes [fsc$shorten], ' append=',
          gfi^.prevented_open_access_modes [fsc$append], ' modify=',
          gfi^.prevented_open_access_modes [fsc$modify], ' execute=',
          gfi^.prevented_open_access_modes [fsc$execute]);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': indent,
          'record_delimiting_character : ',
          $INTEGER (gfi^.record_delimiting_character):#(16), '(16)');
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

  PROCEND syp$display_global_file_info;

?? TITLE := 'PROCEDURE display_instance_attributes', EJECT ??

  PROCEDURE display_instance_attributes
    (    instance_attributes: ^bat$instance_attributes;
         indent: bat$display_tables_indention;
     VAR status: ost$status);

    VAR
      local_indent: bat$display_tables_indention,
      output_length: integer,
      output_string: string (bat$display_tables_str_length);

    status.normal := TRUE;

    STRINGREP (output_string, output_length, ' ': indent,
          'instance_attributes.static_label');
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    local_indent := indent + 4;
    STRINGREP (output_string, output_length, ' ': local_indent,
          'block_type : ', instance_attributes^.static_label.block_type);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    put_source (instance_attributes^.static_label.block_type_source,
          local_indent, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': local_indent,
          'file_organization : ', instance_attributes^.static_label.
          file_organization);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    put_source (instance_attributes^.static_label.file_organization_source,
          local_indent, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': local_indent,
          'record_type : ', instance_attributes^.static_label.record_type);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    put_source (instance_attributes^.static_label.record_type_source,
          local_indent, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': local_indent,
          'ring_attributes.r1 : ', instance_attributes^.static_label.
          ring_attributes.r1);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    STRINGREP (output_string, output_length, ' ': local_indent,
          'ring_attributes.r2 : ', instance_attributes^.static_label.
          ring_attributes.r2);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    STRINGREP (output_string, output_length, ' ': local_indent,
          'ring_attributes.r3 : ', instance_attributes^.static_label.
          ring_attributes.r3);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    put_source (instance_attributes^.static_label.ring_attributes_source,
          local_indent, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': indent,
          'instance_attributes.dynamic_label');
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': local_indent,
          'access_mode : ');
    append_usage_selections (instance_attributes^.dynamic_label.access_mode,
          output_string, output_length);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    put_source (instance_attributes^.dynamic_label.access_mode_source,
          local_indent, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': local_indent,
          'error_exit_name : ', instance_attributes^.dynamic_label.
          error_exit_name);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    put_source (instance_attributes^.dynamic_label.error_exit_name_source,
          local_indent, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': local_indent,
          'error_exit_procedure : ', instance_attributes^.dynamic_label.
          error_exit_procedure);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    put_source (instance_attributes^.dynamic_label.error_exit_procedure_source,
          local_indent, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': local_indent,
          'perform_failure_recovery : ', instance_attributes^.dynamic_label.
          error_options.perform_failure_recovery, '    error_action : ',
          instance_attributes^.dynamic_label.error_options.error_action);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    put_source (instance_attributes^.dynamic_label.error_options_source,
          local_indent, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': local_indent,
          'label_exit_name : ', instance_attributes^.dynamic_label.
          label_exit_name);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    put_source (instance_attributes^.dynamic_label.label_exit_name_source,
          local_indent, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': local_indent,
          'label_exit_procedure : ', instance_attributes^.dynamic_label.
          label_exit_procedure);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    put_source (instance_attributes^.dynamic_label.label_exit_procedure_source,
          local_indent, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    CASE instance_attributes^.dynamic_label.open_position OF
    = amc$open_at_boi =
      STRINGREP (output_string, output_length, ' ': local_indent,
            'open_position : amc$open_at_boi');
    = amc$open_no_positioning =
      STRINGREP (output_string, output_length, ' ': local_indent,
            'open_position : amc$open_no_positioning');
    = amc$open_at_eoi =
      STRINGREP (output_string, output_length, ' ': local_indent,
            'open_position : amc$open_at_eoi');
    ELSE
      STRINGREP (output_string, output_length, ' ': local_indent,
            'open_position : INVALID OPEN_POSITION');
    CASEND;
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    put_source (instance_attributes^.dynamic_label.open_position_source,
          local_indent, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': local_indent,
          'open_share_modes : ');
    append_file_access_options (instance_attributes^.dynamic_label.
          open_share_modes, output_string, output_length);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    put_source (instance_attributes^.dynamic_label.open_share_modes_source,
          local_indent, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': local_indent,
          'return_option : ', instance_attributes^.dynamic_label.
          return_option);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    put_source (instance_attributes^.dynamic_label.return_option_source,
          local_indent, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': local_indent,
          'error_limit : ', instance_attributes^.dynamic_label.error_limit);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    put_source (instance_attributes^.dynamic_label.error_limit_source,
          local_indent, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': local_indent,
          'message_control : ');
    append_message_control (instance_attributes^.dynamic_label.message_control,
          output_string, output_length);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    put_source (instance_attributes^.dynamic_label.message_control_source,
          local_indent, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

  PROCEND display_instance_attributes;

?? TITLE := 'PROCEDURE display_named_object', EJECT ??

  PROCEDURE display_named_object
    (    pde: ^fmt$path_description_entry;
         indent: bat$display_tables_indention;
     VAR status: ost$status);

    VAR
      output_length: integer,
      output_string: string (bat$display_tables_str_length);

    status.normal := TRUE;

    STRINGREP (output_string, output_length, ' ': indent,
          'active_path_participation_count : ',
          pde^.active_path_participation_count);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': indent,
          'parental_tree_entry : ', pde^.parental_tree_entry);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': indent, 'left_subtree : ',
          pde^.left_subtree);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': indent, 'right_subtree : ',
          pde^.right_subtree);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': indent, 'path_node_name : ',
          pde^.path_node_name.value);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': indent,
          'randomized_node_name : ', pde^.randomized_node_name);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': indent, 'highest_cycle : ',
          pde^.highest_cycle);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': indent,
          'next_cycle_alias_entry : ', pde^.next_cycle_alias_entry);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

  PROCEND display_named_object;

?? TITLE := 'PROCEDURE display_pde', EJECT ??

  PROCEDURE display_pde
    (    pde: ^fmt$path_description_entry;
         indent: bat$display_tables_indention;
     VAR status: ost$status);

    VAR
      output_length: integer,
      output_string: string (bat$display_tables_str_length);


    status.normal := TRUE;
    IF (pde^.unique_identifier = fmc$pde_unique_identifier) AND
          (pde^.entry_assignment^ = fmc$entry_assigned) THEN

      STRINGREP (output_string, output_length, ' ': indent,
            'unique_identifier : ', pde^.unique_identifier: #(16), '(16)');
      syp$write_output_line (output_string (1, output_length), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      STRINGREP (output_string, output_length, ' ': indent,
            'cumulative_parental_path_size : ',
            pde^.cumulative_parental_path_size);
      syp$write_output_line (output_string (1, output_length), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      STRINGREP (output_string, output_length, ' ': indent, 'path_depth : ',
            pde^.path_depth);
      syp$write_output_line (output_string (1, output_length), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      STRINGREP (output_string, output_length, ' ': indent,
            'entry_assignment_counter : ',
            pde^.entry_assignment_counter:#(16), '(16)');
      syp$write_output_line (output_string (1, output_length), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      STRINGREP (output_string, output_length, ' ': indent,
            'parental_path_entry : ', pde^.parental_path_entry);
      syp$write_output_line (output_string (1, output_length), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      STRINGREP (output_string, output_length, ' ': indent,
            'path_handle_name_externalized : ', pde^.path_handle_name_externalized);
      syp$write_output_line (output_string (1, output_length), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      CASE pde^.entry_type OF
      = fmc$named_object =
        STRINGREP (output_string, output_length, ' ': indent,
              'entry_type : fmc$named_object');
        syp$write_output_line (output_string (1, output_length), status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;

        display_named_object (pde, indent + 4, status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;

      = fmc$file_cycle_object =
        STRINGREP (output_string, output_length, ' ': indent,
              'entry_type : fmc$file_cycle_object');
        syp$write_output_line (output_string (1, output_length), status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;

        display_file_cycle_object (pde, indent + 4, status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;

      ELSE
      CASEND

    ELSE
      IF pde^.unique_identifier <> fmc$pde_unique_identifier THEN
        STRINGREP (output_string, output_length, ' ': indent,
              'Invalid pde passed to display_pde');
        syp$write_output_line (output_string (1, output_length), status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;
      ELSE
        STRINGREP (output_string, output_length, ' ': indent,
              'Entry not assigned');
        syp$write_output_line (output_string (1, output_length), status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;
      IFEND;
    IFEND;

  PROCEND display_pde;

?? TITLE := 'PROCEDURE display_system_file_label', EJECT ??

  PROCEDURE display_system_file_label
    (    sfl: ^fmt$system_file_label;
         indent: bat$display_tables_indention;
     VAR status: ost$status);

    VAR
      attribute_key: fmt$file_attribute_keys,
      header: ^fmt$static_label_header,
      local_indent: bat$display_tables_indention,
      name: pmt$program_name,
      output_length: integer,
      output_path: string (amc$max_path_name_size + 100),
      output_string: string (bat$display_tables_str_length),
      path: amt$path_name,
      path_length: 0 .. amc$max_path_name_size,
      static_label: ^SEQ ( * ),
      static_label_item: ^fmt$static_label_item,
      str: ^string ( * );

    PROCEDURE [INLINE] get_entry_point_reference
      (VAR name: pmt$program_name;
       VAR path: amt$file_reference;
       VAR path_length: 0 .. amc$max_path_name_size);

      NEXT str: [static_label_item^.entry_point_name_length] IN static_label;
      name := str^;
      path_length := static_label_item^.entry_point_path_length;
      IF static_label_item^.entry_point_path_length > 0 THEN
        NEXT str: [static_label_item^.entry_point_path_length] IN static_label;
        path := str^;
      IFEND;
    PROCEND get_entry_point_reference;

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

      NEXT str: [static_label_item^.name_length] IN static_label;
      name := str^;
    PROCEND get_name;

    status.normal := TRUE;

    STRINGREP (output_string, output_length, ' ': indent,
          'file_previously_opened : ', sfl^.file_previously_opened);
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (output_string, output_length, ' ': indent, 'static_label : ',
          sfl^.static_label);
    { pointer to seq }
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    IF sfl^.static_label <> NIL THEN
      static_label := sfl^.static_label;
      local_indent := indent + 4;

      RESET static_label;
      NEXT header IN static_label;
      STRINGREP (output_string, output_length, ' ': local_indent,
            'unique_character : ', header^.unique_character);
      syp$write_output_line (output_string (1, output_length), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      STRINGREP (output_string, output_length, ' ': local_indent,
            'revision_level : ', header^.revision_level);
      syp$write_output_line (output_string (1, output_length), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      STRINGREP (output_string, output_length, ' ': local_indent,
            'highest_attribute_present : ', header^.highest_attribute_present);
      syp$write_output_line (output_string (1, output_length), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      STRINGREP (output_string, output_length, ' ': local_indent,
            'highest_attribute_supported : ',
            header^.highest_attribute_supported);
      syp$write_output_line (output_string (1, output_length), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      STRINGREP (output_string, output_length, ' ': local_indent,
            'job_routing_label_size : ', header^.job_routing_label_size);
      syp$write_output_line (output_string (1, output_length), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      STRINGREP (output_string, output_length, ' ': local_indent,
            'default_revision_level : ', header^.default_revision_level);
      syp$write_output_line (output_string (1, output_length), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      STRINGREP (output_string, output_length, ' ': local_indent,
            'user_attribute_length : ', header^.user_attribute_length);
      syp$write_output_line (output_string (1, output_length), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      STRINGREP (output_string, output_length, ' ': local_indent,
            'file_previously_opened : ', header^.file_previously_opened);
      syp$write_output_line (output_string (1, output_length), status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      IF header^.file_previously_opened THEN
        STRINGREP (output_string, output_length, ' ': local_indent + 4,
              'ring_attributes : ', header^.ring_attributes.r1, ' ',
              header^.ring_attributes.r2, ' ', header^.ring_attributes.r3);
        syp$write_output_line (output_string (1, output_length), status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;
      IFEND;

      IF header^.highest_attribute_present > 0 THEN
        STRINGREP (output_string, output_length, ' ': local_indent,
              'static_label_attributes - nondefault values');
        syp$write_output_line (output_string (1, output_length), status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;
        local_indent := local_indent + 4;
        FOR attribute_key := LOWERBOUND (header^.attribute_present) TO header^.
              highest_attribute_present DO
          CASE attribute_key OF
          = fmc$block_type =
            IF header^.attribute_present [fmc$block_type] THEN
              NEXT static_label_item: [fmc$block_type] IN static_label;
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'block_type : ', static_label_item^.block_type);
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$character_conversion =
            IF header^.attribute_present [fmc$character_conversion] THEN
              NEXT static_label_item: [fmc$character_conversion] IN
                    static_label;
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'character_conversion : ', static_label_item^.
                    character_conversion);
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$clear_space =
            IF header^.attribute_present [fmc$clear_space] THEN
              NEXT static_label_item: [fmc$clear_space] IN static_label;
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'clear_space : ', static_label_item^.clear_space);
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$file_access_procedure =
            IF header^.attribute_present [fmc$file_access_procedure] THEN
              NEXT static_label_item: [fmc$file_access_procedure] IN
                    static_label;
              get_entry_point_reference (name, path, path_length);
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'file_access_procedure : ', name);
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$file_contents =
            IF header^.attribute_present [fmc$file_contents] THEN
              NEXT static_label_item: [fmc$file_contents] IN static_label;
              get_name (name);
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'file_contents : ', name);
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$file_limit =
            IF header^.attribute_present [fmc$file_limit] THEN
              NEXT static_label_item: [fmc$file_limit] IN static_label;
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'file_limit : ', static_label_item^.integer_value);
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$file_organization =
            IF header^.attribute_present [fmc$file_organization] THEN
              NEXT static_label_item: [fmc$file_organization] IN static_label;
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'file_organization : ', static_label_item^.
                    file_organization);
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$file_processor =
            IF header^.attribute_present [fmc$file_processor] THEN
              NEXT static_label_item: [fmc$file_processor] IN static_label;
              get_name (name);
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'file_processor : ', name);
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$file_structure =
            IF header^.attribute_present [fmc$file_structure] THEN
              NEXT static_label_item: [fmc$file_structure] IN static_label;
              get_name (name);
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'file_structure : ', name);
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$forced_write =
            IF header^.attribute_present [fmc$forced_write] THEN
              NEXT static_label_item: [fmc$forced_write] IN static_label;
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'forced_write : ', static_label_item^.forced_write);
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$internal_code =
            IF header^.attribute_present [fmc$internal_code] THEN
              NEXT static_label_item: [fmc$internal_code] IN static_label;
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'internal_code : ', static_label_item^.internal_code);
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$label_type =
            IF header^.attribute_present [fmc$label_type] THEN
              NEXT static_label_item: [fmc$label_type] IN static_label;
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'label_type : ', static_label_item^.label_type);
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$line_number =
            IF header^.attribute_present [fmc$line_number] THEN
              NEXT static_label_item: [fmc$line_number] IN static_label;
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'line_number.length : ', static_label_item^.line_number.
                    length, '  line_number.location : ',
                    static_label_item^.line_number.location);
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$max_block_length =
            IF header^.attribute_present [fmc$max_block_length] THEN
              NEXT static_label_item: [fmc$max_block_length] IN static_label;
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'max_block_length : ', static_label_item^.integer_value);
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$max_record_length =
            IF header^.attribute_present [fmc$max_record_length] THEN
              NEXT static_label_item: [fmc$max_record_length] IN static_label;
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'max_record_length : ', static_label_item^.integer_value);
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$min_block_length =
            IF header^.attribute_present [fmc$min_block_length] THEN
              NEXT static_label_item: [fmc$min_block_length] IN static_label;
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'min_block_length : ', static_label_item^.integer_value);
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$min_record_length =
            IF header^.attribute_present [fmc$min_record_length] THEN
              NEXT static_label_item: [fmc$min_record_length] IN static_label;
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'min_record_length : ', static_label_item^.integer_value);
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$padding_character =
            IF header^.attribute_present [fmc$padding_character] THEN
              NEXT static_label_item: [fmc$padding_character] IN static_label;
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'padding_character : ', $INTEGER (static_label_item^.
                    padding_character): #(16), '(16)');
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$page_format =
            IF header^.attribute_present [fmc$page_format] THEN
              NEXT static_label_item: [fmc$page_format] IN static_label;
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'page_format : ', static_label_item^.page_format);
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$page_length =
            IF header^.attribute_present [fmc$page_length] THEN
              NEXT static_label_item: [fmc$page_length] IN static_label;
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'page_length : ', static_label_item^.integer_value);
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$page_width =
            IF header^.attribute_present [fmc$page_width] THEN
              NEXT static_label_item: [fmc$page_width] IN static_label;
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'page_width : ', static_label_item^.integer_value);
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$preset_value =
            IF header^.attribute_present [fmc$preset_value] THEN
              NEXT static_label_item: [fmc$preset_value] IN static_label;
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'preset_value : ', static_label_item^.integer_value);
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$record_delimiting_character =
            IF header^.attribute_present [fmc$record_delimiting_character] THEN
              NEXT static_label_item: [fmc$record_delimiting_character] IN
                    static_label;
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'record_delimiting_character : ',
                    $INTEGER (static_label_item^.record_delimiting_character): #(16), '(16)');
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$record_type =
            IF header^.attribute_present [fmc$record_type] THEN
              NEXT static_label_item: [fmc$record_type] IN static_label;
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'record_type : ', static_label_item^.record_type);
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$ring_attributes =
            { processed above prior to FOR loop }
            ;
          = fmc$statement_identifier =
            IF header^.attribute_present [fmc$statement_identifier] THEN
              NEXT static_label_item: [fmc$statement_identifier] IN
                    static_label;
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'statement_identifier :  length = ',
                    static_label_item^.statement_identifier.length,
                    ' location = ', static_label_item^.statement_identifier.
                    location);
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$user_info =
            IF header^.attribute_present [fmc$user_info] THEN
              NEXT static_label_item: [fmc$user_info] IN static_label;
              IF static_label_item^.user_info_present THEN
                NEXT str: [32] IN static_label;
                STRINGREP (output_string, output_length, ' ': local_indent,
                      'user_info : ', str^);
                syp$write_output_line (output_string (1, output_length), status);
                IF NOT status.normal THEN
                  RETURN;
                IFEND;
                put_source (static_label_item^.source, local_indent, status);
                IF NOT status.normal THEN
                  RETURN;
                IFEND;
              IFEND;
            IFEND;
          = fmc$vertical_print_density =
            IF header^.attribute_present [fmc$vertical_print_density] THEN
              NEXT static_label_item: [fmc$vertical_print_density] IN
                    static_label;
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'vertical_print_density : ', static_label_item^.
                    integer_value);
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$average_record_length =
            IF header^.attribute_present [fmc$average_record_length] THEN
              NEXT static_label_item: [fmc$average_record_length] IN
                    static_label;
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'average_record_length : ', static_label_item^.
                    integer_value);
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$collate_table =
            IF header^.attribute_present [fmc$collate_table] THEN
              NEXT static_label_item: [fmc$collate_table] IN static_label;
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'collate_table : set but not displayed');
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$collate_table_name =
            IF header^.attribute_present [fmc$collate_table_name] THEN
              NEXT static_label_item: [fmc$collate_table_name] IN static_label;
              get_entry_point_reference (name, path, path_length);
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'collate_table_name : ', name);
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$compression_procedure_name =
            IF header^.attribute_present [fmc$compression_procedure_name] THEN
              NEXT static_label_item: [fmc$compression_procedure_name] IN
                    static_label;
              get_entry_point_reference (name, path, path_length);
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'compression_procedure_name.name : ', name);
              syp$write_output_line (output_string (1, output_length), status);
              STRINGREP (output_path, output_length, ' ': local_indent,
                    'compression_procedure_name.object_library : ',
                    path (1, path_length));
              syp$write_output_line (output_path (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$data_padding =
            IF header^.attribute_present [fmc$data_padding] THEN
              NEXT static_label_item: [fmc$data_padding] IN static_label;
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'data_padding : ', static_label_item^.data_padding);
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$dynamic_home_block_space =
            IF header^.attribute_present [fmc$dynamic_home_block_space] THEN
              NEXT static_label_item: [fmc$dynamic_home_block_space] IN
                    static_label;
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'dynamic_home_block_space : ',
                    static_label_item^.dynamic_home_block_space);
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$embedded_key =
            IF header^.attribute_present [fmc$embedded_key] THEN
              NEXT static_label_item: [fmc$embedded_key] IN static_label;
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'embedded_key : ', static_label_item^.embedded_key);
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$estimated_record_count =
            IF header^.attribute_present [fmc$estimated_record_count] THEN
              NEXT static_label_item: [fmc$estimated_record_count] IN
                    static_label;
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'estimated_record_count : ', static_label_item^.
                    integer_value);
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$hashing_procedure_name =
            IF header^.attribute_present [fmc$hashing_procedure_name] THEN
              NEXT static_label_item: [fmc$hashing_procedure_name] IN
                    static_label;
              get_entry_point_reference (name, path, path_length);
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'hashing_procedure_name.name : ', name);
              syp$write_output_line (output_string (1, output_length), status);
              STRINGREP (output_path, output_length, ' ': local_indent,
                    'hashing_procedure_name.object_library : ',
                    path (1, path_length));
              syp$write_output_line (output_path (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$index_levels =
            IF header^.attribute_present [fmc$index_levels] THEN
              NEXT static_label_item: [fmc$index_levels] IN static_label;
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'index_levels : ', static_label_item^.integer_value);
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$index_padding =
            IF header^.attribute_present [fmc$index_padding] THEN
              NEXT static_label_item: [fmc$index_padding] IN static_label;
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'index_padding : ', static_label_item^.index_padding);
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$initial_home_block_count =
            IF header^.attribute_present [fmc$initial_home_block_count] THEN
              NEXT static_label_item: [fmc$initial_home_block_count] IN
                    static_label;
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'initial_home_block_count : ',
                    static_label_item^.integer_value);
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$key_length =
            IF header^.attribute_present [fmc$key_length] THEN
              NEXT static_label_item: [fmc$key_length] IN static_label;
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'key_length : ', static_label_item^.integer_value);
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$key_position =
            IF header^.attribute_present [fmc$key_position] THEN
              NEXT static_label_item: [fmc$key_position] IN static_label;
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'key_position : ', static_label_item^.integer_value);
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$key_type =
            IF header^.attribute_present [fmc$key_type] THEN
              NEXT static_label_item: [fmc$key_type] IN static_label;
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'key_type : ', static_label_item^.key_type);
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$loading_factor =
            IF header^.attribute_present [fmc$loading_factor] THEN
              NEXT static_label_item: [fmc$loading_factor] IN static_label;
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'loading_factor : ', static_label_item^.loading_factor);
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$lock_expiration_time =
            IF header^.attribute_present [fmc$lock_expiration_time] THEN
              NEXT static_label_item: [fmc$lock_expiration_time] IN
                    static_label;
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'lock_expiration_time : ', static_label_item^.
                    integer_value);
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$logging_options =
            IF header^.attribute_present [fmc$logging_options] THEN
              NEXT static_label_item: [fmc$logging_options] IN static_label;
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'logging_options : ');
              append_logging_options (static_label_item^.logging_options,
                    output_string, output_length);
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$log_residence =
            IF header^.attribute_present [fmc$log_residence] THEN
              NEXT static_label_item: [fmc$log_residence] IN static_label;
              NEXT str: [static_label_item^.path_length] IN static_label;
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'log_residence : ', str^);
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$record_limit =
            IF header^.attribute_present [fmc$record_limit] THEN
              NEXT static_label_item: [fmc$record_limit] IN static_label;
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'record_limit : ', static_label_item^.integer_value);
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          = fmc$records_per_block =
            IF header^.attribute_present [fmc$records_per_block] THEN
              NEXT static_label_item: [fmc$records_per_block] IN static_label;
              STRINGREP (output_string, output_length, ' ': local_indent,
                    'records_per_block : ', static_label_item^.integer_value);
              syp$write_output_line (output_string (1, output_length), status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
              put_source (static_label_item^.source, local_indent, status);
              IF NOT status.normal THEN
                RETURN;
              IFEND;
            IFEND;
          ELSE
          CASEND;
        FOREND;
      ELSE
        STRINGREP (output_string, output_length, ' ': local_indent,
              'NO static_label_attributes present');
        syp$write_output_line (output_string (1, output_length), status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;
      IFEND;
    IFEND;

    STRINGREP (output_string, output_length, ' ': indent,
          'descriptive_file_attributes ');
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    display_descriptive_attr (^sfl^.descriptive_label, indent + 4, status);

  PROCEND display_system_file_label;

?? TITLE := 'PROCEDURE display_title', EJECT ??

  PROCEDURE display_title
    (    title: string ( * <= title_length);
     VAR status: ost$status);

    CONST
      asterisks_constant = '****************************************' CAT
            '****************************************';

    VAR
      asterisks: string (80),
      output_length: integer,
      output_string: string (bat$display_tables_str_length);

    status.normal := TRUE;

    asterisks := asterisks_constant;
    STRINGREP (output_string, output_length, '1', asterisks (1, title_length));
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    STRINGREP (output_string, output_length, ' ',
          asterisks (1, ((title_length DIV 2) - (STRLENGTH (title) DIV 2) - 2
          {spaces} )), '  ', title, '  ', asterisks
          (1, (((title_length + 1) DIV 2) - ((STRLENGTH (title) + 1) DIV 2) - 2
          {spaces} )));
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    STRINGREP (output_string, output_length, ' ', asterisks (1, title_length));
    syp$write_output_line (output_string (1, output_length), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    output_string := '- ';
    syp$write_output_line (output_string (1, 2), status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

  PROCEND display_title;

?? TITLE := 'PROCEDURE get_path', EJECT ??

  PROCEDURE get_path
    (    path_description_entry: ^fmt$path_description_entry;
     VAR path: fst$path;
     VAR path_length: fst$path_size;
     VAR status: ost$status);

    { PURPOSE: Given a path_description_entry, recreate a path to that node.
    {          A string containing the path is returned.

    VAR
      cycle_string: ost$string,
      pde: ^fmt$path_description_entry;

    status.normal := TRUE;
    pde := path_description_entry;
    path := osc$null_name;

    { Note: path depth is the same in last element and it's cycle objects }

    { Fill in cycle number if file cycle object. }
    IF pde^.entry_type = fmc$file_cycle_object THEN
      clp$convert_integer_to_string (pde^.cycle_number, 10, FALSE,
            cycle_string, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      path (pde^.cumulative_parental_path_size + 1, 1) := '.';
      path (pde^.cumulative_parental_path_size + 2,
            cycle_string.size) := cycle_string.value;
      path_length := pde^.cumulative_parental_path_size + cycle_string.size +
            1;
      { Move up the tree. }
      pde := pde^.parental_path_entry;
    ELSE
      path_length := pde^.cumulative_parental_path_size +
            pde^.path_node_name.size + 1;
    IFEND;

    { Fill in each path element name from last to first. }
    REPEAT
      path (pde^.cumulative_parental_path_size + 1, 1) := '.';
      path (pde^.cumulative_parental_path_size + 2,
            pde^.path_node_name.size) := pde^.path_node_name.value;
      pde := pde^.parental_path_entry;
    UNTIL pde = NIL;
    path (1, 1) := ':';

  PROCEND get_path;

?? TITLE := 'PROCEDURE put_device_class', EJECT ??

  PROCEDURE put_device_class
    (    device_class: rmt$device_class;
         indent: bat$display_tables_indention;
     VAR status: ost$status);

    VAR
      output_length: integer,
      output_string: string (bat$display_tables_str_length),
      device_class_string: ost$name;

    status.normal := TRUE;

    CASE device_class OF
    = rmc$connected_file_device =
      device_class_string := 'rmc$connect_file_device';
    = rmc$interstate_link_device =
      device_class_string := 'rmc$interstate_link_device';
    = rmc$local_queue_device =
      device_class_string := 'rmc$local_queue_device';
    = rmc$log_device =
      device_class_string := 'rmc$log_device';
    = rmc$magnetic_tape_device =
      device_class_string := 'rmc$magnetic_tape_device';
    = rmc$mass_storage_device =
      device_class_string := 'rmc$mass_storage_device';
    = rmc$memory_resident_device =
      device_class_string := 'rmc$memory_resident_device';
    = rmc$network_device =
      device_class_string := 'rmc$network_device';
    = rmc$null_device =
      device_class_string := 'rmc$null_device';
    = rmc$pipeline_device =
      device_class_string := 'rmc$pipeline_device';
    = rmc$rhfam_device =
      device_class_string := 'rmc$rhfam_device';
    = rmc$terminal_device =
      device_class_string := 'rmc$terminal_device';
    ELSE
      device_class_string := 'UNKNOWN';
    CASEND;

    STRINGREP (output_string, output_length, ' ': indent, 'device_class : ',
          device_class_string);
    syp$write_output_line (output_string (1, output_length), status);

  PROCEND put_device_class;

?? TITLE := 'PROCEDURE put_source', EJECT ??

  PROCEDURE put_source
    (    source: amt$attribute_source;
         indent: bat$display_tables_indention;
     VAR status: ost$status);

    VAR
      output_length: integer,
      output_string: string (bat$display_tables_str_length),
      source_string: ost$name;

    status.normal := TRUE;

    CASE source OF
    = amc$undefined_attribute =
      source_string := 'amc$undefined_attribute';
    = amc$local_file_information =
      source_string := 'amc$local_file_information';
    = amc$change_file_attributes =
      source_string := 'amc$change_file_attributes';
    = amc$open_request =
      source_string := 'amc$open_request';
    = amc$file_reference =
      source_string := 'amc$file_reference';
    = amc$file_command =
      source_string := 'amc$file_command';
    = amc$file_request =
      source_string := 'amc$file_request';
    = amc$add_to_file_description =
      source_string := 'amc$add_to_file_description';
    = amc$access_method_default =
      source_string := 'amc$access_method_default';
    = amc$store_request =
      source_string := 'amc$store_request';
    ELSE
      source_string := 'INVALID SOURCE';
    CASEND;

    STRINGREP (output_string, output_length, ' ': indent + 4, 'source : ',
          source_string);
    syp$write_output_line (output_string (1, output_length), status);

  PROCEND put_source;

MODEND sym$display_bam_tables;


