?? RIGHT := 110 ??
?? NEWTITLE := ' NOS/VE Backup/Restore Utilities:  backup_permanent_file ', EJECT ??
MODULE pum$backup_permanent_file;
?? RIGHT := 110 ??
{
{  This module contains the command table and entry and exit points for
{  the BACKUP_PERMANENT_FILES utility.  The processing for the
{  SET_BACKUP_OPTIONS subcommand is also within this module.
{
?? NEWTITLE := '   Global Declarations', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc pus$literals
*copyc osd$integer_limits
*copyc pud$backup_file
*copyc pue$error_condition_codes
*copyc amt$backup_information
*copyc ost$status
*copyc ost$string
*copyc put$exclude_site_backup_options
*copyc put$file_identifier
*copyc put$include_data_options
*copyc pft$usage_selections
?? POP ??
*copyc fip#addl_initialize
*copyc fip#addl_integer
*copyc fip#addl_string

*copyc amp$close
*copyc avp$family_administrator
*copyc avp$system_administrator
*copyc clp$begin_utility
*copyc clp$convert_integer_to_string
*copyc clp$end_include
*copyc clp$end_utility
*copyc clp$evaluate_parameters
*copyc clp$include_file
*copyc osp$set_status_abnormal
*copyc pup$all_volumes_included
*copyc pup$close_backup_file
*copyc pup$close_display_file
*copyc pup$crack_file
*copyc pup$crack_file_reference
*copyc pup$display_blank_lines
*copyc pup$display_boolean
*copyc pup$display_line
*copyc pup$open_backup_file
*copyc pup$open_display_file
*copyc puv$listing_display_control
*copyc puv$trace_selected
?? TITLE := '    Global Variables', EJECT ??

  VAR
    { Backup file information }
    puv$backup_information: [XDCL, STATIC] amt$backup_information,
    puv$backup_file_id: [XDCL, STATIC] put$file_identifier,
    puv$bacpf_cycle_data_total: [XDCL, STATIC] ost$non_negative_integers,
    puv$bacpf_backup_file_version: [XDCL, STATIC] put$backup_file_version_name := puc$backup_file_version_2,
    puv$null_original_unique_name: [XDCL, STATIC] ost$binary_unique_name := [0, 0, 1980, 1, 1, 0, 0, 0, 0, 0],
    puv$null_res_cycle_array_ent_sp: [XDCL, STATIC] array [1 .. 46] of boolean := [REP 46 of FALSE],
    puv$null_reserved_cycle_info_sp: [XDCL, STATIC] array [1 .. 55] of boolean := [REP 55 of FALSE];

  VAR
    { Backup options }
    puv$backup_share_modes: [XDCL, STATIC] pft$usage_selections := $pft$usage_selections
          [pfc$read, pfc$execute],
    puv$exclude_catalog_information: [XDCL, STATIC] boolean := FALSE,
    puv$exclude_site_backup_options: [XDCL] put$exclude_site_backup_options :=
          $put$exclude_site_backup_options [],
    puv$include_archive_information: [XDCL] boolean,
    puv$include_data_options: [XDCL] put$include_data_options :=
          $put$include_data_options [puc$include_releasable_data, puc$include_unreleasable_data],
    puv$include_exceptions: [XDCL, STATIC] boolean := TRUE,
    puv$read_data_on_null_bf: [XDCL, STATIC] boolean := FALSE;


  CONST
    puc$backup_utility_name = 'BACKUP_PERMANENT_FILES         ';

?? TITLE := '    Utility Commands', EJECT ??

{ table backup_command_list type=command section_name=pus$literals, scope=local
{ command (backup_all_files, bacaf) p=pup$backup_all_files_command cm=xref
{ command (backup_catalog bacc) p=pup$backup_catalog_command cm=xref
{ command (backup_file bacf) p=pup$backup_file_command cm=xref log=manual
{ command (backup_set bacs) p=pup$backup_set_command cm=xref log=manual
{ command (close_volume) p=pup$close_volume cm=xref a=au
{ command (delete_all_files) p=pup$delete_all_files_cm cm=xref
{ command (delete_catalog_contents delete_catalog_content, delcc) p=pup$delete_catalog_contents_cm cm=xref
{ command (delete_file_contents delete_file_content, delfc) p=pup$delete_file_command cm=xref log=manual
{ command (display_active_volumes, disav) p=pup$display_volumes_command cm=xref a=au
{ command display_advise p=pup$display_advise_cmd cm=xref a=au
{ command (display_all_users) p=pup$display_all_users_command cm=xref a=au
{ command (display_backup_directives) p=pup$display_directives cm=xref a=au
{ command (display_backup_options display_backup_option disbo) p=pup$display_backup_options_cm cm=local
{ command (display_exclude_highest_cycles, display_exclude_highest_cycle, disehc) ..
{   p=pup$display_exc_highest_cycles cm=xref a=au
{ command (display_excluded_items, display_excluded_item, disei) p=pup$display_excluded_items cm=xref a=au
{ command (display_include_empty_catalogs, display_include_empty_catalog, disiec) ..
{   p=pup$display_delete_empty_cat_cm cm=xref a=au
{ command (display_included_cycles, display_included_cycle, disic) p=pup$dis_included_cycles_cm cm=xref a=au
{ command (display_included_volumes, display_included_volume, disiv) p=pup$display_included_volumes ..
{   cm=xref a=au
{ command (display_list_options, display_list_option, dislo) p=pup$display_list_options cm=xref a=au
{ command (exclude_catalog excc) p=pup$exclude_catalog_command cm=xref
{ command (exclude_file excf) p=pup$exclude_pf_command cm=xref
{ command (exclude_highest_cycles, exclude_highest_cycle, exchc) p=pup$exclude_highest_cycles_cm cm=xref
{ command (include_all_files) p=pup$include_all_files cm=xref a=au
{ command (include_catalog, incc) p=pup$include_catalog_command cm=xref a=au
{ command (include_cycles include_cycle, inc) p=pup$backup_include_cycles cm=xref
{ command (include_empty_catalogs, include_empty_catalog, incec) p=pup$include_empty_catalog_cm cm=xref
{ command (include_excluded_items) p=pup$include_excluded_items cm=xref a=au
{ command (include_large_cycles include_large_cycle, inclc) p=pup$include_large_cycles_cmd cm=xref
{ command (include_master_catalogs include_master_catalog incmc) p=pup$include_master_catalog_cmd cm=xref
{ command (include_permanent_file) p=pup$include_pf_command cm=xref a=au
{ command (include_small_cycles, include_small_cycle, incsc) p=pup$include_small_cycles_cmd, cm=xref
{ command (include_users include_user, incu) p=pup$include_users_command cm=xref
{ command (include_volumes include_volume, incv) p=pup$backup_include_volumes_cmd cm=xref
{ command (log_keyed_file_backup logkfb) p=pup$log_keyed_file_backup cm=xref a=hidden
{ command (push_restore) p=pup$push_restore_permanent_file cm=xref a=au
{ command (putrace) p=pup$trace cm=xref a=au
{ command (quit qui) p=pup$quit cm=local
{ command (select_advise_in) p=pup$select_advise_in_cmd cm=xref a=au
{ command (select_data_file) p=pup$select_data_file cm=xref a=au
{ command (set_backup_options, set_backup_option, setbo) p=set_backup_options_subcommand cm=local
{ command (set_list_options, set_list_option, setlo) p=pup$set_list_options_command cm=xref
{ command (sort_users soru) p=pup$sort_users_command cm=xref
{ tablend

?? PUSH (LISTEXT := ON) ??

  VAR
    backup_command_list: [STATIC, READ, pus$literals] ^clt$command_table := ^backup_command_list_entries,

    backup_command_list_entries: [STATIC, READ, pus$literals] array [1 .. 91] of clt$command_table_entry := [
          {} ['BACAF                          ', clc$abbreviation_entry, clc$normal_usage_entry, 1,
          clc$automatically_log, clc$linked_call, ^pup$backup_all_files_command],
          {} ['BACC                           ', clc$abbreviation_entry, clc$normal_usage_entry, 2,
          clc$automatically_log, clc$linked_call, ^pup$backup_catalog_command],
          {} ['BACF                           ', clc$abbreviation_entry, clc$normal_usage_entry, 3,
          clc$manually_log, clc$linked_call, ^pup$backup_file_command],
          {} ['BACKUP_ALL_FILES               ', clc$nominal_entry, clc$normal_usage_entry, 1,
          clc$automatically_log, clc$linked_call, ^pup$backup_all_files_command],
          {} ['BACKUP_CATALOG                 ', clc$nominal_entry, clc$normal_usage_entry, 2,
          clc$automatically_log, clc$linked_call, ^pup$backup_catalog_command],
          {} ['BACKUP_FILE                    ', clc$nominal_entry, clc$normal_usage_entry, 3,
          clc$manually_log, clc$linked_call, ^pup$backup_file_command],
          {} ['BACKUP_SET                     ', clc$nominal_entry, clc$normal_usage_entry, 4,
          clc$manually_log, clc$linked_call, ^pup$backup_set_command],
          {} ['BACS                           ', clc$abbreviation_entry, clc$normal_usage_entry, 4,
          clc$manually_log, clc$linked_call, ^pup$backup_set_command],
          {} ['CLOSE_VOLUME                   ', clc$nominal_entry, clc$advanced_usage_entry, 5,
          clc$automatically_log, clc$linked_call, ^pup$close_volume],
          {} ['DELCC                          ', clc$abbreviation_entry, clc$normal_usage_entry, 7,
          clc$automatically_log, clc$linked_call, ^pup$delete_catalog_contents_cm],
          {} ['DELETE_ALL_FILES               ', clc$nominal_entry, clc$normal_usage_entry, 6,
          clc$automatically_log, clc$linked_call, ^pup$delete_all_files_cm],
          {} ['DELETE_CATALOG_CONTENT         ', clc$alias_entry, clc$normal_usage_entry, 7,
          clc$automatically_log, clc$linked_call, ^pup$delete_catalog_contents_cm],
          {} ['DELETE_CATALOG_CONTENTS        ', clc$nominal_entry, clc$normal_usage_entry, 7,
          clc$automatically_log, clc$linked_call, ^pup$delete_catalog_contents_cm],
          {} ['DELETE_FILE_CONTENT            ', clc$alias_entry, clc$normal_usage_entry, 8, clc$manually_log,
          clc$linked_call, ^pup$delete_file_command],
          {} ['DELETE_FILE_CONTENTS           ', clc$nominal_entry, clc$normal_usage_entry, 8,
          clc$manually_log, clc$linked_call, ^pup$delete_file_command],
          {} ['DELFC                          ', clc$abbreviation_entry, clc$normal_usage_entry, 8,
          clc$manually_log, clc$linked_call, ^pup$delete_file_command],
          {} ['DISAV                          ', clc$abbreviation_entry, clc$advanced_usage_entry, 9,
          clc$automatically_log, clc$linked_call, ^pup$display_volumes_command],
          {} ['DISBO                          ', clc$abbreviation_entry, clc$normal_usage_entry, 13,
          clc$automatically_log, clc$linked_call, ^pup$display_backup_options_cm],
          {} ['DISEHC                         ', clc$abbreviation_entry, clc$advanced_usage_entry, 14,
          clc$automatically_log, clc$linked_call, ^pup$display_exc_highest_cycles],
          {} ['DISEI                          ', clc$abbreviation_entry, clc$advanced_usage_entry, 15,
          clc$automatically_log, clc$linked_call, ^pup$display_excluded_items],
          {} ['DISIC                          ', clc$abbreviation_entry, clc$advanced_usage_entry, 17,
          clc$automatically_log, clc$linked_call, ^pup$dis_included_cycles_cm],
          {} ['DISIEC                         ', clc$abbreviation_entry, clc$advanced_usage_entry, 16,
          clc$automatically_log, clc$linked_call, ^pup$display_delete_empty_cat_cm],
          {} ['DISIV                          ', clc$abbreviation_entry, clc$advanced_usage_entry, 18,
          clc$automatically_log, clc$linked_call, ^pup$display_included_volumes],
          {} ['DISLO                          ', clc$abbreviation_entry, clc$advanced_usage_entry, 19,
          clc$automatically_log, clc$linked_call, ^pup$display_list_options],
          {} ['DISPLAY_ACTIVE_VOLUMES         ', clc$nominal_entry, clc$advanced_usage_entry, 9,
          clc$automatically_log, clc$linked_call, ^pup$display_volumes_command],
          {} ['DISPLAY_ADVISE                 ', clc$nominal_entry, clc$advanced_usage_entry, 10,
          clc$automatically_log, clc$linked_call, ^pup$display_advise_cmd],
          {} ['DISPLAY_ALL_USERS              ', clc$nominal_entry, clc$advanced_usage_entry, 11,
          clc$automatically_log, clc$linked_call, ^pup$display_all_users_command],
          {} ['DISPLAY_BACKUP_DIRECTIVES      ', clc$nominal_entry, clc$advanced_usage_entry, 12,
          clc$automatically_log, clc$linked_call, ^pup$display_directives],
          {} ['DISPLAY_BACKUP_OPTION          ', clc$alias_entry, clc$normal_usage_entry, 13,
          clc$automatically_log, clc$linked_call, ^pup$display_backup_options_cm],
          {} ['DISPLAY_BACKUP_OPTIONS         ', clc$nominal_entry, clc$normal_usage_entry, 13,
          clc$automatically_log, clc$linked_call, ^pup$display_backup_options_cm],
          {} ['DISPLAY_EXCLUDED_ITEM          ', clc$alias_entry, clc$advanced_usage_entry, 15,
          clc$automatically_log, clc$linked_call, ^pup$display_excluded_items],
          {} ['DISPLAY_EXCLUDED_ITEMS         ', clc$nominal_entry, clc$advanced_usage_entry, 15,
          clc$automatically_log, clc$linked_call, ^pup$display_excluded_items],
          {} ['DISPLAY_EXCLUDE_HIGHEST_CYCLE  ', clc$alias_entry, clc$advanced_usage_entry, 14,
          clc$automatically_log, clc$linked_call, ^pup$display_exc_highest_cycles],
          {} ['DISPLAY_EXCLUDE_HIGHEST_CYCLES ', clc$nominal_entry, clc$advanced_usage_entry, 14,
          clc$automatically_log, clc$linked_call, ^pup$display_exc_highest_cycles],
          {} ['DISPLAY_INCLUDED_CYCLE         ', clc$alias_entry, clc$advanced_usage_entry, 17,
          clc$automatically_log, clc$linked_call, ^pup$dis_included_cycles_cm],
          {} ['DISPLAY_INCLUDED_CYCLES        ', clc$nominal_entry, clc$advanced_usage_entry, 17,
          clc$automatically_log, clc$linked_call, ^pup$dis_included_cycles_cm],
          {} ['DISPLAY_INCLUDED_VOLUME        ', clc$alias_entry, clc$advanced_usage_entry, 18,
          clc$automatically_log, clc$linked_call, ^pup$display_included_volumes],
          {} ['DISPLAY_INCLUDED_VOLUMES       ', clc$nominal_entry, clc$advanced_usage_entry, 18,
          clc$automatically_log, clc$linked_call, ^pup$display_included_volumes],
          {} ['DISPLAY_INCLUDE_EMPTY_CATALOG  ', clc$alias_entry, clc$advanced_usage_entry, 16,
          clc$automatically_log, clc$linked_call, ^pup$display_delete_empty_cat_cm],
          {} ['DISPLAY_INCLUDE_EMPTY_CATALOGS ', clc$nominal_entry, clc$advanced_usage_entry, 16,
          clc$automatically_log, clc$linked_call, ^pup$display_delete_empty_cat_cm],
          {} ['DISPLAY_LIST_OPTION            ', clc$alias_entry, clc$advanced_usage_entry, 19,
          clc$automatically_log, clc$linked_call, ^pup$display_list_options],
          {} ['DISPLAY_LIST_OPTIONS           ', clc$nominal_entry, clc$advanced_usage_entry, 19,
          clc$automatically_log, clc$linked_call, ^pup$display_list_options],
          {} ['EXCC                           ', clc$abbreviation_entry, clc$normal_usage_entry, 20,
          clc$automatically_log, clc$linked_call, ^pup$exclude_catalog_command],
          {} ['EXCF                           ', clc$abbreviation_entry, clc$normal_usage_entry, 21,
          clc$automatically_log, clc$linked_call, ^pup$exclude_pf_command],
          {} ['EXCHC                          ', clc$abbreviation_entry, clc$normal_usage_entry, 22,
          clc$automatically_log, clc$linked_call, ^pup$exclude_highest_cycles_cm],
          {} ['EXCLUDE_CATALOG                ', clc$nominal_entry, clc$normal_usage_entry, 20,
          clc$automatically_log, clc$linked_call, ^pup$exclude_catalog_command],
          {} ['EXCLUDE_FILE                   ', clc$nominal_entry, clc$normal_usage_entry, 21,
          clc$automatically_log, clc$linked_call, ^pup$exclude_pf_command],
          {} ['EXCLUDE_HIGHEST_CYCLE          ', clc$alias_entry, clc$normal_usage_entry, 22,
          clc$automatically_log, clc$linked_call, ^pup$exclude_highest_cycles_cm],
          {} ['EXCLUDE_HIGHEST_CYCLES         ', clc$nominal_entry, clc$normal_usage_entry, 22,
          clc$automatically_log, clc$linked_call, ^pup$exclude_highest_cycles_cm],
          {} ['INC                            ', clc$abbreviation_entry, clc$normal_usage_entry, 25,
          clc$automatically_log, clc$linked_call, ^pup$backup_include_cycles],
          {} ['INCC                           ', clc$abbreviation_entry, clc$advanced_usage_entry, 24,
          clc$automatically_log, clc$linked_call, ^pup$include_catalog_command],
          {} ['INCEC                          ', clc$abbreviation_entry, clc$normal_usage_entry, 26,
          clc$automatically_log, clc$linked_call, ^pup$include_empty_catalog_cm],
          {} ['INCLC                          ', clc$abbreviation_entry, clc$normal_usage_entry, 28,
          clc$automatically_log, clc$linked_call, ^pup$include_large_cycles_cmd],
          {} ['INCLUDE_ALL_FILES              ', clc$nominal_entry, clc$advanced_usage_entry, 23,
          clc$automatically_log, clc$linked_call, ^pup$include_all_files],
          {} ['INCLUDE_CATALOG                ', clc$nominal_entry, clc$advanced_usage_entry, 24,
          clc$automatically_log, clc$linked_call, ^pup$include_catalog_command],
          {} ['INCLUDE_CYCLE                  ', clc$alias_entry, clc$normal_usage_entry, 25,
          clc$automatically_log, clc$linked_call, ^pup$backup_include_cycles],
          {} ['INCLUDE_CYCLES                 ', clc$nominal_entry, clc$normal_usage_entry, 25,
          clc$automatically_log, clc$linked_call, ^pup$backup_include_cycles],
          {} ['INCLUDE_EMPTY_CATALOG          ', clc$alias_entry, clc$normal_usage_entry, 26,
          clc$automatically_log, clc$linked_call, ^pup$include_empty_catalog_cm],
          {} ['INCLUDE_EMPTY_CATALOGS         ', clc$nominal_entry, clc$normal_usage_entry, 26,
          clc$automatically_log, clc$linked_call, ^pup$include_empty_catalog_cm],
          {} ['INCLUDE_EXCLUDED_ITEMS         ', clc$nominal_entry, clc$advanced_usage_entry, 27,
          clc$automatically_log, clc$linked_call, ^pup$include_excluded_items],
          {} ['INCLUDE_LARGE_CYCLE            ', clc$alias_entry, clc$normal_usage_entry, 28,
          clc$automatically_log, clc$linked_call, ^pup$include_large_cycles_cmd],
          {} ['INCLUDE_LARGE_CYCLES           ', clc$nominal_entry, clc$normal_usage_entry, 28,
          clc$automatically_log, clc$linked_call, ^pup$include_large_cycles_cmd],
          {} ['INCLUDE_MASTER_CATALOG         ', clc$alias_entry, clc$normal_usage_entry, 29,
          clc$automatically_log, clc$linked_call, ^pup$include_master_catalog_cmd],
          {} ['INCLUDE_MASTER_CATALOGS        ', clc$nominal_entry, clc$normal_usage_entry, 29,
          clc$automatically_log, clc$linked_call, ^pup$include_master_catalog_cmd],
          {} ['INCLUDE_PERMANENT_FILE         ', clc$nominal_entry, clc$advanced_usage_entry, 30,
          clc$automatically_log, clc$linked_call, ^pup$include_pf_command],
          {} ['INCLUDE_SMALL_CYCLE            ', clc$alias_entry, clc$normal_usage_entry, 31,
          clc$automatically_log, clc$linked_call, ^pup$include_small_cycles_cmd],
          {} ['INCLUDE_SMALL_CYCLES           ', clc$nominal_entry, clc$normal_usage_entry, 31,
          clc$automatically_log, clc$linked_call, ^pup$include_small_cycles_cmd],
          {} ['INCLUDE_USER                   ', clc$alias_entry, clc$normal_usage_entry, 32,
          clc$automatically_log, clc$linked_call, ^pup$include_users_command],
          {} ['INCLUDE_USERS                  ', clc$nominal_entry, clc$normal_usage_entry, 32,
          clc$automatically_log, clc$linked_call, ^pup$include_users_command],
          {} ['INCLUDE_VOLUME                 ', clc$alias_entry, clc$normal_usage_entry, 33,
          clc$automatically_log, clc$linked_call, ^pup$backup_include_volumes_cmd],
          {} ['INCLUDE_VOLUMES                ', clc$nominal_entry, clc$normal_usage_entry, 33,
          clc$automatically_log, clc$linked_call, ^pup$backup_include_volumes_cmd],
          {} ['INCMC                          ', clc$abbreviation_entry, clc$normal_usage_entry, 29,
          clc$automatically_log, clc$linked_call, ^pup$include_master_catalog_cmd],
          {} ['INCSC                          ', clc$abbreviation_entry, clc$normal_usage_entry, 31,
          clc$automatically_log, clc$linked_call, ^pup$include_small_cycles_cmd],
          {} ['INCU                           ', clc$abbreviation_entry, clc$normal_usage_entry, 32,
          clc$automatically_log, clc$linked_call, ^pup$include_users_command],
          {} ['INCV                           ', clc$abbreviation_entry, clc$normal_usage_entry, 33,
          clc$automatically_log, clc$linked_call, ^pup$backup_include_volumes_cmd],
          {} ['LOGKFB                         ', clc$abbreviation_entry, clc$hidden_entry, 34,
          clc$automatically_log, clc$linked_call, ^pup$log_keyed_file_backup],
          {} ['LOG_KEYED_FILE_BACKUP          ', clc$nominal_entry, clc$hidden_entry, 34,
          clc$automatically_log, clc$linked_call, ^pup$log_keyed_file_backup],
          {} ['PUSH_RESTORE                   ', clc$nominal_entry, clc$advanced_usage_entry, 35,
          clc$automatically_log, clc$linked_call, ^pup$push_restore_permanent_file],
          {} ['PUTRACE                        ', clc$nominal_entry, clc$advanced_usage_entry, 36,
          clc$automatically_log, clc$linked_call, ^pup$trace],
          {} ['QUI                            ', clc$abbreviation_entry, clc$normal_usage_entry, 37,
          clc$automatically_log, clc$linked_call, ^pup$quit],
          {} ['QUIT                           ', clc$nominal_entry, clc$normal_usage_entry, 37,
          clc$automatically_log, clc$linked_call, ^pup$quit],
          {} ['SELECT_ADVISE_IN               ', clc$nominal_entry, clc$advanced_usage_entry, 38,
          clc$automatically_log, clc$linked_call, ^pup$select_advise_in_cmd],
          {} ['SELECT_DATA_FILE               ', clc$nominal_entry, clc$advanced_usage_entry, 39,
          clc$automatically_log, clc$linked_call, ^pup$select_data_file],
          {} ['SETBO                          ', clc$abbreviation_entry, clc$normal_usage_entry, 40,
          clc$automatically_log, clc$linked_call, ^set_backup_options_subcommand],
          {} ['SETLO                          ', clc$abbreviation_entry, clc$normal_usage_entry, 41,
          clc$automatically_log, clc$linked_call, ^pup$set_list_options_command],
          {} ['SET_BACKUP_OPTION              ', clc$alias_entry, clc$normal_usage_entry, 40,
          clc$automatically_log, clc$linked_call, ^set_backup_options_subcommand],
          {} ['SET_BACKUP_OPTIONS             ', clc$nominal_entry, clc$normal_usage_entry, 40,
          clc$automatically_log, clc$linked_call, ^set_backup_options_subcommand],
          {} ['SET_LIST_OPTION                ', clc$alias_entry, clc$normal_usage_entry, 41,
          clc$automatically_log, clc$linked_call, ^pup$set_list_options_command],
          {} ['SET_LIST_OPTIONS               ', clc$nominal_entry, clc$normal_usage_entry, 41,
          clc$automatically_log, clc$linked_call, ^pup$set_list_options_command],
          {} ['SORT_USERS                     ', clc$nominal_entry, clc$normal_usage_entry, 42,
          clc$automatically_log, clc$linked_call, ^pup$sort_users_command],
          {} ['SORU                           ', clc$abbreviation_entry, clc$normal_usage_entry, 42,
          clc$automatically_log, clc$linked_call, ^pup$sort_users_command]];

  PROCEDURE [XREF] pup$backup_all_files_command
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] pup$backup_catalog_command
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] pup$backup_file_command
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] pup$backup_include_cycles
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] pup$backup_include_volumes_cmd
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] pup$backup_set_command
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] pup$close_volume
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] pup$delete_all_files_cm
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] pup$delete_catalog_contents_cm
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] pup$delete_file_command
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] pup$display_advise_cmd
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] pup$display_all_users_command
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] pup$display_delete_empty_cat_cm
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] pup$display_directives
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] pup$display_excluded_items
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] pup$display_exc_highest_cycles
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] pup$display_included_volumes
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

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

  PROCEDURE [XREF] pup$display_volumes_command
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] pup$dis_included_cycles_cm
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] pup$exclude_catalog_command
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] pup$exclude_highest_cycles_cm
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] pup$exclude_pf_command
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] pup$include_all_files
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] pup$include_catalog_command
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] pup$include_empty_catalog_cm
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] pup$include_excluded_items
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] pup$include_large_cycles_cmd
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] pup$include_master_catalog_cmd
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] pup$include_pf_command
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] pup$include_small_cycles_cmd
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] pup$include_users_command
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] pup$log_keyed_file_backup
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] pup$push_restore_permanent_file
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] pup$select_advise_in_cmd
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] pup$select_data_file
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

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

  PROCEDURE [XREF] pup$sort_users_command
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] pup$trace
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

?? POP ??

?? TITLE := 'p$backup_permanent_file ', EJECT ??

  PROCEDURE p$backup_permanent_file
    (    backup_file: fst$file_reference;
     VAR status: ost$status);

    VAR
      attributes: array [1 .. 3] of clt$utility_attribute,
      status_p: ^ost$status;

    pup$open_backup_file (backup_file, puc$backup_permanent_files, amc$open_at_boi, puv$backup_file_id,
          status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    puv$include_archive_information := avp$family_administrator () OR avp$system_administrator ();

    attributes [1].key := clc$utility_command_table;
    attributes [1].command_table := backup_command_list;
    attributes [2].key := clc$utility_prompt;
    attributes [2].prompt.value := 'PUB';
    attributes [2].prompt.size := 3;
    attributes [3].key := clc$utility_termination_command;
    attributes [3].termination_command := 'QUIT';

    clp$begin_utility (puc$backup_utility_name, attributes, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    clp$include_file (clc$current_command_input, '', puc$backup_utility_name, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    clp$end_utility (puc$backup_utility_name, status);
    IF status.normal THEN
      status_p := ^status;
    ELSE
      PUSH status_p;
    IFEND;

    pup$close_backup_file (puv$backup_file_id, status_p^);

  PROCEND p$backup_permanent_file;
?? TITLE := '[XDCL] pup$backup_permanent_file ', EJECT ??

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

{ PROCEDURE backup_permanent_file (
{   backup_file, bf: file = $required
{   list, l: file = $list
{   status)

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

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 5] of clt$pdt_parameter_name,
      parameters: array [1 .. 3] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
      recend,
      type2: record
        header: clt$type_specification_header,
        default_value: string (5),
      recend,
      type3: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [104, 5, 17, 16, 49, 57, 33],
    clc$command, 5, 3, 1, 0, 0, 0, 3, ''], [
    ['BACKUP_FILE                    ',clc$nominal_entry, 1],
    ['BF                             ',clc$abbreviation_entry, 1],
    ['L                              ',clc$abbreviation_entry, 2],
    ['LIST                           ',clc$nominal_entry, 2],
    ['STATUS                         ',clc$nominal_entry, 3]],
    [
{ PARAMETER 1
    [1, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$required_parameter, 0
  , 0],
{ PARAMETER 2
    [4, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_default_parameter, 0, 5],
{ PARAMETER 3
    [5, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$file_type]],
{ PARAMETER 2
    [[1, 0, clc$file_type],
    '$list'],
{ PARAMETER 3
    [[1, 0, clc$status_type]]];

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

    CONST
      p$backup_file = 1,
      p$list = 2,
      p$status = 3;

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

    VAR
      status_p: ^ost$status;

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

    pup$open_display_file (pvt [p$list].value^.file_value^, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    p$backup_permanent_file (pvt [p$backup_file].value^.file_value^, status);
    IF status.normal THEN
      status_p := ^status;
    ELSE
      PUSH status_p;
    IFEND;

    pup$close_display_file (status_p^);

  PROCEND pup$backup_permanent_file;
?? TITLE := '[XDCL] pup$push_backup_permanent_file ', EJECT ??

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

{ PROCEDURE push_backup_permanent_file (
{   backup_file, bf: file = $required
{   status)

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

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 3] of clt$pdt_parameter_name,
      parameters: array [1 .. 2] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
      recend,
      type2: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [104, 5, 17, 16, 50, 36, 547],
    clc$command, 3, 2, 1, 0, 0, 0, 2, ''], [
    ['BACKUP_FILE                    ',clc$nominal_entry, 1],
    ['BF                             ',clc$abbreviation_entry, 1],
    ['STATUS                         ',clc$nominal_entry, 2]],
    [
{ PARAMETER 1
    [1, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$required_parameter, 0
  , 0],
{ PARAMETER 2
    [3, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$file_type]],
{ PARAMETER 2
    [[1, 0, clc$status_type]]];

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

    CONST
      p$backup_file = 1,
      p$status = 2;

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

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

    p$backup_permanent_file (pvt [p$backup_file].value^.file_value^, status);

  PROCEND pup$push_backup_permanent_file;
?? TITLE := '    pup$quit ', EJECT ??

  PROCEDURE pup$quit
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{ PROCEDURE quit (
{   status)

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

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 1] of clt$pdt_parameter_name,
      parameters: array [1 .. 1] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [104, 5, 13, 12, 40, 4, 421],
    clc$command, 1, 1, 0, 0, 0, 0, 1, ''], [
    ['STATUS                         ',clc$nominal_entry, 1]],
    [
{ PARAMETER 1
    [1, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$status_type]]];

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

    CONST
      p$status = 1;

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

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

    clp$end_include (puc$backup_utility_name, status);

  PROCEND pup$quit;
?? TITLE := '    pup$display_backup_options_cm', EJECT ??

  PROCEDURE pup$display_backup_options_cm
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{ PROCEDURE (pup$disbo) display_backup_options, display_backup_option, disbo (
{   status)

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

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 1] of clt$pdt_parameter_name,
      parameters: array [1 .. 1] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [97, 1, 31, 15, 42, 52, 298],
    clc$command, 1, 1, 0, 0, 0, 0, 1, 'PUP$DISBO'], [
    ['STATUS                         ',clc$nominal_entry, 1]],
    [
{ PARAMETER 1
    [1, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_reference, clc$immediate_evaluation,
clc$standard_parameter_checking, 3,
  clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$status_type]]];

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

    CONST
      p$status = 1;

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

    VAR
      high: integer,
      ignore_status: ost$status,
      local_status: ost$status,
      low: integer,
      option: integer,
      option_string: ost$string,
      s: ost$string,
      subrange: integer;

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

    pup$display_line (' Backup_Options', ignore_status);

    pup$display_blank_lines (1, ignore_status);

    s.value (1, 35) := '   Backup_File_Version           : ';
    s.size := 35;
    s.value (s.size + 1, 31) := puv$bacpf_backup_file_version;
    s.size := s.size + 31;
    pup$display_line (s.value (1, s.size), ignore_status);

    s.value (1, 35) := '   Exclude_Catalog_Information   : ';
    s.size := 35;
    IF puv$exclude_catalog_information THEN
      s.value (s.size + 1, 4) := 'True';
      s.size := s.size + 4;
    ELSE
      s.value (s.size + 1, 5) := 'False';
      s.size := s.size + 5;
    IFEND;
    pup$display_line (s.value (1, s.size), ignore_status);

    s.value (1, 35) := '   Exclude_Site_Backup_Option    : ';
    s.size := 35;
    IF puv$exclude_site_backup_options = $put$exclude_site_backup_options [] THEN
      s.value (s.size + 1, 4) := 'None';
      s.size := s.size + 4;
    ELSEIF puv$exclude_site_backup_options = -$put$exclude_site_backup_options [] THEN
      s.value (s.size + 1, 3) := 'All';
      s.size := s.size + 3;
    ELSE
      s.value (s.size + 1, 1) := '(';
      s.size := s.size + 1;
      option := 0;

    /all_exclude_options/
      WHILE option <= 255 DO
        IF option IN puv$exclude_site_backup_options THEN
          low := option;
          high := option;

        /exclude_range/
          FOR subrange := (low + 1) TO 255 DO
            IF subrange IN puv$exclude_site_backup_options THEN
              high := high + 1;
            ELSE
              EXIT /exclude_range/; {----->
            IFEND;
          FOREND /exclude_range/;
          IF low <> high THEN
            clp$convert_integer_to_string (low, {radix} 10, {include_radix} FALSE, option_string,
                  local_status);
            IF local_status.normal THEN
              s.value (s.size + 1, option_string.size) := option_string.value (1, option_string.size);
              s.size := s.size + option_string.size;
            IFEND;
            s.value (s.size + 1, 2) := '..';
            s.size := s.size + 2;
            clp$convert_integer_to_string (high, {radix} 10, {include_radix} FALSE, option_string,
                  local_status);
            IF local_status.normal THEN
              s.value (s.size + 1, option_string.size) := option_string.value (1, option_string.size);
              s.size := s.size + option_string.size;
            IFEND;
          ELSE
            clp$convert_integer_to_string (low, {radix} 10, {include_radix} FALSE, option_string,
                  local_status);
            IF local_status.normal THEN
              s.value (s.size + 1, option_string.size) := option_string.value (1, option_string.size);
              s.size := s.size + option_string.size;
            IFEND;
          IFEND;
          s.value (s.size + 1, 1) := ' ';
          s.size := s.size + 1;
          low := high;
          option := high + 1;
          CYCLE /all_exclude_options/; {----->
        IFEND;
        option := option + 1;
      WHILEND /all_exclude_options/;
      s.value (s.size, 1) := ')';
    IFEND;
    pup$display_line (s.value (1, s.size), ignore_status);

    s.value (1, 35) := '   Include_Archive_Information   : ';
    s.size := 35;
    IF puv$include_archive_information THEN
      s.value (s.size + 1, 4) := 'True';
      s.size := s.size + 4;
    ELSE
      s.value (s.size + 1, 5) := 'False';
      s.size := s.size + 5;
    IFEND;
    pup$display_line (s.value (1, s.size), ignore_status);

    s.value (1, 36) := '   Include_Data                  : (';
    s.size := 36;
    IF puc$include_unreleasable_data IN puv$include_data_options THEN
      s.value (s.size + 1, 18) := 'Unreleasable_Data ';
      s.size := s.size + 18;
    IFEND;
    IF puc$include_releasable_data IN puv$include_data_options THEN
      s.value (s.size + 1, 16) := 'Releasable_Data ';
      s.size := s.size + 16;
    IFEND;
    IF puc$include_offline_data IN puv$include_data_options THEN
      s.value (s.size + 1, 13) := 'Offline_Data ';
      s.size := s.size + 13;
    IFEND;
    s.value (s.size, 1) := ')';
    pup$display_line (s.value (1, s.size), ignore_status);

    s.value (1, 35) := '   Include_Exception_Conditions  : ';
    s.size := 35;
    IF puv$include_exceptions THEN
      s.value (s.size + 1, 3) := 'All';
      s.size := s.size + 3;
    ELSE
      s.value (s.size + 1, 4) := 'None';
      s.size := s.size + 4;
    IFEND;
    pup$display_line (s.value (1, s.size), ignore_status);

    s.value (1, 35) := '   Null_File_Backup_Option       : ';
    s.size := 35;
    IF puv$read_data_on_null_bf THEN
      s.value (s.size + 1, 27) := 'Reading Data on Null Backup';
      s.size := s.size + 27;
    ELSE
      s.value (s.size + 1, 31) := 'Not Reading Data on Null Backup';
      s.size := s.size + 31;
    IFEND;
    pup$display_line (s.value (1, s.size), ignore_status);

    s.value (1, 35) := '   Share_Modes                   : ';
    s.size := 35;
    IF puv$backup_share_modes = $pft$usage_selections [] THEN
      s.value (s.size + 1, 4) := 'None';
      s.size := s.size + 4;
    ELSE
      s.value (s.size + 1, 1) := '(';
      s.size := s.size + 1;
      IF pfc$read IN puv$backup_share_modes THEN
        s.value (s.size + 1, 5) := 'Read ';
        s.size := s.size + 5;
      IFEND;
      IF pfc$shorten IN puv$backup_share_modes THEN
        s.value (s.size + 1, 8) := 'Shorten ';
        s.size := s.size + 8;
      IFEND;
      IF pfc$append IN puv$backup_share_modes THEN
        s.value (s.size + 1, 7) := 'Append ';
        s.size := s.size + 7;
      IFEND;
      IF pfc$modify IN puv$backup_share_modes THEN
        s.value (s.size + 1, 7) := 'Modify ';
        s.size := s.size + 7;
      IFEND;
      IF pfc$execute IN puv$backup_share_modes THEN
        s.value (s.size + 1, 8) := 'Execute ';
        s.size := s.size + 8;
      IFEND;
      s.value (s.size, 1) := ')';
    IFEND;
    pup$display_line (s.value (1, s.size), ignore_status);

    pup$display_blank_lines (1, ignore_status);

  PROCEND pup$display_backup_options_cm;

?? TITLE := '  set_backup_options_subcommand', EJECT ??

  PROCEDURE set_backup_options_subcommand
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{ PROCEDURE (osm$setbo) set_backup_option, set_backup_options, setbo (
{   exclude_catalog_information, eci: boolean = $optional
{   null_backup_file_option, nbfo: key
{       (read_data, rd)
{     keyend = $optional
{   include_archive_information, iai: boolean = $optional
{   include_data, id: any of
{       list of key
{         (offline_data, od)
{         (releasable_data, rd)
{         (unreleasable_data, ud)
{       keyend
{       key
{         all
{       keyend
{     anyend = (releasable_data, unreleasable_data)
{   backup_file_version, bfv: integer 1..2 = 2
{   exclude_site_backup_option, esbo: (BY_NAME, ADVANCED) any of
{       key
{         all, none
{       keyend
{       list of any of
{         integer 0..255
{         range of integer 0..255
{       anyend
{     anyend = $optional
{   include_exception_conditions, iec: (BY_NAME) key
{       all, none
{     keyend = $optional
{   share_modes, sm: (BY_NAME, ADVANCED) any of
{       key
{         all
{       keyend
{       list of key
{         (append, a)
{         (execute, e)
{         (modify, m)
{         (read, r)
{         (shorten, s)
{         (write, w)
{       keyend
{     anyend = (execute read)
{   status)

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

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 17] of clt$pdt_parameter_name,
      parameters: array [1 .. 9] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
      recend,
      type2: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 2] of clt$keyword_specification,
      recend,
      type3: record
        header: clt$type_specification_header,
      recend,
      type4: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$list_type_qualifier_v2,
          element_type_spec: record
            header: clt$type_specification_header,
            qualifier: clt$keyword_type_qualifier,
            keyword_specs: array [1 .. 6] of clt$keyword_specification,
          recend,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 1] of clt$keyword_specification,
        recend,
        default_value: string (36),
      recend,
      type5: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
        default_value: string (1),
      recend,
      type6: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 2] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$list_type_qualifier_v2,
          element_type_spec: record
            header: clt$type_specification_header,
            qualifier: clt$union_type_qualifier,
            type_size_1: clt$type_specification_size,
            element_type_spec_1: record
              header: clt$type_specification_header,
              qualifier: clt$integer_type_qualifier,
            recend,
            type_size_2: clt$type_specification_size,
            element_type_spec_2: record
              header: clt$type_specification_header,
              qualifier: clt$range_type_qualifier,
              element_type_spec: record
                header: clt$type_specification_header,
                qualifier: clt$integer_type_qualifier,
              recend,
            recend,
          recend,
        recend,
      recend,
      type7: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 2] of clt$keyword_specification,
      recend,
      type8: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 1] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$list_type_qualifier_v2,
          element_type_spec: record
            header: clt$type_specification_header,
            qualifier: clt$keyword_type_qualifier,
            keyword_specs: array [1 .. 12] of clt$keyword_specification,
          recend,
        recend,
        default_value: string (14),
      recend,
      type9: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [99, 1, 25, 14, 16, 23, 361],
    clc$command, 17, 9, 0, 2, 0, 0, 9, 'OSM$SETBO'], [
    ['BACKUP_FILE_VERSION            ',clc$nominal_entry, 5],
    ['BFV                            ',clc$abbreviation_entry, 5],
    ['ECI                            ',clc$abbreviation_entry, 1],
    ['ESBO                           ',clc$abbreviation_entry, 6],
    ['EXCLUDE_CATALOG_INFORMATION    ',clc$nominal_entry, 1],
    ['EXCLUDE_SITE_BACKUP_OPTION     ',clc$nominal_entry, 6],
    ['IAI                            ',clc$abbreviation_entry, 3],
    ['ID                             ',clc$abbreviation_entry, 4],
    ['IEC                            ',clc$abbreviation_entry, 7],
    ['INCLUDE_ARCHIVE_INFORMATION    ',clc$nominal_entry, 3],
    ['INCLUDE_DATA                   ',clc$nominal_entry, 4],
    ['INCLUDE_EXCEPTION_CONDITIONS   ',clc$nominal_entry, 7],
    ['NBFO                           ',clc$abbreviation_entry, 2],
    ['NULL_BACKUP_FILE_OPTION        ',clc$nominal_entry, 2],
    ['SHARE_MODES                    ',clc$nominal_entry, 8],
    ['SM                             ',clc$abbreviation_entry, 8],
    ['STATUS                         ',clc$nominal_entry, 9]],
    [
{ PARAMETER 1
    [5, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$optional_parameter, 0
  , 0],
{ PARAMETER 2
    [14, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 81, clc$optional_parameter,
  0, 0],
{ PARAMETER 3
    [10, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$optional_parameter, 0
  , 0],
{ PARAMETER 4
    [11, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 309,
  clc$optional_default_parameter, 0, 36],
{ PARAMETER 5
    [1, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20,
  clc$optional_default_parameter, 0, 1],
{ PARAMETER 6
    [6, clc$advanced_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 184,
  clc$optional_parameter, 0, 0],
{ PARAMETER 7
    [12, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 81, clc$optional_parameter,
  0, 0],
{ PARAMETER 8
    [15, clc$advanced_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 531,
  clc$optional_default_parameter, 0, 14],
{ PARAMETER 9
    [17, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$boolean_type]],
{ PARAMETER 2
    [[1, 0, clc$keyword_type], [2], [
    ['RD                             ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
    ['READ_DATA                      ', clc$nominal_entry, clc$normal_usage_entry, 1]]
    ],
{ PARAMETER 3
    [[1, 0, clc$boolean_type]],
{ PARAMETER 4
    [[1, 0, clc$union_type], [[clc$keyword_type, clc$list_type],
    FALSE, 2],
    245, [[1, 0, clc$list_type], [229, 1, clc$max_list_size, 0, FALSE, FALSE],
        [[1, 0, clc$keyword_type], [6], [
        ['OD                             ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
        ['OFFLINE_DATA                   ', clc$nominal_entry, clc$normal_usage_entry, 1],
        ['RD                             ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
        ['RELEASABLE_DATA                ', clc$nominal_entry, clc$normal_usage_entry, 2],
        ['UD                             ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
        ['UNRELEASABLE_DATA              ', clc$nominal_entry, clc$normal_usage_entry, 3]]
        ]
      ],
    44, [[1, 0, clc$keyword_type], [1], [
      ['ALL                            ', clc$nominal_entry, clc$normal_usage_entry, 1]]
      ]
    ,
    '(releasable_data, unreleasable_data)'],
{ PARAMETER 5
    [[1, 0, clc$integer_type], [1, 2, 10],
    '2'],
{ PARAMETER 6
    [[1, 0, clc$union_type], [[clc$keyword_type, clc$list_type],
    FALSE, 2],
    81, [[1, 0, clc$keyword_type], [2], [
      ['ALL                            ', clc$nominal_entry, clc$normal_usage_entry, 1],
      ['NONE                           ', clc$nominal_entry, clc$normal_usage_entry, 2]]
      ],
    83, [[1, 0, clc$list_type], [67, 1, clc$max_list_size, 0, FALSE, FALSE],
        [[1, 0, clc$union_type], [[clc$integer_type, clc$range_type],
        FALSE, 2],
        20, [[1, 0, clc$integer_type], [0, 255, 10]],
        27, [[1, 0, clc$range_type], [20],
            [[1, 0, clc$integer_type], [0, 255, 10]]
          ]
        ]
      ]
    ],
{ PARAMETER 7
    [[1, 0, clc$keyword_type], [2], [
    ['ALL                            ', clc$nominal_entry, clc$normal_usage_entry, 1],
    ['NONE                           ', clc$nominal_entry, clc$normal_usage_entry, 2]]
    ],
{ PARAMETER 8
    [[1, 0, clc$union_type], [[clc$keyword_type, clc$list_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['ALL                            ', clc$nominal_entry, clc$normal_usage_entry, 1]]
      ],
    467, [[1, 0, clc$list_type], [451, 1, clc$max_list_size, 0, FALSE, FALSE],
        [[1, 0, clc$keyword_type], [12], [
        ['A                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
        ['APPEND                         ', clc$nominal_entry, clc$normal_usage_entry, 1],
        ['E                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
        ['EXECUTE                        ', clc$nominal_entry, clc$normal_usage_entry, 2],
        ['M                              ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
        ['MODIFY                         ', clc$nominal_entry, clc$normal_usage_entry, 3],
        ['R                              ', clc$abbreviation_entry, clc$normal_usage_entry, 4],
        ['READ                           ', clc$nominal_entry, clc$normal_usage_entry, 4],
        ['S                              ', clc$abbreviation_entry, clc$normal_usage_entry, 5],
        ['SHORTEN                        ', clc$nominal_entry, clc$normal_usage_entry, 5],
        ['W                              ', clc$abbreviation_entry, clc$normal_usage_entry, 6],
        ['WRITE                          ', clc$nominal_entry, clc$normal_usage_entry, 6]]
        ]
      ]
    ,
    '(execute read)'],
{ PARAMETER 9
    [[1, 0, clc$status_type]]];

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

    CONST
      p$exclude_catalog_information = 1,
      p$null_backup_file_option = 2,
      p$include_archive_information = 3,
      p$include_data = 4,
      p$backup_file_version = 5,
      p$exclude_site_backup_option = 6,
      p$include_exception_conditions = 7,
      p$share_modes = 8,
      p$status = 9;

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

    CONST
      c$max_range_string_size = 9; {=#size('255..255 ')

    VAR
      exclude_site_backup_option: ^clt$data_value,
      high: integer,
      ignore_status: ost$status,
      include_data_option: ^clt$data_value,
      include_site_backup_option: ^clt$data_value,
      local_usage_share_value: ^clt$data_value,
      low: integer,
      option: integer,
      s: ost$string,
      share_mode_value: clt$keyword,
      usage_share_selections: pft$usage_selections;

?? NEWTITLE := '[inline] P$ADDL_INTEGER_RANGE', EJECT ??

    PROCEDURE [INLINE] p$addl_integer_range
      (VAR line: ost$string;
           low_value: integer;
           high_value: integer);

      VAR
        ignore_status: ost$status;

      fip#addl_integer (line, low, ignore_status);
      fip#addl_string (line, '..');
      fip#addl_integer (line, high, ignore_status);

    PROCEND p$addl_integer_range;
?? OLDTITLE ??
?? EJECT ??

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

    pup$display_line (' Set_Backup_Options', ignore_status);
    pup$display_blank_lines (1, ignore_status);

    IF pvt [p$backup_file_version].value^.integer_value.value = 1 THEN
      puv$bacpf_backup_file_version := puc$backup_file_version_1;
    ELSEIF pvt [p$backup_file_version].value^.integer_value.value = 2 THEN
      puv$bacpf_backup_file_version := puc$backup_file_version_2;
    IFEND;
    s.value (1, 25) := '   Backup_File_Version = ';
    s.size := 25;
    s.value (s.size + 1, 31) := puv$bacpf_backup_file_version;
    s.size := s.size + 31;
    pup$display_line (s.value (1, s.size), ignore_status);

    IF pvt [p$exclude_catalog_information].specified THEN
      puv$exclude_catalog_information := pvt [p$exclude_catalog_information].value^.boolean_value.value;
      s.value (1, 33) := '   Exclude_Catalog_Information = ';
      s.size := 33;
      IF puv$exclude_catalog_information THEN
        s.value (s.size + 1, 4) := 'True';
        s.size := s.size + 4;
      ELSE
        s.value (s.size + 1, 5) := 'False';
        s.size := s.size + 5;
      IFEND;
      pup$display_line (s.value (1, s.size), ignore_status);
    IFEND;

{Exclude_Site_Backup_Option
    IF pvt [p$exclude_site_backup_option].specified THEN
      exclude_site_backup_option := pvt [p$exclude_site_backup_option].value;
      fip#addl_initialize (s, '   Exclude_Site_Backup_Option = ');
      IF exclude_site_backup_option^.keyword_value = 'NONE' THEN
        puv$exclude_site_backup_options := $put$exclude_site_backup_options [];
        fip#addl_string (s, 'None');
      ELSEIF exclude_site_backup_option^.keyword_value = 'ALL' THEN
        puv$exclude_site_backup_options := -$put$exclude_site_backup_options [];
        fip#addl_string (s, 'All');
      ELSE
        fip#addl_string (s, '(');

        WHILE exclude_site_backup_option <> NIL DO

          {line overflow
          IF s.size + c$max_range_string_size > puv$listing_display_control.page_width THEN
            fip#addl_string (s, ' ..');
            pup$display_line (s.value (1, s.size), ignore_status);
            fip#addl_initialize (s, '       ');
          IFEND;

          IF exclude_site_backup_option^.element_value^.kind = clc$integer THEN
            low := exclude_site_backup_option^.element_value^.integer_value.value;
            high := exclude_site_backup_option^.element_value^.integer_value.value;
          ELSE {range
            low := exclude_site_backup_option^.element_value^.low_value^.integer_value.value;
            high := exclude_site_backup_option^.element_value^.high_value^.integer_value.value;
          IFEND;

          IF low > high THEN
            fip#addl_initialize (s, '');
            p$addl_integer_range (s, low, high);
            osp$set_status_abnormal (puc$pf_utility_id, pue$bad_integer_subrange, s.value (1, s.size),
                  status);
            RETURN; {----->
          IFEND;

          IF low = high THEN
            fip#addl_integer (s, low, ignore_status);
          ELSE
            p$addl_integer_range (s, low, high);
          IFEND;
          fip#addl_string (s, ' ');

          FOR option := low TO high DO
            puv$exclude_site_backup_options := puv$exclude_site_backup_options +
                  $put$exclude_site_backup_options [option];
          FOREND;
          exclude_site_backup_option := exclude_site_backup_option^.link;
        WHILEND;
        fip#addl_string (s, ')');
      IFEND;
      pup$display_line (s.value (1, s.size), ignore_status);
    IFEND;

    IF pvt [p$include_archive_information].specified THEN
      IF pvt [p$include_archive_information].value^.boolean_value.value AND
            NOT (avp$family_administrator () OR avp$system_administrator ()) THEN
        osp$set_status_abnormal (puc$pf_utility_id, pue$user_set_iai_true, '', status);
        RETURN; {----->
      ELSE
        puv$include_archive_information := pvt [p$include_archive_information].value^.boolean_value.value;
        s.value (1, 33) := '   Include_Archive_Information = ';
        s.size := 33;
        IF puv$include_archive_information THEN
          s.value (s.size + 1, 4) := 'True';
          s.size := s.size + 4;
        ELSE
          s.value (s.size + 1, 5) := 'False';
          s.size := s.size + 5;
        IFEND;
        pup$display_line (s.value (1, s.size), ignore_status);
      IFEND;
    ELSE
      puv$include_archive_information := avp$family_administrator () OR avp$system_administrator ();
      s.value (1, 47) := '   Include_Archive_Information (Unspecified) = ';
      s.size := 47;
      IF puv$include_archive_information THEN
        s.value (s.size + 1, 4) := 'True';
        s.size := s.size + 4;
      ELSE
        s.value (s.size + 1, 5) := 'False';
        s.size := s.size + 5;
      IFEND;
      pup$display_line (s.value (1, s.size), ignore_status);
    IFEND;

    include_data_option := pvt [p$include_data].value;
    puv$include_data_options := $put$include_data_options [];
    s.value := '   Include_Data = ';
    s.size := 18;
    IF include_data_option^.kind = clc$keyword THEN
      { Checks for the keyword ALL. }
      IF NOT pup$all_volumes_included () THEN
        osp$set_status_abnormal (puc$pf_utility_id, pue$incv_and_offline_conflict, '', status);
        RETURN; {----->
      ELSE
        puv$include_data_options := -$put$include_data_options [];
        s.value (s.size + 1, 4) := 'All ';
        s.size := s.size + 4;
      IFEND;
    ELSE
      s.value (s.size + 1, 1) := '(';
      s.size := s.size + 1;
      WHILE include_data_option <> NIL DO
        IF include_data_option^.element_value^.keyword_value = 'OFFLINE_DATA' THEN
          IF NOT pup$all_volumes_included () THEN
            osp$set_status_abnormal (puc$pf_utility_id, pue$incv_and_offline_conflict, '', status);
            RETURN; {----->
          ELSE
            s.value (s.size + 1, 13) := 'Offline_Data ';
            s.size := s.size + 13;
            puv$include_data_options := puv$include_data_options +
                  $put$include_data_options [puc$include_offline_data];
          IFEND;
        ELSEIF include_data_option^.element_value^.keyword_value = 'RELEASABLE_DATA' THEN
          s.value (s.size + 1, 16) := 'Releasable_Data ';
          s.size := s.size + 16;
          puv$include_data_options := puv$include_data_options +
                $put$include_data_options [puc$include_releasable_data];
        ELSEIF include_data_option^.element_value^.keyword_value = 'UNRELEASABLE_DATA' THEN
          s.value (s.size + 1, 18) := 'Unreleasable_Data ';
          s.size := s.size + 18;
          puv$include_data_options := puv$include_data_options +
                $put$include_data_options [puc$include_unreleasable_data];
        IFEND;
        include_data_option := include_data_option^.link;
      WHILEND;
      s.value (s.size, 1) := ')';
    IFEND;
    pup$display_line (s.value (1, s.size), ignore_status);

    IF pvt [p$include_exception_conditions].specified THEN
      s.value := '   Include_Exception_Conditions =  ';
      s.size := 35;
      IF pvt [p$include_exception_conditions].value^.keyword_value = 'ALL' THEN
        puv$include_exceptions := TRUE;
        s.value (s.size + 1, 3) := 'All';
        s.size := s.size + 3;
      ELSE { include_exception_conditions = 'NONE'}
        IF (puv$backup_file_id.device_class <> rmc$null_device) THEN
          osp$set_status_abnormal (puc$pf_utility_id, pue$cannot_specify_none_for_iec,
                '$NULL is not specified for the BACKUP_FILE parameter', status);
          RETURN; {----->
        ELSEIF (puv$backup_file_id.device_class = rmc$null_device) AND puv$read_data_on_null_bf THEN
          osp$set_status_abnormal (puc$pf_utility_id, pue$cannot_specify_none_for_iec,
                'READ_DATA is specified for the NULL_BACKUP_FILE_OPTION pa' CAT 'rameter', status);
          RETURN; {----->
        ELSE
          puv$include_exceptions := FALSE;
          s.value (s.size + 1, 4) := 'None';
          s.size := s.size + 4;
        IFEND;
      IFEND;
      pup$display_line (s.value (1, s.size), ignore_status);
    IFEND;

    IF pvt [p$null_backup_file_option].specified THEN
      IF puv$backup_file_id.device_class = rmc$null_device THEN
        s.value := '   Null_Backup_File_Option = ';
        s.size := 29;
        IF pvt [p$null_backup_file_option].value^.keyword_value = 'READ_DATA' THEN
          puv$read_data_on_null_bf := TRUE;
          s.value (s.size + 1, 27) := 'Reading Data on Null Backup';
          s.size := s.size + 27;
        ELSE
          puv$read_data_on_null_bf := FALSE;
          s.value (s.size + 1, 31) := 'Not Reading Data on Null Backup';
          s.size := s.size + 31;
        IFEND;
        pup$display_line (s.value (1, s.size), ignore_status);
      ELSE
        osp$set_status_abnormal (puc$pf_utility_id, pue$null_backup_file_required, '', status);
        RETURN; {----->
      IFEND;
    IFEND;

    s.value := '   Share_Modes = ';
    s.size := 17;
    local_usage_share_value := pvt [p$share_modes].value;
    IF local_usage_share_value^.kind = clc$keyword THEN
      usage_share_selections := -$pft$usage_selections [];
      s.value (s.size + 1, 3) := 'All ';
      s.size := s.size + 3;
    ELSE
      usage_share_selections := $pft$usage_selections [];
      s.value (s.size + 1, 1) := '(';
      s.size := s.size + 1;
      WHILE local_usage_share_value <> NIL DO
        share_mode_value := local_usage_share_value^.element_value^.keyword_value;
        IF share_mode_value = 'APPEND' THEN
          usage_share_selections := usage_share_selections + $pft$usage_selections [pfc$append];
          s.value (s.size + 1, 7) := 'Append ';
          s.size := s.size + 7;
        ELSEIF share_mode_value = 'EXECUTE' THEN
          usage_share_selections := usage_share_selections + $pft$usage_selections [pfc$execute];
          s.value (s.size + 1, 8) := 'Execute ';
          s.size := s.size + 8;
        ELSEIF share_mode_value = 'MODIFY' THEN
          usage_share_selections := usage_share_selections + $pft$usage_selections [pfc$modify];
          s.value (s.size + 1, 7) := 'Modify ';
          s.size := s.size + 7;
        ELSEIF share_mode_value = 'READ' THEN
          usage_share_selections := usage_share_selections + $pft$usage_selections [pfc$read];
          s.value (s.size + 1, 5) := 'Read ';
          s.size := s.size + 5;
        ELSEIF share_mode_value = 'SHORTEN' THEN
          usage_share_selections := usage_share_selections + $pft$usage_selections [pfc$shorten];
          s.value (s.size + 1, 8) := 'Shorten ';
          s.size := s.size + 8;
        ELSEIF share_mode_value = 'WRITE' THEN
          usage_share_selections := usage_share_selections + $pft$usage_selections
                [pfc$append, pfc$modify, pfc$shorten];
          s.value (s.size + 1, 6) := 'Write ';
          s.size := s.size + 6;
        IFEND;
        local_usage_share_value := local_usage_share_value^.link;
      WHILEND;
      s.value (s.size, 1) := ')';
    IFEND;
    puv$backup_share_modes := usage_share_selections;
    pup$display_line (s.value (1, s.size), ignore_status);
    pup$display_blank_lines (1, ignore_status);

  PROCEND set_backup_options_subcommand;

MODEND pum$backup_permanent_file;
