?? NEWTITLE := ' NOS/VE Backup/Restore Utilities:  listing_output ', EJECT ??
MODULE pum$listing_output;
?? RIGHT := 110 ??

{ This handles all output to the listing files on backup and restore.
{ This also includes the SET_LIST_OPTIONS subcommand processing.
{
?? NEWTITLE := '   Global Declarations', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc pus$literals
*copyc osd$virtual_address
*copyc amt$access_level
*copyc amt$attribute_source
*copyc amt$average_record_length
*copyc amt$block_type
*copyc amt$collate_table
*copyc amt$collation_value
*copyc amt$data_padding
*copyc amt$error_exit_procedure
*copyc amt$error_limit
*copyc amt$estimated_record_count
*copyc amt$file_access_selections
*copyc amt$file_attribute_keys
*copyc amt$file_attributes
*copyc amt$file_byte_address
*copyc amt$file_identifier
*copyc amt$file_length
*copyc amt$file_limit
*copyc amt$file_organization
*copyc amt$file_position
*copyc amt$forced_write
*copyc amt$global_file_position
*copyc amt$index_padding
*copyc amt$internal_code
*copyc amt$key_length
*copyc amt$key_position
*copyc amt$key_type
*copyc amt$label_exit_procedure
*copyc amt$label_options
*copyc amt$label_type
*copyc amt$local_file_name
*copyc amc$mau_length
*copyc amt$max_block_length
*copyc amt$max_record_length
*copyc amt$message_control
*copyc amt$min_block_length
*copyc amt$min_record_length
*copyc amt$padding_character
*copyc amt$record_limit
*copyc amt$record_type
*copyc amt$records_per_block
*copyc amt$return_option
*copyc amt$user_info
*copyc amt$vertical_print_density
*copyc ost$status
*copyc pud$hierarchy_list
*copyc pfe$external_archive_conditions
*copyc pue$error_condition_codes
*copyc amt$backup_information
*copyc amt$local_file_name
*copyc ost$status
*copyc put$file_identifier
*copyc stt$set_name
?? POP ??
*copyc amp$fetch_access_information
*copyc clp$close_display
*copyc clp$convert_integer_to_string
*copyc clp$open_display_reference
*copyc clp$put_display
*copyc clp$scan_parameter_list
*copyc fsp$append_status_file_id
*copyc osp$append_status_integer
*copyc osp$append_status_parameter
*copyc osp$format_message
*copyc osp$set_status_abnormal
*copyc pfp$find_archive_info
*copyc pfp$find_next_archive_entry
*copyc pmp$convert_binary_unique_name
*copyc pmp$format_compact_date
*copyc pmp$format_compact_time
*copyc pmp$get_compact_date_time
*copyc pmp$get_mainframe_id
*copyc pup$compare_cycle_selectors
*copyc pup$compare_paths
*copyc pup$crack_boolean
*copyc pup$crack_name_list
*copyc pup$determine_if_all_selected
*copyc pup$determine_if_none_selected
*copyc pup$fetch_current_volume
*copyc pup$find_cycle_info_record
*copyc pup$initialize_restore_totals
*copyc puv$include_archive_information
*copyc puv$include_data_options
*copyc puv$restore_archive_information
?? TITLE := '    Global Variables', EJECT ??

  VAR
    puv$display_excluded_items: [STATIC, XDCL] boolean := FALSE,
    puv$listing_display_control: [STATIC, XDCL] clt$display_control :=
          [ * , * , * , 0, * , 1, [0, 1], * , * , FALSE, * , FALSE, FALSE, [0, * ], FALSE];

  VAR
    backup_restore_names_equal: [STATIC] boolean := TRUE,
    error_count: [STATIC] integer := 0,
    last_error_status: [STATIC] ost$status := [TRUE];

  TYPE
    label_types = amc$labelled .. amc$unlabelled,
    tape_densities = rmc$200 .. rmc$38000;

  VAR
    blank_char_scan_set: [READ, pus$literals] set of char := [' '],
    catalog_list_separator: [pus$literals, READ] string (1) := '.',
    cycle_template: [pus$literals, READ] string (8) := 'CYCLE = ',
    density_name: [pus$literals, READ] array [tape_densities] of string (10) := [
          {} 'RMC$200',
          {} 'RMC$556',
          {} 'MT9$800',
          {} 'MT9$1600',
          {} 'MT9$6250',
          {} 'MT18$38000'],
    label_type_name: [pus$literals, READ] array [label_types] of string (21) := [
          {} 'LABELLED',
          {} 'NON_STANDARD_LABELLED',
          {} 'UNLABELLED'],
    path_template: [pus$literals, READ] string (1) := ':',
    pfn_template: [pus$literals, READ] string (17) := 'PERMANENT_FILE   ',
    unable_to_process_template: [pus$literals, READ] string (24) := '***UNABLE TO PROCESS***';

  CONST
    puc$minimum_list_page_width = 55,

    puc$maximum_list_page_width = 255,

    puc$header_line_separator =
          '--------------------------------------------------------------------------------' CAT
          '--------------------------------------------------------------------------------' CAT
          '--------------------------------------------------------------------------------' CAT
          '---------------',


    puc$continuation_string = '.. ',

    puc$initial_line_space = '    ';

  VAR
    no_expiration_date: [READ, pus$literals] ost$date_time := [255, 12, 31, 23, 59, 59, 999];


?? TITLE := '    List options', EJECT ??
*copyc pud$list_options

?? TITLE := '    Cycle Display Tables', EJECT ??

  VAR
    puv$cycle_display_selections: [STATIC, XDCL] put$cycle_display_selections :=
          [puc$cdo_identifier, puc$cdo_size, puc$cdo_modification_date_time, puc$cdo_action_descriptor];

  VAR
    system_minimal_cdo: [pus$literals, READ] put$cycle_display_selections :=
          [puc$cdo_identifier, puc$cdo_action_descriptor];

  VAR
    cycle_display_selection_table: [pus$literals, STATIC, READ] array [1 .. 24] of record
      name: ost$name,
      display_option: put$cycle_display_options,
    recend := [
          {} ['IDENTIFIER                     ', puc$cdo_identifier],
          {} ['SIZE                           ', puc$cdo_size],
          {} ['S                              ', puc$cdo_size],
          {} ['CREATION_DATE_TIME             ', puc$cdo_creation_date_time],
          {} ['CDT                            ', puc$cdo_creation_date_time],
          {} ['ACCESS_DATE_TIME               ', puc$cdo_access_date_time],
          {} ['ADT                            ', puc$cdo_access_date_time],
          {} ['MODIFICATION_DATE_TIME         ', puc$cdo_modification_date_time],
          {} ['MDT                            ', puc$cdo_modification_date_time],
          {} ['EXPIRATION_DATE                ', puc$cdo_expiration_date],
          {} ['ED                             ', puc$cdo_expiration_date],
          {} ['ACCESS_COUNT                   ', puc$cdo_access_count],
          {} ['AC                             ', puc$cdo_access_count],
          {} ['GLOBAL_FILE_NAME               ', puc$cdo_global_file_name],
          {} ['GFN                            ', puc$cdo_global_file_name],
          {} ['RECORDED_VSN                   ', puc$cdo_recorded_vsn],
          {} ['RVSN                           ', puc$cdo_recorded_vsn],
          {} ['ALTERNATE_FILE_MEDIA_DESCRIPTOR', puc$cdo_alternate_storage],
          {} ['AFMD                           ', puc$cdo_alternate_storage],
          {} ['ALTERNATE_FILE_MEDIA_DESCRIPTOR', puc$cdo_alternate_mod_date_time],
          {} ['AFMD                           ', puc$cdo_alternate_mod_date_time],
          {} ['ALTERNATE_FILE_MEDIA_DESCRIPTOR', puc$cdo_alternate_size],
          {} ['AFMD                           ', puc$cdo_alternate_size],
          {} ['ACTION_DESCRIPTOR              ', puc$cdo_action_descriptor]];

  VAR
    cycle_display_header_table: [pus$literals, STATIC, READ] array [put$cycle_display_options] of record
      size: 0 .. 100,
      header: string (100),
    recend := [
          {} [38, 'PF_NAME.CYCLE'],
          {} [18, '     SIZE'],
          {} [25, 'CREATION DATE/TIME'],
          {} [25, 'ACCESS DATE/TIME'],
          {} [25, 'MODIFICATION DATE/TIME'],
          {} [25, 'EXPIRATION DATE'],
          {} [16, 'ACCESS COUNT'],
          {} [40, 'GLOBAL_FILE_NAME'],
          {} [17, 'RECORDED_VSN(S)'],
          {} [35, 'ALTERNATE STORAGE'],
          {} [36, 'ALTERNATE MODIFICATION DATE/TIME'],
          {} [18, 'ALTERNATE SIZE'],
          {} [16, 'EXCLUSION']];


?? TITLE := '    File Display Tables', EJECT ??

  VAR
    file_display_selection_table: [pus$literals, STATIC, READ] array [1 .. 6] of record
      name: ost$name,
      display_option: put$file_display_options,
    recend := [
          {} ['IDENTIFIER                     ', puc$fdo_identifier],
          {} ['ACCOUNT                        ', puc$fdo_account],
          {} ['A                              ', puc$fdo_account],
          {} ['PROJECT                        ', puc$fdo_project],
          {} ['P                              ', puc$fdo_project],
          {} ['ACTION_DESCRIPTOR              ', puc$fdo_action_descriptor]];

  VAR
    file_display_header_table: [pus$literals, STATIC, READ] array [put$file_display_options] of record
      size: 0 .. 50,
      header: string (50),
    recend := [
          {} [33, 'PF_NAME'],
          {} [33, 'ACCOUNT'],
          {} [33, 'PROJECT'],
          {} [16, 'ACTION DESCRIPTOR']];

  VAR
    file_display_selections: put$file_display_selections := [puc$fdo_identifier, puc$fdo_action_descriptor],

    system_minimal_fdo: [pus$literals, STATIC, READ] put$file_display_selections :=
          [puc$fdo_identifier, puc$fdo_action_descriptor];

?? TITLE := '    [XDCL] pup$close_display_file ', EJECT ??

  PROCEDURE [XDCL] pup$close_display_file
    (VAR status: ost$status);

    clp$close_display (puv$listing_display_control, status);

  PROCEND pup$close_display_file;
?? TITLE := '    [XDCL] pup$convert_gfn_to_string ', EJECT ??

  PROCEDURE [XDCL] pup$convert_gfn_to_string
    (    binary_name: ost$binary_unique_name;
     VAR result_string: string (60));

    VAR
      unique_name: ost$name,
      ignore_status: ost$status;

    pmp$convert_binary_unique_name (binary_name, unique_name, ignore_status);
    result_string := unique_name;

  PROCEND pup$convert_gfn_to_string;
?? TITLE := '    [XDCL] pup$display_blank_lines ', EJECT ??

  PROCEDURE [XDCL] pup$display_blank_lines
    (    number_of_lines: integer;
     VAR status: ost$status);

    VAR
      i: integer,
      output_string: string (2);

    output_string := ' ';
    status.normal := TRUE;
    FOR i := 1 TO number_of_lines DO
      clp$put_display (puv$listing_display_control, output_string, clc$no_trim, status);
    FOREND;

  PROCEND pup$display_blank_lines;
?? TITLE := '    [XDCL] pup$display_boolean ', EJECT ??

  PROCEDURE [XDCL] pup$display_boolean
    (    descriptor: string ( * <= 255);
         value: boolean;
     VAR status: ost$status);

    VAR
      total_length: integer,
      working_string: string (200);

    STRINGREP (working_string, total_length, descriptor, ' ', value);
    pup$display_line (working_string (1, total_length), status);

  PROCEND pup$display_boolean;
?? TITLE := '    [XDCL] pup$display_excluded_item ', EJECT ??

  PROCEDURE [XDCL] pup$display_excluded_item
    (    entry: put$entry;
         catalog_header: put$catalog_header;
     VAR status: ost$status);

    IF puv$display_excluded_items THEN
      pup$display_item_descriptor ('--- EXCLUDING ----------', catalog_header, entry, status);
      pup$display_line ('------------------------', status);
    IFEND;
  PROCEND pup$display_excluded_item;

?? TITLE := '    [XDCL] pup$display_integer ', EJECT ??

  PROCEDURE [XDCL] pup$display_integer
    (    descriptor: string ( * <= 256);
         number: integer;
     VAR status: ost$status);

    VAR
      total_length: integer,
      working_string: string (200);

    STRINGREP (working_string, total_length, descriptor, ' ', number);
    pup$display_line (working_string (1, total_length), status);

  PROCEND pup$display_integer;
?? TITLE := '    [XDCL] pup$display_item_descriptor ', EJECT ??

  PROCEDURE [XDCL] pup$display_item_descriptor
    (    descriptor_header: string ( * );
         catalog_header: put$catalog_header;
         entry: put$entry;
     VAR status: ost$status);

    IF descriptor_header <> '' THEN
      pup$display_line (descriptor_header, status);
    IFEND;
    pup$write_catalog_header (catalog_header, status);
    CASE entry.entry_type OF
    = puc$valid_pf_entry =
      pup$display_line (' PERMANENT FILE', status);
    = puc$valid_cycle_entry =
      pup$write_cycle_entry (entry, status);
    ELSE
    CASEND;

  PROCEND pup$display_item_descriptor;
?? TITLE := '    [XDCL] pup$display_line ', EJECT ??

  PROCEDURE [XDCL] pup$display_line
    (    output_string: string ( * <= 256);
     VAR status: ost$status);

    clp$put_display (puv$listing_display_control, output_string, clc$trim, status);

  PROCEND pup$display_line;
?? TITLE := '    [XDCL] pup$display_list_options ', EJECT ??

  PROCEDURE [XDCL] pup$display_list_options
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

?? RIGHT := 110 ??
{ pdt display_list_options_pdt (status)

?? PUSH (LISTEXT := ON) ??

    VAR
      display_list_options_pdt: [STATIC, READ, cls$pdt] clt$parameter_descriptor_table :=
            [^display_list_options_pdt_names, ^display_list_options_pdt_params];

    VAR
      display_list_options_pdt_names: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 1] of
            clt$parameter_name_descriptor := [['STATUS', 1]];

    VAR
      display_list_options_pdt_params: [STATIC, READ, cls$pdt_parameters] array [1 .. 1] of
            clt$parameter_descriptor := [

{ STATUS }
      [[clc$optional], 1, 1, 1, 1, clc$value_range_not_allowed,
            [NIL, clc$variable_reference, clc$array_not_allowed, clc$status_value]]];

?? POP ??

    VAR
      cycle_display_option: put$cycle_display_options,
      file_display_option: put$file_display_options,
      j: integer;

    clp$scan_parameter_list (parameter_list, display_list_options_pdt, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF puv$display_excluded_items THEN
      pup$display_line (' Displaying excluded items.', status);
    ELSE
      pup$display_line (' NOT displaying excluded items', status);
    IFEND;

    pup$display_line (' file_display_selections: ', status);
    FOR file_display_option := LOWERVALUE (put$file_display_options)
          TO UPPERVALUE (put$file_display_options) DO
      IF file_display_option IN file_display_selections THEN

      /find_fdo_option_name/
        FOR j := 1 TO UPPERBOUND (file_display_selection_table) DO
          IF file_display_option = file_display_selection_table [j].display_option THEN
            pup$display_line (file_display_selection_table [j].name, status);
            EXIT /find_fdo_option_name/; {----->
          IFEND;
        FOREND /find_fdo_option_name/;
      IFEND;
    FOREND;


    pup$display_line (' cycle_display_selections: ', status);
    FOR cycle_display_option := LOWERVALUE (put$cycle_display_options)
          TO UPPERVALUE (put$cycle_display_options) DO
      IF cycle_display_option IN puv$cycle_display_selections THEN

      /find_cdo_option_name/
        FOR j := 1 TO UPPERBOUND (cycle_display_selection_table) DO
          IF cycle_display_option = cycle_display_selection_table [j].display_option THEN
            pup$display_line (cycle_display_selection_table [j].name, status);
            EXIT /find_cdo_option_name/; {----->
          IFEND;
        FOREND /find_cdo_option_name/;
      IFEND;
    FOREND;
  PROCEND pup$display_list_options;
?? TITLE := '    [XDCL] pup$format_date_time ', EJECT ??

  PROCEDURE [XDCL] pup$format_date_time
    (    date_time: ost$date_time;
     VAR date_time_string: string ( * ));

    VAR
      date: ost$date,
      status: ost$status,
      time: ost$time;

    date_time_string := '    ';
    pmp$format_compact_date (date_time, osc$mdy_date, date, status);
    date_time_string := date.mdy;
{ should use osc$hms_time osc$millisecond only for TESTING
    pmp$format_compact_time (date_time, osc$millisecond_time, time, status);
    date_time_string (10, * ) := time.millisecond;

  PROCEND pup$format_date_time;
?? TITLE := '    [XDCL] pup$get_summary_status ', EJECT ??

  PROCEDURE [XDCL] pup$get_summary_status
    (VAR status {input, output} : ost$status);

    VAR
      line_count: ost$status_message_line_count,
      p_line_count: ^ost$status_message_line_count,
      p_line_size: ^ost$status_message_line_size,
      p_message: ^ost$status_message,
      p_message_line: ^string ( * ),
      request_status: ost$status,
      singular_string: string (1);

    IF status.normal AND (error_count > 0) THEN
      osp$set_status_abnormal (puc$pf_utility_id, pue$error_summary_status, '', status);
      osp$append_status_integer (osc$status_parameter_delimiter, error_count, 10, FALSE, status);
      singular_string := ' ';
      IF error_count > 1 THEN
        singular_string := 's';
      IFEND;
      osp$append_status_parameter (osc$status_parameter_delimiter, singular_string, status);
      fsp$append_status_file_id (osc$status_parameter_delimiter, puv$listing_display_control.file_id, status);
      IF (error_count = 1) AND (NOT last_error_status.normal) THEN
        osp$append_status_parameter (osc$status_parameter_delimiter, ' Single abnormal status: ', status);
        PUSH p_message;
        osp$format_message (last_error_status, osc$brief_message_level, osc$max_string_size, p_message^,
              request_status);
        IF NOT request_status.normal THEN
          RETURN; {----->
        IFEND;
        RESET p_message;
        NEXT p_line_count IN p_message;
        IF p_line_count^ > 0 THEN
          FOR line_count := 1 TO (p_line_count^) DO
            NEXT p_line_size IN p_message;
            NEXT p_message_line: [p_line_size^] IN p_message;
            osp$append_status_parameter (osc$status_parameter_delimiter, p_message_line^, status);
          FOREND;
        IFEND;
      IFEND;
    IFEND;

  PROCEND pup$get_summary_status;
?? TITLE := '    [XDCL] pup$initialize_backup_listing ', EJECT ??

{  PURPOSE:
{    This procedure initializes a listing on a backup_permanent_file
{    subcommand.  Displayed are the item being backed up, and the time of the
{    backup.

  PROCEDURE [XDCL] pup$initialize_backup_listing
    (    pf_utility_hierarchy_list: put$hierarchy_list;
         backup_file_id: put$file_identifier;
         backup_information: amt$backup_information;
     VAR status: ost$status);

    VAR
      file: clt$file,
      local_status: ost$status,
      outputline: string (osc$max_string_size),
      outputline_index: integer,
      mainframe_id: pmt$mainframe_id,
      volume_description: rmt$volume_descriptor,
      volume_number: amt$volume_number;

    error_count := 0;
    last_error_status.normal := TRUE;
    display_archive_options (status);
    pup$display_blank_lines (2, status);
    outputline := 'LISTING PRODUCED BY BACKUP OF:';
    clp$put_display (puv$listing_display_control, outputline, clc$trim, status);
    IF status.normal THEN
      pup$write_catalog_header (pf_utility_hierarchy_list.catalog_header, status);
      IF status.normal THEN
        CASE pf_utility_hierarchy_list.pf_entry.entry_type OF
        = puc$valid_cycle_entry =
          pup$write_cycle_entry (pf_utility_hierarchy_list.pf_entry, status);
        = puc$valid_pf_entry =
          write_pf_entry (pf_utility_hierarchy_list.pf_entry, status);
        ELSE
        CASEND;
        pmp$get_mainframe_id (mainframe_id, status);
        pup$format_date_time (pf_utility_hierarchy_list.date_time, outputline);
        outputline (40, * ) := mainframe_id;
        clp$put_display (puv$listing_display_control, outputline, clc$trim, status);
        CASE backup_file_id.device_class OF
        = rmc$magnetic_tape_device =
          { Display enough information here so that a user would know how to request the tape
          { to restore it.
          pup$fetch_current_volume (backup_file_id, volume_number, volume_description, status);
          IF status.normal THEN
            STRINGREP (outputline, outputline_index, 'TAPE NUMBER:', volume_number, '     EXTERNAL VSN: ',
                  volume_description.external_vsn, '     DENSITY: ',
                  density_name [backup_information.density], '     ',
                  label_type_name [backup_file_id.label_type]);
            pup$display_line (outputline (1, outputline_index), status);
            IF status.normal AND (backup_file_id.label_type <> amc$unlabelled) THEN
              STRINGREP (outputline, outputline_index, '                   RECORDED VSN: ',
                    volume_description.recorded_vsn);
              pup$display_line (outputline (1, outputline_index), status);
            IFEND;
          ELSE
            pup$write_os_status (status, local_status);
          IFEND;
        = rmc$mass_storage_device =
          clp$put_display (puv$listing_display_control, backup_information.file_path, clc$trim, status);
        ELSE
          pup$display_line ('TO $NULL ', status);
        CASEND;
        pup$write_cycle_display_header (status);
      IFEND;
    IFEND;

  PROCEND pup$initialize_backup_listing;
?? TITLE := '    [XDCL] pup$initialize_restore_listing ', EJECT ??

  PROCEDURE [XDCL] pup$initialize_restore_listing
    (    descriptor: string ( * );
         old_catalog_header: put$catalog_header;
         old_entry: put$entry;
         new_catalog_path: pft$path;
         new_cycle_selector: pft$cycle_selector;
     VAR status: ost$status);

    VAR
      date_time: ost$date_time,
      date_time_string: string (80),
      old_above_new: boolean;

    error_count := 0;
    last_error_status.normal := TRUE;
    pup$initialize_restore_totals;
    pup$display_boolean (' RESTORE_ARCHIVE_INFORMATION =', puv$restore_archive_information, status);
    pup$display_blank_lines (2, status);
    pup$display_line (' LISTING PRODUCED BY', status);
    pup$display_line (descriptor, status);
    IF old_entry.entry_type = puc$valid_set_entry THEN
      backup_restore_names_equal := TRUE;
    ELSE
      pup$write_sub_path (old_catalog_header.path, LOWERBOUND (old_catalog_header.path),
            UPPERBOUND (old_catalog_header.path), status);
      CASE old_entry.entry_type OF
      = puc$valid_cycle_entry =
        pup$write_cycle_selector (old_entry.pf_selector.cycle_selector, status);
      ELSE
      CASEND;

{ determine if the backup name equals the restore name
      pup$compare_paths (old_catalog_header.path, new_catalog_path, backup_restore_names_equal,
            old_above_new);
      IF backup_restore_names_equal THEN
        IF old_entry.entry_type = puc$valid_cycle_entry THEN
          pup$compare_cycle_selectors (old_entry.pf_selector.cycle_selector, new_cycle_selector,
                backup_restore_names_equal);
        IFEND;
      IFEND;
      IF NOT backup_restore_names_equal THEN
        pup$display_line ('  NEW NAME:', status);
        pup$write_sub_path (new_catalog_path, LOWERBOUND (new_catalog_path), UPPERBOUND (new_catalog_path),
              status);
        IF old_entry.entry_type = puc$valid_cycle_entry THEN
          pup$write_cycle_selector (new_cycle_selector, status);
        IFEND;
      IFEND;
    IFEND;
    pmp$get_compact_date_time (date_time, status);
    pup$format_date_time (date_time, date_time_string);
    pup$display_line (date_time_string, status);

    pup$write_cycle_display_header (status);
  PROCEND pup$initialize_restore_listing;

?? TITLE := '    [XDCL] pup$initialize_summary_status ', EJECT ??

  PROCEDURE [XDCL] pup$initialize_summary_status;

    error_count := 0;
    last_error_status.normal := TRUE;

  PROCEND pup$initialize_summary_status;
?? TITLE := '    [XDCL] pup$open_display_file ', EJECT ??

  PROCEDURE [XDCL] pup$open_display_file
    (    list_file: fst$file_reference;
     VAR status: ost$status);

    VAR
      default_ring_attributes: amt$ring_attributes;

    default_ring_attributes.r1 := #RING (^default_ring_attributes);
    default_ring_attributes.r2 := #RING (^default_ring_attributes);
    default_ring_attributes.r3 := #RING (^default_ring_attributes);

    clp$open_display_reference (list_file, NIL, fsc$list, default_ring_attributes,
          puv$listing_display_control, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF (puv$listing_display_control.page_width < puc$minimum_list_page_width) THEN
      puv$listing_display_control.page_width := puc$minimum_list_page_width;
    ELSEIF (puv$listing_display_control.page_width > puc$maximum_list_page_width) THEN
      puv$listing_display_control.page_width := puc$maximum_list_page_width;
    IFEND;

  PROCEND pup$open_display_file;
?? TITLE := '    [XDCL] pup$set_list_options ', EJECT ??

  PROCEDURE [XDCL] pup$set_list_options
    (    file_selections: put$file_display_selections;
         cycle_selections: put$cycle_display_selections;
         excluded_items_selection: boolean;
     VAR status: ost$status);

    status.normal := TRUE;
    file_display_selections := file_selections + system_minimal_fdo;
    puv$cycle_display_selections := cycle_selections + system_minimal_cdo;
    puv$display_excluded_items := excluded_items_selection;

  PROCEND pup$set_list_options;

?? TITLE := '    [XDCL] pup$set_list_options_command ', EJECT ??

  PROCEDURE [XDCL] pup$set_list_options_command
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

    VAR
      cycle_options: put$cycle_display_selections,
      excluded_items_selection: boolean,
      file_options: put$file_display_selections;

    crack_set_list_options (parameter_list, file_options, cycle_options, excluded_items_selection, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    pup$set_list_options (file_options, cycle_options, excluded_items_selection, status);

  PROCEND pup$set_list_options_command;
?? TITLE := '    [XDCL] pup$write_catalog_header ', EJECT ??

  PROCEDURE [XDCL] pup$write_catalog_header
    (    pf_utility_catalog_header: put$catalog_header;
     VAR status: ost$status);

    VAR
      length: integer,
      outputline: string (osc$max_string_size);

    status.normal := TRUE;
{       STRINGREP (outputline, length, set_template, catalog_header.set_name);
{    pup$display_line (outputline (1, length), status);
    IF pf_utility_catalog_header.logical_path_length > 0 THEN
      pup$write_path (pf_utility_catalog_header.path, status);
    IFEND;
  PROCEND pup$write_catalog_header;
?? TITLE := '    [XDCL] pup$write_cycle_display ', EJECT ??

  PROCEDURE [XDCL] pup$write_cycle_display
    (    pf_entry: put$entry;
         cycle_array_entry: pft$cycle_array_entry_version_2;
         file_length: amt$file_length;
         global_file_name: ost$binary_unique_name;
         p_recorded_vsns: ^array [1 .. * ] of rmt$recorded_vsn;
         p_cycle_array_extended_record: pft$p_info_record;
         p_cycle_directory_array: pft$p_cycle_directory_array;
     VAR status: ost$status);

    write_cycle_display (pf_entry, cycle_array_entry, file_length, global_file_name, p_recorded_vsns,
          p_cycle_array_extended_record, p_cycle_directory_array, puc$item_backed_up, status);

  PROCEND pup$write_cycle_display;
?? TITLE := '    [XDCL] pup$write_cycle_display_header ', EJECT ??

  PROCEDURE [XDCL] pup$write_cycle_display_header
    (VAR status: ost$status);

    VAR
      current_position: integer,
      i: put$cycle_display_options,
      outputline: string (osc$max_string_size);

    status.normal := TRUE;
    pup$display_blank_lines (2, status);
    pup$display_line ('CATALOG', status);
    pup$write_file_display_header (status);
    STRINGREP (outputline, current_position, puc$initial_line_space);
    FOR i := LOWERVALUE (put$cycle_display_options) TO PRED (puc$cdo_action_descriptor) DO
      IF i IN puv$cycle_display_selections THEN
        IF (current_position + cycle_display_header_table [i].size) >
              puv$listing_display_control.page_width THEN
          { Start a new line
          pup$display_line (outputline (1, current_position), status);
          STRINGREP (outputline, current_position, puc$initial_line_space, puc$continuation_string);
        IFEND;
        STRINGREP (outputline, current_position, outputline (1, current_position),
              cycle_display_header_table [i].header (1, cycle_display_header_table [i].size));
      IFEND;
    FOREND;
    pup$display_line (outputline (1, current_position), status);

    outputline := puc$header_line_separator;
    pup$display_line (outputline (1, puv$listing_display_control.page_width), status);
  PROCEND pup$write_cycle_display_header;

?? TITLE := '    pup$write_cycle_entry ', EJECT ??

  PROCEDURE pup$write_cycle_entry
    (    pf_entry: put$entry;
     VAR status: ost$status);

    VAR
      index: integer,
      outputline: string (osc$max_string_size);

    status.normal := TRUE;
    outputline := ' ';
    outputline (1, STRLENGTH (pfn_template)) := pfn_template;
{    outputline (STRLENGTH (pfn_template) + 1, * ) := pf_entry.pf_selector.pfn;
    clp$put_display (puv$listing_display_control, outputline, clc$trim, status);
    IF status.normal THEN
      pup$write_cycle_selector (pf_entry.pf_selector.cycle_selector, status);
    IFEND;
  PROCEND pup$write_cycle_entry;

?? TITLE := '    [XDCL] pup$write_cycle_selector ', EJECT ??

  PROCEDURE [XDCL] pup$write_cycle_selector
    (    cycle_selector: pft$cycle_selector;
     VAR status: ost$status);

    VAR
      index: integer,
      outputline: string (osc$max_string_size);

    status.normal := TRUE;
    outputline := ' ';
    outputline (1, STRLENGTH (cycle_template)) := cycle_template;
    CASE cycle_selector.cycle_option OF
    = pfc$highest_cycle =
      outputline (STRLENGTH (cycle_template) + 1, * ) := '$HIGH';
    = pfc$lowest_cycle =
      outputline (STRLENGTH (cycle_template) + 1, * ) := '$LOW';
    = pfc$specific_cycle =
      outputline (STRLENGTH (cycle_template) + 1, * ) := '    ';
      STRINGREP (outputline (STRLENGTH (cycle_template) + 1, * ), index, cycle_selector.cycle_number);
    ELSE
      ;
    CASEND;
    clp$put_display (puv$listing_display_control, outputline, clc$trim, status);
  PROCEND pup$write_cycle_selector;

?? TITLE := '    [XDCL] pup$write_deleted_cycle ', EJECT ??

  PROCEDURE [XDCL] pup$write_deleted_cycle
    (    pf_entry: put$entry;
         cycle_array_entry: pft$cycle_array_entry_version_2;
         file_length: amt$file_length;
         global_file_name: ost$binary_unique_name;
         p_recorded_vsns: ^array [1 .. * ] of rmt$recorded_vsn;
         p_cycle_array_extended_record: pft$p_info_record;
         p_cycle_directory_array: pft$p_cycle_directory_array;
     VAR status: ost$status);

    write_cycle_display (pf_entry, cycle_array_entry, file_length, global_file_name, p_recorded_vsns,
          p_cycle_array_extended_record, p_cycle_directory_array, '     DELETED  ', status);

  PROCEND pup$write_deleted_cycle;

?? TITLE := '    [XDCL] pup$write_excluded_cycle ', EJECT ??

  PROCEDURE [XDCL] pup$write_excluded_cycle
    (    pf_entry: put$entry;
         cycle_array_entry: pft$cycle_array_entry_version_2;
         file_length: amt$file_length;
         global_file_name: ost$binary_unique_name;
         p_recorded_vsns: ^array [1 .. * ] of rmt$recorded_vsn;
         p_cycle_array_extended_record: pft$p_info_record;
         p_cycle_directory_array: pft$p_cycle_directory_array;
         exclusion_descriptor: put$action_descriptor;
     VAR status: ost$status);

    IF puv$display_excluded_items THEN
      write_cycle_display (pf_entry, cycle_array_entry, file_length, global_file_name, p_recorded_vsns,
            p_cycle_array_extended_record, p_cycle_directory_array, exclusion_descriptor, status);
    IFEND;

  PROCEND pup$write_excluded_cycle;

?? TITLE := '    [XDCL] pup$write_file_display ', EJECT ??

  PROCEDURE [XDCL] pup$write_file_display
    (    pf_entry: put$entry;
         account: avt$account_name;
         project: avt$project_name;
     VAR status: ost$status);

    VAR
      current_position: integer,
      i: put$file_display_options,
      outputline: string (osc$max_string_size);

    outputline := ' ';
    status.normal := TRUE;
    STRINGREP (outputline, current_position, puc$initial_line_space);
    FOR i := LOWERVALUE (put$file_display_options) TO UPPERVALUE (put$file_display_options) DO
      IF i IN file_display_selections THEN
        IF (current_position + file_display_header_table [i].size) >
              puv$listing_display_control.page_width THEN
          { start a new line }
          pup$display_line (outputline (1, current_position), status);
          outputline := ' ';
          STRINGREP (outputline, current_position, puc$initial_line_space, puc$continuation_string);
        IFEND;
        CASE i OF
        = puc$fdo_identifier =
          STRINGREP (outputline, current_position, outputline (1, current_position),
                pf_entry.pf_selector.pfn);
        = puc$fdo_project =
          STRINGREP (outputline, current_position, outputline (1, current_position), project);
        = puc$fdo_account =
          STRINGREP (outputline, current_position, outputline (1, current_position), account);
        = puc$fdo_action_descriptor =
          {?????/?????????????
        ELSE
        CASEND;
      IFEND;
    FOREND;
    pup$display_line (outputline (1, current_position), status);
  PROCEND pup$write_file_display;

?? TITLE := '    pup$write_file_display_header ', EJECT ??

  PROCEDURE pup$write_file_display_header
    (VAR status: ost$status);

    VAR
      current_position: integer,
      i: put$file_display_options,
      outputline: string (osc$max_string_size);

    status.normal := TRUE;
    STRINGREP (outputline, current_position, puc$initial_line_space);
    FOR i := LOWERVALUE (put$file_display_options) TO puc$fdo_project DO
      IF i IN file_display_selections THEN
        IF (current_position + file_display_header_table [i].size) >
              puv$listing_display_control.page_width THEN
          { Start a new line
          pup$display_line (outputline (1, current_position), status);
          STRINGREP (outputline, current_position, puc$initial_line_space, puc$continuation_string);
        IFEND;
        STRINGREP (outputline, current_position, outputline (1, current_position),
              file_display_header_table [i].header (1, file_display_header_table [i].size));
      IFEND;
    FOREND;
    pup$display_line (outputline (1, current_position), status);
  PROCEND pup$write_file_display_header;

?? TITLE := '    [XDCL] pup$write_os_status ', EJECT ??

  PROCEDURE [XDCL] pup$write_os_status
    (    status: ost$status;
     VAR request_status: ost$status);

{  This routine writes a status variable to the output file.  If the status
{  is normal nothing is output, but if the status is NOT normal, the
{  status message is formatted and output.

    VAR
      line_count: ost$status_message_line_count,
      outputline: string (osc$max_string_size),
      p_line_count: ^ost$status_message_line_count,
      p_line_size: ^ost$status_message_line_size,
      p_message: ^ost$status_message,
      p_message_line: ^string ( * );

    request_status.normal := TRUE;
    IF status.normal THEN
      RETURN; {----->
    IFEND;
    last_error_status := status;
    error_count := error_count + 1;
    PUSH p_message;
    osp$format_message (status, osc$full_message_level, puv$listing_display_control.page_width, p_message^,
          request_status);
    IF NOT request_status.normal THEN
      RETURN; {----->
    IFEND;
    RESET p_message;
    NEXT p_line_count IN p_message;
    IF p_line_count^ > 0 THEN
      FOR line_count := 1 TO (p_line_count^) DO
        NEXT p_line_size IN p_message;
        NEXT p_message_line: [p_line_size^] IN p_message;
        outputline := '   ';
        outputline (1, p_line_size^) := p_message_line^;
        clp$put_display (puv$listing_display_control, outputline, clc$trim, request_status);
        IF NOT request_status.normal THEN
          RETURN; {----->
        IFEND;
      FOREND;
    IFEND;
    pup$display_blank_lines (1, request_status);
  PROCEND pup$write_os_status;

?? TITLE := '    [XDCL] pup$write_path ', EJECT ??

  PROCEDURE [XDCL] pup$write_path
    (    path: pft$path;
     VAR status: ost$status);

    pup$write_sub_path (path, LOWERBOUND (path), UPPERBOUND (path), status);
  PROCEND pup$write_path;

?? TITLE := '    [XDCL] pup$write_status_to_listing ', EJECT ??

  PROCEDURE [XDCL] pup$write_status_to_listing
    (    pf_utility_entry: put$entry;
         bad_status: ost$status;
     VAR status: ost$status);

    VAR
      k: integer,
      name_length: put$half_integer,
      outputline: string (osc$max_string_size),
      outputline_index: put$half_integer;

    status.normal := TRUE;
    IF bad_status.normal THEN
      RETURN; {----->
    IFEND;
    outputline := '     ';
    outputline_index := 1;
    CASE pf_utility_entry.entry_type OF
    = puc$valid_cycle_entry =
      outputline_index := 6;
      calculate_name_length (pf_utility_entry.pf_selector.pfn, name_length);
      outputline (outputline_index, name_length) := pf_utility_entry.pf_selector.pfn;
      CASE pf_utility_entry.pf_selector.cycle_selector.cycle_option OF
      = pfc$lowest_cycle =
        outputline ((outputline_index + name_length), 5) := '.$LOW';
      = pfc$highest_cycle =
        outputline ((outputline_index + name_length), 6) := '.$HIGH';
      = pfc$specific_cycle =
        STRINGREP (outputline (outputline_index + name_length, 4), k,
              pf_utility_entry.pf_selector.cycle_selector.cycle_number);
        outputline (outputline_index + name_length) := '.';
      CASEND;
    = puc$valid_pf_entry =
      outputline_index := 6;
      calculate_name_length (pf_utility_entry.pfn, name_length);
      outputline (outputline_index, name_length) := pf_utility_entry.pfn;
    = puc$valid_catalog_entry =
      calculate_name_length (pf_utility_entry.catalog_name, name_length);
      outputline (outputline_index, name_length) := pf_utility_entry.catalog_name;
    = puc$valid_family_entry =
      calculate_name_length (pf_utility_entry.family_name, name_length);
      outputline (outputline_index, name_length) := pf_utility_entry.family_name;
    = puc$valid_set_entry =
      calculate_name_length (pf_utility_entry.set_name, name_length);
      outputline (outputline_index, name_length) := pf_utility_entry.set_name;
    = puc$invalid_entry =
      name_length := 0;
    ELSE
    CASEND;
    outputline_index := outputline_index + name_length + 6;
    outputline (outputline_index, STRLENGTH (unable_to_process_template)) := unable_to_process_template;
    clp$put_display (puv$listing_display_control, outputline, clc$trim, status);
    pup$write_os_status (bad_status, status);
  PROCEND pup$write_status_to_listing;

?? TITLE := '    [XDCL] pup$write_sub_path ', EJECT ??

  PROCEDURE [XDCL] pup$write_sub_path
    (    path: pft$path;
         lower: integer;
         upper: integer;
     VAR status: ost$status);

{  PURPOSE:
{    This procedure writes a pf path to the list file designated by
{    puv$listing_display_control.

    VAR
      index: put$half_integer,
      name_length: put$half_integer,
      new_outputline_index: put$half_integer,
      outputline: string (osc$max_string_size),
      outputline_index: put$half_integer;

    status.normal := TRUE;
    outputline_index := 1;
    outputline (outputline_index, * ) := '     ';
    outputline (outputline_index, STRLENGTH (path_template)) := path_template;
    outputline_index := outputline_index + STRLENGTH (path_template);

  /display_loop/
    FOR index := lower TO upper DO
      calculate_name_length (path [index], name_length);
      new_outputline_index := outputline_index + name_length + STRLENGTH (catalog_list_separator);
      IF new_outputline_index > puv$listing_display_control.page_width THEN
        clp$put_display (puv$listing_display_control, outputline, clc$trim, status);
        IF NOT status.normal THEN
          EXIT /display_loop/; {----->
        IFEND;
        outputline_index := 4;
        outputline := puc$continuation_string;
        new_outputline_index := outputline_index + name_length + STRLENGTH (catalog_list_separator);
      IFEND;
      outputline (outputline_index, name_length) := path [index];
      IF index < upper THEN
        {This assures there isnt a trailing separator }
        outputline (outputline_index + name_length, STRLENGTH (catalog_list_separator)) :=
              catalog_list_separator;
      IFEND;
      outputline_index := new_outputline_index;
    FOREND /display_loop/;
    IF outputline_index > 1 THEN
      clp$put_display (puv$listing_display_control, outputline, clc$trim, status);
    IFEND;
  PROCEND pup$write_sub_path;
?? TITLE := '    [INLINE] calculate_name_length ', EJECT ??

  PROCEDURE [INLINE] calculate_name_length
    (    name: ost$name;
     VAR name_length: put$half_integer);

    VAR
      found: boolean;

    #SCAN (blank_char_scan_set, name, name_length, found);
    IF found THEN
      name_length := name_length - 1;
    ELSE
      name_length := STRLENGTH (name);
    IFEND;
  PROCEND calculate_name_length;

?? TITLE := '    convert_name_to_cdo ', EJECT ??

  PROCEDURE convert_name_to_cdo
    (    name: ost$name;
     VAR cycle_display_option: put$cycle_display_options;
     VAR status: ost$status);

    VAR
      i: integer;

    status.normal := TRUE;
    FOR i := 1 TO UPPERBOUND (cycle_display_selection_table) DO
      IF cycle_display_selection_table [i].name = name THEN
        cycle_display_option := cycle_display_selection_table [i].display_option;
        RETURN; {----->
      IFEND;
    FOREND;
    osp$set_status_abnormal (puc$pf_utility_id, cle$name_not_a_keyword_value, name, status);
  PROCEND convert_name_to_cdo;

?? TITLE := '    convert_name_to_fdo ', EJECT ??

  PROCEDURE convert_name_to_fdo
    (    name: ost$name;
     VAR file_display_option: put$file_display_options;
     VAR status: ost$status);

    VAR
      i: integer;

    status.normal := TRUE;
    FOR i := 1 TO UPPERBOUND (file_display_selection_table) DO
      IF file_display_selection_table [i].name = name THEN
        file_display_option := file_display_selection_table [i].display_option;
        RETURN; {----->
      IFEND;
    FOREND;
    osp$set_status_abnormal (puc$pf_utility_id, cle$name_not_a_keyword_value, name, status);
  PROCEND convert_name_to_fdo;


?? TITLE := '    crack_cycle_display_selection ', EJECT ??

  PROCEDURE crack_cycle_display_selection
    (    parameter_name: string ( * );
     VAR cycle_display_selection: put$cycle_display_selections;
     VAR status: ost$status);

    VAR
      all_selected: boolean,
      cycle_display_option: put$cycle_display_options,
      i: 1 .. 20,
      name_list_container: SEQ (REP 20 of ost$name),
      none_selected: boolean,
      p_name_list: ^array [1 .. * ] of ost$name;

    pup$crack_name_list (parameter_name, name_list_container, p_name_list, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    pup$determine_if_all_selected (p_name_list^, parameter_name, all_selected, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;
    pup$determine_if_none_selected (p_name_list^, parameter_name, none_selected, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF all_selected THEN
      cycle_display_selection := -$put$cycle_display_selections [];
    ELSEIF none_selected THEN
      cycle_display_selection := $put$cycle_display_selections [];
    ELSE
      cycle_display_selection := $put$cycle_display_selections [];
      FOR i := 1 TO UPPERBOUND (p_name_list^) DO
        convert_name_to_cdo (p_name_list^ [i], cycle_display_option, status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
        cycle_display_selection := cycle_display_selection +
              $put$cycle_display_selections [cycle_display_option];
      FOREND;
    IFEND;

  PROCEND crack_cycle_display_selection;

?? TITLE := '    crack_file_display_selection ', EJECT ??

  PROCEDURE crack_file_display_selection
    (    parameter_name: string ( * );
     VAR file_display_selection: put$file_display_selections;
     VAR status: ost$status);

    VAR
      all_selected: boolean,
      file_display_option: put$file_display_options,
      i: 1 .. 20,
      name_list_container: SEQ (REP 20 of ost$name),
      none_selected: boolean,
      p_name_list: ^array [1 .. * ] of ost$name;

    pup$crack_name_list (parameter_name, name_list_container, p_name_list, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    pup$determine_if_all_selected (p_name_list^, parameter_name, all_selected, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;
    pup$determine_if_none_selected (p_name_list^, parameter_name, none_selected, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF all_selected THEN
      file_display_selection := -$put$file_display_selections [];
    ELSEIF none_selected THEN
      file_display_selection := $put$file_display_selections [];
    ELSE
      file_display_selection := $put$file_display_selections [];
      FOR i := 1 TO UPPERBOUND (p_name_list^) DO
        convert_name_to_fdo (p_name_list^ [i], file_display_option, status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
        file_display_selection := file_display_selection + $put$file_display_selections [file_display_option];
      FOREND;
    IFEND;

  PROCEND crack_file_display_selection;
?? TITLE := '    crack_set_list_options ', EJECT ??

  PROCEDURE crack_set_list_options
    (    parameter_list: clt$parameter_list;
     VAR file_display_selections: put$file_display_selections;
     VAR cycle_display_selections: put$cycle_display_selections;
     VAR excluded_items_selection: boolean;
     VAR status: ost$status);

{  PDT setlo_pdt (
{  file_display_options,file_display_option,fdo: list of key account, a, project, p, all, none = none
{  cycle_display_options,cycle_display_option,cdo: list of key creation_date_time,cdt, ..
{  access_date_time,adt,modification_date_time,mdt,expiration_date,ed,..
{   access_count,ac,size,s,recorded_vsn,rvsn,global_file_name,gfn,alternate_file_media_descriptor,afmd,..
{   all,none = (size,modification_date_time)
{  display_excluded_items, display_excluded_item, dei: boolean = false
{  status)

?? PUSH (LISTEXT := ON) ??

    VAR
      setlo_pdt: [STATIC, READ, cls$pdt] clt$parameter_descriptor_table :=
            [^setlo_pdt_names, ^setlo_pdt_params];

    VAR
      setlo_pdt_names: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 10] of
            clt$parameter_name_descriptor := [['FILE_DISPLAY_OPTIONS', 1], ['FILE_DISPLAY_OPTION', 1],
            ['FDO', 1], ['CYCLE_DISPLAY_OPTIONS', 2], ['CYCLE_DISPLAY_OPTION', 2], ['CDO', 2],
            ['DISPLAY_EXCLUDED_ITEMS', 3], ['DISPLAY_EXCLUDED_ITEM', 3], ['DEI', 3], ['STATUS', 4]];

    VAR
      setlo_pdt_params: [STATIC, READ, cls$pdt_parameters] array [1 .. 4] of clt$parameter_descriptor := [

{ FILE_DISPLAY_OPTIONS FILE_DISPLAY_OPTION FDO }
      [[clc$optional_with_default, ^setlo_pdt_dv1], 1, clc$max_value_sets, 1, 1,
            clc$value_range_not_allowed, [^setlo_pdt_kv1, clc$keyword_value]],

{ CYCLE_DISPLAY_OPTIONS CYCLE_DISPLAY_OPTION CDO }
      [[clc$optional_with_default, ^setlo_pdt_dv2], 1, clc$max_value_sets, 1, 1,
            clc$value_range_not_allowed, [^setlo_pdt_kv2, clc$keyword_value]],

{ DISPLAY_EXCLUDED_ITEMS DISPLAY_EXCLUDED_ITEM DEI }
      [[clc$optional_with_default, ^setlo_pdt_dv3], 1, 1, 1, 1, clc$value_range_not_allowed,
            [NIL, clc$boolean_value]],

{ STATUS }
      [[clc$optional], 1, 1, 1, 1, clc$value_range_not_allowed,
            [NIL, clc$variable_reference, clc$array_not_allowed, clc$status_value]]];

    VAR
      setlo_pdt_kv1: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 6] of ost$name := ['ACCOUNT', 'A',
            'PROJECT', 'P', 'ALL', 'NONE'];

    VAR
      setlo_pdt_kv2: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 20] of
            ost$name := ['CREATION_DATE_TIME', 'CDT', 'ACCESS_DATE_TIME', 'ADT', 'MODIFICATION_DATE_TIME',
            'MDT', 'EXPIRATION_DATE', 'ED', 'ACCESS_COUNT', 'AC', 'SIZE', 'S', 'RECORDED_VSN', 'RVSN',
            'GLOBAL_FILE_NAME', 'GFN', 'ALTERNATE_FILE_MEDIA_DESCRIPTOR', 'AFMD', 'ALL', 'NONE'];

    VAR
      setlo_pdt_dv1: [STATIC, READ, cls$pdt_names_and_defaults] string (4) := 'none';

    VAR
      setlo_pdt_dv2: [STATIC, READ, cls$pdt_names_and_defaults] string (29) :=
            '(size,modification_date_time)';

    VAR
      setlo_pdt_dv3: [STATIC, READ, cls$pdt_names_and_defaults] string (5) := 'false';

?? POP ??

    clp$scan_parameter_list (parameter_list, setlo_pdt, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    crack_file_display_selection ('FILE_DISPLAY_OPTIONS', file_display_selections, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    crack_cycle_display_selection ('CYCLE_DISPLAY_OPTIONS', cycle_display_selections, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    pup$crack_boolean ('DISPLAY_EXCLUDED_ITEMS', excluded_items_selection, status);

  PROCEND crack_set_list_options;
?? TITLE := '    display_archive_options ', EJECT ??

  PROCEDURE display_archive_options
    (VAR status: ost$status);

    pup$display_boolean (' INCLUDE_ARCHIVE_INFORMATION =', puv$include_archive_information, status);
    IF status.normal THEN
      IF puc$include_offline_data IN puv$include_data_options THEN
        pup$display_line (' INCLUDING OFFLINE DATA', status);
      IFEND;
      IF status.normal THEN
        IF (puc$include_releasable_data IN puv$include_data_options) THEN
          pup$display_line (' INCLUDING RELEASABLE DATA', status);
        IFEND;
        IF status.normal THEN
          IF (puc$include_unreleasable_data IN puv$include_data_options) THEN
            pup$display_line (' INCLUDING UNRELEASABLE DATA', status);
          IFEND;
        IFEND;
      IFEND;
    IFEND;

  PROCEND display_archive_options;
?? TITLE := '    {inline} edit_integer ', EJECT ??

  PROCEDURE {inline} edit_integer
    (    int: integer;
     VAR str {input, output} : ost$string);

    VAR
      i: ost$string_size,
      ignore_status: ost$status,
      j: ost$string_size,
      temp_str: ost$string;

    clp$convert_integer_to_string (int, 10, FALSE, temp_str, ignore_status);
    IF str.size < (temp_str.size + ((temp_str.size - 1) DIV 3)) THEN
      str.size := temp_str.size + ((temp_str.size - 1) DIV 3);
    IFEND;
    j := str.size;
    FOR i := temp_str.size DOWNTO 1 DO
      str.value (j) := temp_str.value (i);
      j := j - 1;
      IF (i > 1) AND (((temp_str.size - i) MOD 3) = 2) THEN
        str.value (j) := ',';
        j := j - 1;
      IFEND;
    FOREND;
    str.value (1, j) := '';

  PROCEND edit_integer;

?? TITLE := '    write_cycle_display ', EJECT ??

  PROCEDURE write_cycle_display
    (    pf_entry: put$entry;
         cycle_array_entry: pft$cycle_array_entry_version_2;
         file_length: amt$file_length;
         global_file_name: ost$binary_unique_name;
         p_recorded_vsns: ^array [1 .. * ] of rmt$recorded_vsn;
         p_cycle_array_extended_record: pft$p_info_record;
         p_cycle_directory_array: pft$p_cycle_directory_array;
         action_descriptor: put$action_descriptor;
     VAR status: ost$status);


    VAR
      alternate_storage_string: string (76),
      alternate_storage_string_size: integer,
      archive_identification: pft$archive_identification,
      current_position: integer,
      date_time_string: string (25),
      file_length_string: string (25),
      gfn_string: string (60),
      i: put$cycle_display_options,
      ignore_status: ost$status,
      k: integer,
      name_length: put$half_integer,
      outputline: string (osc$max_string_size),
      p_archive_entry: pft$p_archive_array_entry,
      p_archive_group: pft$p_info_record,
      p_archive_list: pft$p_info_record,
      p_archive_list_body: pft$p_info,
      p_archive_media: pft$p_amd,
      p_cycle_info_record: pft$p_info_record,
      p_path: pft$p_path,
      starting_position: integer,
      volume: amt$volume_number;

    status.normal := TRUE;
    outputline := ' ';
    date_time_string := ' ';
    STRINGREP (outputline, current_position, puc$initial_line_space);
    current_position := current_position + 1;

  /process_cycle_display_options/
    FOR i := LOWERVALUE (put$cycle_display_options) TO UPPERVALUE (put$cycle_display_options) DO
      IF i IN puv$cycle_display_selections THEN
        IF (i <> puc$cdo_action_descriptor) OR ((i = puc$cdo_action_descriptor) AND
              (action_descriptor <> puc$item_backed_up)) THEN
          IF (current_position + cycle_display_header_table [i].size) >
                puv$listing_display_control.page_width THEN

{ Start a new line

            pup$display_line (outputline (1, current_position), ignore_status);
            outputline := ' ';
            STRINGREP (outputline, current_position, puc$initial_line_space, puc$continuation_string);
            current_position := current_position + 1;
          IFEND;
          CASE i OF
          = puc$cdo_identifier =
            calculate_name_length (pf_entry.pf_selector.pfn, name_length);
            outputline (current_position, name_length) := pf_entry.pf_selector.pfn;
            CASE pf_entry.pf_selector.cycle_selector.cycle_option OF
            = pfc$lowest_cycle =
              outputline ((current_position + name_length), 5) := '.$LOW';
            = pfc$highest_cycle =
              outputline ((current_position + name_length), 6) := '.$HIGH';
            = pfc$specific_cycle =
              STRINGREP (outputline (current_position + name_length, 4), k,
                    pf_entry.pf_selector.cycle_selector.cycle_number);
              outputline (current_position + name_length) := '.';
            CASEND;
          = puc$cdo_size =
            IF cycle_array_entry.device_class = rmc$mass_storage_device THEN
              IF file_length = puc$unknown_cycle_size THEN
                outputline (current_position + 2, 7) := 'UNKNOWN';
              ELSEIF file_length = puc$released_cycle_size THEN
                outputline (current_position + 2, 8) := 'RELEASED';
              ELSE
                STRINGREP (file_length_string, k, file_length);
                outputline ((current_position + 9 - k), k) := file_length_string (1, k);
              IFEND;
            ELSEIF cycle_array_entry.device_class = rmc$magnetic_tape_device THEN
              outputline (current_position + 2, 13) := 'MAGNETIC_TAPE';
            IFEND;
          = puc$cdo_creation_date_time =
            pup$format_date_time (cycle_array_entry.cycle_statistics.creation_date_time, date_time_string);
            outputline (current_position, cycle_display_header_table [i].size) := date_time_string;
          = puc$cdo_access_date_time =
            pup$format_date_time (cycle_array_entry.cycle_statistics.access_date_time, date_time_string);
            outputline (current_position, cycle_display_header_table [i].size) := date_time_string;
          = puc$cdo_modification_date_time =
            pup$format_date_time (cycle_array_entry.cycle_statistics.modification_date_time,
                  date_time_string);
            outputline (current_position, cycle_display_header_table [i].size) := date_time_string;
          = puc$cdo_expiration_date =
            IF cycle_array_entry.expiration_date_time = no_expiration_date THEN
              outputline (current_position, 4) := 'NONE';
            ELSE
              pup$format_date_time (cycle_array_entry.expiration_date_time, date_time_string);
              outputline (current_position, cycle_display_header_table [i].size) := date_time_string;
            IFEND;
          = puc$cdo_access_count =
            STRINGREP (outputline (current_position, * ), k, cycle_array_entry.cycle_statistics.access_count);
          = puc$cdo_global_file_name =
            IF global_file_name = puv$unknown_global_file_name THEN
              outputline (current_position, 7) := 'UNKNOWN';
            ELSE
              pup$convert_gfn_to_string (global_file_name, gfn_string);
              outputline (current_position, 40) := gfn_string;
            IFEND;
          = puc$cdo_recorded_vsn =
            IF p_recorded_vsns = NIL THEN
              outputline (current_position + 1, 7) := 'UNKNOWN';
            ELSEIF p_recorded_vsns^ [1] = puc$nonexistent_recorded_vsn THEN
              outputline (current_position + 1, 8) := 'RELEASED';
            ELSEIF UPPERBOUND (p_recorded_vsns^) = 1 THEN
              outputline (current_position + 1, 6) := p_recorded_vsns^ [1];
            ELSE { Volume list
              starting_position := current_position;
              outputline (current_position) := '(';
              current_position := current_position + 1;
              FOR volume := 1 TO UPPERBOUND (p_recorded_vsns^) DO
                IF (current_position + 7) >= puv$listing_display_control.page_width THEN

{ Start a new line

                  pup$display_line (outputline (1, current_position), ignore_status);
                  outputline := ' ';
                  STRINGREP (outputline, current_position, puc$initial_line_space, puc$continuation_string,
                        ' ');
                IFEND;
                outputline (current_position, 6) := p_recorded_vsns^ [volume];
                current_position := current_position + 7;
              FOREND;
              outputline (current_position - 1) := ')';
              IF current_position > (starting_position + cycle_display_header_table [i].size) THEN

{ Force this line out to allow the action_descriptor to be aligned

                pup$display_line (outputline (1, current_position), ignore_status);
                outputline := ' ';
                STRINGREP (outputline, current_position, puc$initial_line_space, puc$continuation_string,
                      ' ');
              IFEND;
              CYCLE /process_cycle_display_options/; {----->
            IFEND;
          = puc$cdo_alternate_storage =
            PUSH p_path: [1 .. 1];
            p_path^ [1] := pf_entry.pf_selector.pfn;
            pup$find_cycle_info_record (p_cycle_array_extended_record, p_cycle_directory_array,
                  cycle_array_entry.cycle_number, p_path, p_cycle_info_record, status);
            IF status.normal THEN
              pfp$find_archive_info (p_cycle_info_record, p_archive_list, status);
              IF (NOT status.normal) AND (status.condition = pfe$unknown_archive_info) THEN
                outputline (current_position, 4) := 'NONE';
              ELSEIF status.normal THEN
                archive_identification.application_identifier := osc$null_name;
                archive_identification.media_identifier.media_device_class := osc$null_name;
                archive_identification.media_identifier.media_volume_identifier := '';
                p_archive_list_body := ^p_archive_list^.body;
                REPEAT
                  pfp$find_next_archive_entry (archive_identification, p_archive_list_body, p_archive_group,
                        p_archive_entry, p_archive_media, status);
                  IF status.normal THEN
                    calculate_name_length (p_archive_entry^.archive_identification.application_identifier,
                          name_length);
                    pup$format_date_time (p_archive_entry^.modification_date_time, date_time_string);
                    STRINGREP (alternate_storage_string, alternate_storage_string_size,
                          p_archive_entry^.archive_identification.application_identifier);
                    IF (current_position + alternate_storage_string_size) >=
                          puv$listing_display_control.page_width THEN
                      pup$display_line (outputline (1, current_position), ignore_status);
                      outputline := ' ';
                      STRINGREP (outputline, current_position, puc$initial_line_space,
                            puc$continuation_string, ' ');
                    IFEND;
                    outputline (current_position, alternate_storage_string_size) := alternate_storage_string;
                    current_position := current_position + alternate_storage_string_size + 1;
                    STRINGREP (alternate_storage_string, alternate_storage_string_size, ' ',
                          date_time_string);
                    IF (current_position + alternate_storage_string_size) >=
                          puv$listing_display_control.page_width THEN
                      pup$display_line (outputline (1, current_position), ignore_status);
                      outputline := ' ';
                      STRINGREP (outputline, current_position, puc$initial_line_space,
                            puc$continuation_string, ' ');
                    IFEND;
                    outputline (current_position, alternate_storage_string_size) := alternate_storage_string;
                    current_position := current_position + alternate_storage_string_size + 1;
                    STRINGREP (alternate_storage_string, alternate_storage_string_size, ' ',
                          p_archive_entry^.file_size: 14);
                    IF (current_position + alternate_storage_string_size) >=
                          puv$listing_display_control.page_width THEN
                      pup$display_line (outputline (1, current_position), ignore_status);
                      outputline := ' ';
                      STRINGREP (outputline, current_position, puc$initial_line_space,
                            puc$continuation_string, ' ');
                    IFEND;
                    outputline (current_position, alternate_storage_string_size) := alternate_storage_string;
                    current_position := current_position + alternate_storage_string_size + 1;
                    IF (p_archive_list_body <> NIL) AND ((current_position + 7) >=
                          puv$listing_display_control.page_width) THEN

{ Start a new line

                      pup$display_line (outputline (1, current_position), ignore_status);
                      outputline := ' ';
                      STRINGREP (outputline, current_position, puc$initial_line_space,
                            puc$continuation_string, ' ');
                    IFEND;
                  IFEND;
                UNTIL (p_archive_list_body = NIL) OR NOT status.normal;
                CYCLE /process_cycle_display_options/; {----->
              IFEND;
            IFEND;
          = puc$cdo_action_descriptor =
            outputline (current_position, 14) := action_descriptor;
          ELSE
          CASEND;
          current_position := current_position + cycle_display_header_table [i].size;
        IFEND;
      IFEND;
    FOREND /process_cycle_display_options/;

    IF current_position > 8 THEN

{ Display the remaining line if it has more than continuation marks on it.

      pup$display_line (outputline (1, current_position), ignore_status);
    IFEND;

  PROCEND write_cycle_display;
?? TITLE := '    write_pf_entry ', EJECT ??

  PROCEDURE write_pf_entry
    (    pf_entry: put$entry;
     VAR status: ost$status);

    VAR
      outputline: string (osc$max_string_size);

    status.normal := TRUE;
    outputline := ' ';
    outputline (1, STRLENGTH (pfn_template)) := pfn_template;
{    outputline (STRLENGTH (pfn_template) + 1, * ) := pf_entry.pfn;
    clp$put_display (puv$listing_display_control, outputline, clc$trim, status);

  PROCEND write_pf_entry;
MODEND pum$listing_output;
