?? RIGHT := 110 ??
?? NEWTITLE := ' NOS/VE Backup/Restore Utilities:  restore_permanent_files ', EJECT ??
MODULE pum$restore_permanent_files;
?? RIGHT := 110 ??
{
{   This module contains processing the extry point and command table
{ for the restore_permanent_files utility, and well as processing for the
{ SET_RESTORE_OPTIONS subcommand.
{
?? NEWTITLE := '   Global Declarations', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc pus$literals
*copyc pfc$null_shared_queue
*copyc pfc$system_shared_queue_name
*copyc rmc$unspecified_allocation_size
*copyc rmc$unspecified_file_class
*copyc rmc$unspecified_file_size
*copyc rmc$unspecified_vsn
*copyc pud$backup_file
*copyc rmd$volume_declarations
*copyc pue$error_condition_codes
*copyc dmt$class
*copyc fmt$mass_storage_request_info
*copyc ost$caller_identifier
*copyc ost$status
*copyc ost$string
*copyc pft$purge_cycle_options
*copyc rmt$allocation_size
*copyc rmt$recorded_vsn
?? POP ??
*copyc avp$family_administrator
*copyc avp$system_administrator
*copyc clp$begin_utility
*copyc clp$end_include
*copyc clp$end_utility
*copyc clp$evaluate_parameters
*copyc clp$include_file
*copyc osp$set_status_abnormal
*copyc pfp$convert_ord_to_shared_queue
*copyc pfp$convert_shared_queue_to_ord
*copyc pup$close_display_file
*copyc pup$display_blank_lines
*copyc pup$display_boolean
*copyc pup$display_integer
*copyc pup$display_line
*copyc pup$open_display_file
*copyc rmp$build_mass_storage_info
*copyc rmp$convert_keyword_to_class
?? TITLE := '    Global Variables', EJECT ??

  TYPE
    restore_option_source = (set_restore_options_command, subcommand_default, utility_default);

  VAR
    puv$create_objects: [XDCL, STATIC] boolean := TRUE,
    puv$mass_storage_info: [XDCL, STATIC] fmt$mass_storage_request_info := [
          {allocation_size} rmc$unspecified_allocation_size,
          {estimated_file_size} rmc$unspecified_file_size,
          {initial_volume} rmc$unspecified_vsn,
          {maintenance_job} FALSE,
          {mass_storage_class} rmc$unspecified_file_class,
          {shared_queue} pfc$null_shared_queue,
          {transfer_size} rmc$unspecified_transfer_size,
          {user_privilege} rmc$normal_user,
          {volume_overflow_allowed} TRUE],
    puv$purge_cycle_options: [XDCL, STATIC] pft$purge_cycle_options := [
          {enforce_password_validation} TRUE,
          {enforce_ring_validation} TRUE,
          {preserve_cycle_entry} FALSE],
    puv$prev_open_by_$backup_file: [XDCL, STATIC] boolean := FALSE,
    puv$replace_cycle_data: [XDCL, STATIC] boolean := FALSE,
    puv$require_modification_match: [XDCL, STATIC] boolean := TRUE,
    puv$respf_backup_file_version: [XDCL, STATIC] put$backup_file_version_name,
    puv$restore_archive_information: [XDCL] boolean,
    puv$trace_selected: [XDCL, STATIC] boolean := FALSE,
    puv$update_cycle_statistics: [XDCL, STATIC] boolean := FALSE;

  VAR
    rai_specified: [STATIC] boolean := FALSE,
    update_cycle_statistics_source: [STATIC] restore_option_source := utility_default;

  CONST
    puc$restore_utility_name = 'RESTORE_PERMANENT_FILES        ';

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

{ table restore_command_list type=command section_name=pus$literals scope=local
{ command (analyze_server_keypoints, anask) p=dfp$analyze_server_keypoints cm=xref a=hidden
{ command (change_all_permits, chaap) p=pup$change_all_permits_cm cm=xref
{ command (change_catalog_permits, chacp) p=pup$change_catalog_permits_cm cm=xref
{ command (change_file_permits, chafp) p=pup$change_file_permits_command cm=xref a=au
{ command (create_mass_storage_catalog, cremsc) p=pup$create_ms_catalog_cmnd cm=xref a=hidden
{ command (define_master_catalog) p=pup$defmc_command cm=xref a=hidden
{ command (detach_all_catalogs, detac) p=pup$detach_all_catalogs cm=xref a=hidden
{ command (display_all_catalogs) p=pup$display_all_catalogs_cmnd cm=xref a=au
{ command (display_advise) p=pup$display_advise_cmd cm=xref a=au
{ command (display_ast) p=pup$display_ast cm=xref a=au
{ command (display_backup_file, disbf) p=pup$display_backup_file_command cm=xref
{ command display_fmd p=pup$display_fmd_cmd cm=xref a=au
{ command (display_master_catalog) p=pup$display_master_catalog_cmnd cm=xref a=au
{ command (display_restore_options display_restore_option disro) p=pup$display_restore_options_cm cm=local
{ command (display_vst) p=pup$display_vst cm=xref a=au
{ command (get_attached_pf_table) p=pup$get_attached_pf_table_cm cm=xref a=hidden
{ command (get_catalog_alarm_table) p=pup$get_catalog_alarm_table_cm cm=xref a=hidden
{ command (get_catalog_segment) p=pup$get_catalog_segment_cm cm=xref a=hidden
{ command (get_file_info) p=pup$get_file_info cm=xref a=hidden
{ command (get_queued_catalog_table) p=pup$get_queued_catalog_table_cm cm=xref a=hidden
{ command (get_stored_fmd) p=pup$get_file_fmd_cm cm=xref a=hidden
{ command (include_cycles include_cycle incc) p=pup$restore_include_cycles cm=xref
{ command (include_volumes include_volume incv) p=pup$restore_include_volumes_cmd cm=xref
{ command (purge_master_catalog) p=pup$purmc_command cm=xref a=hidden
{ command (purge_object) p=pup$purge_object_cm cm=xref a=hidden
{ command (push_backup) p=pup$push_backup_permanent_file cm=xref a=au
{ command (put_catalog_segment) p=pup$put_catalog_segment_cm cm=xref a=hidden
{ command (putrace) p=pup$trace cm=local a=au
{ command (quit, qui) p=pup$quit_restore cm=local
{ command (restore_all_files, resaf) p=pup$restore_all_files_command cm=xref
{ command (restore_catalog, resc) p=pup$restore_catalog_command cm=xref
{ command (restore_excluded_file_cycles, restore_excluded_file_cycle, resefc)   ..
{   p=pup$restore_excluded_cycles_cm cm=xref
{ command (restore_existing_catalog, resec) p=pup$restore_existing_catalog_cm cm=xref
{ command (restore_existing_file, resef) p=pup$restore_existing_file_cm cm=xref log=manual
{ command (restore_file, resf) p=pup$restore_file_command cm=xref log=manual
{ command (restore_objects, restore_object, reso) p=pup$restore_object_command cm=xref
{ command (restore_missing_catalogs, restore_missing_catalog, resmc) p=pup$restore_missing_catalogs_cm   ..
{   cm=xref
{ command (search_data_file) p=pup$search_data_file cm=xref a=au
{ command (select_advise_in) p=pup$select_advise_in_cmd cm=xref a=au
{ command (set_list_options, set_list_option, setlo) p=pup$set_list_options_command cm=xref
{ command (set_restore_options, set_restore_option, setro) p=pup$set_restore_options_command cm=local
{ command (set_restore_missing_catalogs, set_restore_missing_catalog, setrmc)   ..
{   p=pup$set_restore_missing_catalog cm=xref
{ tablend

?? PUSH (LISTEXT := ON) ??

VAR
  restore_command_list: [STATIC, READ, pus$literals] ^clt$command_table := ^restore_command_list_entries,

  restore_command_list_entries: [STATIC, READ, pus$literals] array [1 .. 73] of clt$command_table_entry := [
  {} ['ANALYZE_SERVER_KEYPOINTS       ', clc$nominal_entry, clc$hidden_entry, 1,
        clc$automatically_log, clc$linked_call, ^dfp$analyze_server_keypoints],
  {} ['ANASK                          ', clc$abbreviation_entry, clc$hidden_entry, 1,
        clc$automatically_log, clc$linked_call, ^dfp$analyze_server_keypoints],
  {} ['CHAAP                          ', clc$abbreviation_entry, clc$normal_usage_entry, 2,
        clc$automatically_log, clc$linked_call, ^pup$change_all_permits_cm],
  {} ['CHACP                          ', clc$abbreviation_entry, clc$normal_usage_entry, 3,
        clc$automatically_log, clc$linked_call, ^pup$change_catalog_permits_cm],
  {} ['CHAFP                          ', clc$abbreviation_entry, clc$advanced_usage_entry, 4,
        clc$automatically_log, clc$linked_call, ^pup$change_file_permits_command],
  {} ['CHANGE_ALL_PERMITS             ', clc$nominal_entry, clc$normal_usage_entry, 2,
        clc$automatically_log, clc$linked_call, ^pup$change_all_permits_cm],
  {} ['CHANGE_CATALOG_PERMITS         ', clc$nominal_entry, clc$normal_usage_entry, 3,
        clc$automatically_log, clc$linked_call, ^pup$change_catalog_permits_cm],
  {} ['CHANGE_FILE_PERMITS            ', clc$nominal_entry, clc$advanced_usage_entry, 4,
        clc$automatically_log, clc$linked_call, ^pup$change_file_permits_command],
  {} ['CREATE_MASS_STORAGE_CATALOG    ', clc$nominal_entry, clc$hidden_entry, 5,
        clc$automatically_log, clc$linked_call, ^pup$create_ms_catalog_cmnd],
  {} ['CREMSC                         ', clc$abbreviation_entry, clc$hidden_entry, 5,
        clc$automatically_log, clc$linked_call, ^pup$create_ms_catalog_cmnd],
  {} ['DEFINE_MASTER_CATALOG          ', clc$nominal_entry, clc$hidden_entry, 6,
        clc$automatically_log, clc$linked_call, ^pup$defmc_command],
  {} ['DETAC                          ', clc$abbreviation_entry, clc$hidden_entry, 7,
        clc$automatically_log, clc$linked_call, ^pup$detach_all_catalogs],
  {} ['DETACH_ALL_CATALOGS            ', clc$nominal_entry, clc$hidden_entry, 7,
        clc$automatically_log, clc$linked_call, ^pup$detach_all_catalogs],
  {} ['DISBF                          ', clc$abbreviation_entry, clc$normal_usage_entry, 11,
        clc$automatically_log, clc$linked_call, ^pup$display_backup_file_command],
  {} ['DISPLAY_ADVISE                 ', clc$nominal_entry, clc$advanced_usage_entry, 9,
        clc$automatically_log, clc$linked_call, ^pup$display_advise_cmd],
  {} ['DISPLAY_ALL_CATALOGS           ', clc$nominal_entry, clc$advanced_usage_entry, 8,
        clc$automatically_log, clc$linked_call, ^pup$display_all_catalogs_cmnd],
  {} ['DISPLAY_AST                    ', clc$nominal_entry, clc$advanced_usage_entry, 10,
        clc$automatically_log, clc$linked_call, ^pup$display_ast],
  {} ['DISPLAY_BACKUP_FILE            ', clc$nominal_entry, clc$normal_usage_entry, 11,
        clc$automatically_log, clc$linked_call, ^pup$display_backup_file_command],
  {} ['DISPLAY_FMD                    ', clc$nominal_entry, clc$advanced_usage_entry, 12,
        clc$automatically_log, clc$linked_call, ^pup$display_fmd_cmd],
  {} ['DISPLAY_MASTER_CATALOG         ', clc$nominal_entry, clc$advanced_usage_entry, 13,
        clc$automatically_log, clc$linked_call, ^pup$display_master_catalog_cmnd],
  {} ['DISPLAY_RESTORE_OPTION         ', clc$alias_entry, clc$normal_usage_entry, 14,
        clc$automatically_log, clc$linked_call, ^pup$display_restore_options_cm],
  {} ['DISPLAY_RESTORE_OPTIONS        ', clc$nominal_entry, clc$normal_usage_entry, 14,
        clc$automatically_log, clc$linked_call, ^pup$display_restore_options_cm],
  {} ['DISPLAY_VST                    ', clc$nominal_entry, clc$advanced_usage_entry, 15,
        clc$automatically_log, clc$linked_call, ^pup$display_vst],
  {} ['DISRO                          ', clc$abbreviation_entry, clc$normal_usage_entry, 14,
        clc$automatically_log, clc$linked_call, ^pup$display_restore_options_cm],
  {} ['GET_ATTACHED_PF_TABLE          ', clc$nominal_entry, clc$hidden_entry, 16,
        clc$automatically_log, clc$linked_call, ^pup$get_attached_pf_table_cm],
  {} ['GET_CATALOG_ALARM_TABLE        ', clc$nominal_entry, clc$hidden_entry, 17,
        clc$automatically_log, clc$linked_call, ^pup$get_catalog_alarm_table_cm],
  {} ['GET_CATALOG_SEGMENT            ', clc$nominal_entry, clc$hidden_entry, 18,
        clc$automatically_log, clc$linked_call, ^pup$get_catalog_segment_cm],
  {} ['GET_FILE_INFO                  ', clc$nominal_entry, clc$hidden_entry, 19,
        clc$automatically_log, clc$linked_call, ^pup$get_file_info],
  {} ['GET_QUEUED_CATALOG_TABLE       ', clc$nominal_entry, clc$hidden_entry, 20,
        clc$automatically_log, clc$linked_call, ^pup$get_queued_catalog_table_cm],
  {} ['GET_STORED_FMD                 ', clc$nominal_entry, clc$hidden_entry, 21,
        clc$automatically_log, clc$linked_call, ^pup$get_file_fmd_cm],
  {} ['INCC                           ', clc$abbreviation_entry, clc$normal_usage_entry, 22,
        clc$automatically_log, clc$linked_call, ^pup$restore_include_cycles],
  {} ['INCLUDE_CYCLE                  ', clc$alias_entry, clc$normal_usage_entry, 22,
        clc$automatically_log, clc$linked_call, ^pup$restore_include_cycles],
  {} ['INCLUDE_CYCLES                 ', clc$nominal_entry, clc$normal_usage_entry, 22,
        clc$automatically_log, clc$linked_call, ^pup$restore_include_cycles],
  {} ['INCLUDE_VOLUME                 ', clc$alias_entry, clc$normal_usage_entry, 23,
        clc$automatically_log, clc$linked_call, ^pup$restore_include_volumes_cmd],
  {} ['INCLUDE_VOLUMES                ', clc$nominal_entry, clc$normal_usage_entry, 23,
        clc$automatically_log, clc$linked_call, ^pup$restore_include_volumes_cmd],
  {} ['INCV                           ', clc$abbreviation_entry, clc$normal_usage_entry, 23,
        clc$automatically_log, clc$linked_call, ^pup$restore_include_volumes_cmd],
  {} ['PURGE_MASTER_CATALOG           ', clc$nominal_entry, clc$hidden_entry, 24,
        clc$automatically_log, clc$linked_call, ^pup$purmc_command],
  {} ['PURGE_OBJECT                   ', clc$nominal_entry, clc$hidden_entry, 25,
        clc$automatically_log, clc$linked_call, ^pup$purge_object_cm],
  {} ['PUSH_BACKUP                    ', clc$nominal_entry, clc$advanced_usage_entry, 26,
        clc$automatically_log, clc$linked_call, ^pup$push_backup_permanent_file],
  {} ['PUTRACE                        ', clc$nominal_entry, clc$advanced_usage_entry, 28,
        clc$automatically_log, clc$linked_call, ^pup$trace],
  {} ['PUT_CATALOG_SEGMENT            ', clc$nominal_entry, clc$hidden_entry, 27,
        clc$automatically_log, clc$linked_call, ^pup$put_catalog_segment_cm],
  {} ['QUI                            ', clc$abbreviation_entry, clc$normal_usage_entry, 29,
        clc$automatically_log, clc$linked_call, ^pup$quit_restore],
  {} ['QUIT                           ', clc$nominal_entry, clc$normal_usage_entry, 29,
        clc$automatically_log, clc$linked_call, ^pup$quit_restore],
  {} ['RESAF                          ', clc$abbreviation_entry, clc$normal_usage_entry, 30,
        clc$automatically_log, clc$linked_call, ^pup$restore_all_files_command],
  {} ['RESC                           ', clc$abbreviation_entry, clc$normal_usage_entry, 31,
        clc$automatically_log, clc$linked_call, ^pup$restore_catalog_command],
  {} ['RESEC                          ', clc$abbreviation_entry, clc$normal_usage_entry, 33,
        clc$automatically_log, clc$linked_call, ^pup$restore_existing_catalog_cm],
  {} ['RESEF                          ', clc$abbreviation_entry, clc$normal_usage_entry, 34,
        clc$manually_log, clc$linked_call, ^pup$restore_existing_file_cm],
  {} ['RESEFC                         ', clc$abbreviation_entry, clc$normal_usage_entry, 32,
        clc$automatically_log, clc$linked_call, ^pup$restore_excluded_cycles_cm],
  {} ['RESF                           ', clc$abbreviation_entry, clc$normal_usage_entry, 35,
        clc$manually_log, clc$linked_call, ^pup$restore_file_command],
  {} ['RESMC                          ', clc$abbreviation_entry, clc$normal_usage_entry, 37,
        clc$automatically_log, clc$linked_call, ^pup$restore_missing_catalogs_cm],
  {} ['RESO                           ', clc$abbreviation_entry, clc$normal_usage_entry, 36,
        clc$automatically_log, clc$linked_call, ^pup$restore_object_command],
  {} ['RESTORE_ALL_FILES              ', clc$nominal_entry, clc$normal_usage_entry, 30,
        clc$automatically_log, clc$linked_call, ^pup$restore_all_files_command],
  {} ['RESTORE_CATALOG                ', clc$nominal_entry, clc$normal_usage_entry, 31,
        clc$automatically_log, clc$linked_call, ^pup$restore_catalog_command],
  {} ['RESTORE_EXCLUDED_FILE_CYCLE    ', clc$alias_entry, clc$normal_usage_entry, 32,
        clc$automatically_log, clc$linked_call, ^pup$restore_excluded_cycles_cm],
  {} ['RESTORE_EXCLUDED_FILE_CYCLES   ', clc$nominal_entry, clc$normal_usage_entry, 32,
        clc$automatically_log, clc$linked_call, ^pup$restore_excluded_cycles_cm],
  {} ['RESTORE_EXISTING_CATALOG       ', clc$nominal_entry, clc$normal_usage_entry, 33,
        clc$automatically_log, clc$linked_call, ^pup$restore_existing_catalog_cm],
  {} ['RESTORE_EXISTING_FILE          ', clc$nominal_entry, clc$normal_usage_entry, 34,
        clc$manually_log, clc$linked_call, ^pup$restore_existing_file_cm],
  {} ['RESTORE_FILE                   ', clc$nominal_entry, clc$normal_usage_entry, 35,
        clc$manually_log, clc$linked_call, ^pup$restore_file_command],
  {} ['RESTORE_MISSING_CATALOG        ', clc$alias_entry, clc$normal_usage_entry, 37,
        clc$automatically_log, clc$linked_call, ^pup$restore_missing_catalogs_cm],
  {} ['RESTORE_MISSING_CATALOGS       ', clc$nominal_entry, clc$normal_usage_entry, 37,
        clc$automatically_log, clc$linked_call, ^pup$restore_missing_catalogs_cm],
  {} ['RESTORE_OBJECT                 ', clc$alias_entry, clc$normal_usage_entry, 36,
        clc$automatically_log, clc$linked_call, ^pup$restore_object_command],
  {} ['RESTORE_OBJECTS                ', clc$nominal_entry, clc$normal_usage_entry, 36,
        clc$automatically_log, clc$linked_call, ^pup$restore_object_command],
  {} ['SEARCH_DATA_FILE               ', clc$nominal_entry, clc$advanced_usage_entry, 38,
        clc$automatically_log, clc$linked_call, ^pup$search_data_file],
  {} ['SELECT_ADVISE_IN               ', clc$nominal_entry, clc$advanced_usage_entry, 39,
        clc$automatically_log, clc$linked_call, ^pup$select_advise_in_cmd],
  {} ['SETLO                          ', clc$abbreviation_entry, clc$normal_usage_entry, 40,
        clc$automatically_log, clc$linked_call, ^pup$set_list_options_command],
  {} ['SETRMC                         ', clc$abbreviation_entry, clc$normal_usage_entry, 42,
        clc$automatically_log, clc$linked_call, ^pup$set_restore_missing_catalog],
  {} ['SETRO                          ', clc$abbreviation_entry, clc$normal_usage_entry, 41,
        clc$automatically_log, clc$linked_call, ^pup$set_restore_options_command],
  {} ['SET_LIST_OPTION                ', clc$alias_entry, clc$normal_usage_entry, 40,
        clc$automatically_log, clc$linked_call, ^pup$set_list_options_command],
  {} ['SET_LIST_OPTIONS               ', clc$nominal_entry, clc$normal_usage_entry, 40,
        clc$automatically_log, clc$linked_call, ^pup$set_list_options_command],
  {} ['SET_RESTORE_MISSING_CATALOG    ', clc$alias_entry, clc$normal_usage_entry, 42,
        clc$automatically_log, clc$linked_call, ^pup$set_restore_missing_catalog],
  {} ['SET_RESTORE_MISSING_CATALOGS   ', clc$nominal_entry, clc$normal_usage_entry, 42,
        clc$automatically_log, clc$linked_call, ^pup$set_restore_missing_catalog],
  {} ['SET_RESTORE_OPTION             ', clc$alias_entry, clc$normal_usage_entry, 41,
        clc$automatically_log, clc$linked_call, ^pup$set_restore_options_command],
  {} ['SET_RESTORE_OPTIONS            ', clc$nominal_entry, clc$normal_usage_entry, 41,
        clc$automatically_log, clc$linked_call, ^pup$set_restore_options_command]];

  PROCEDURE [XREF] dfp$analyze_server_keypoints
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

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

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

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

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

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

  PROCEDURE [XREF] pup$detach_all_catalogs
    (    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_catalogs_cmnd
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  PROCEDURE [XREF] pup$search_data_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$set_list_options_command
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

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

?? POP ??


{ table restore_function_list type=function section_name=pus$literals scope=local
{ function name=($backup_file, $bf) processor=pup$$backup_file cm=xref a=advertised
{ tablend

?? PUSH (LISTEXT := ON) ??

VAR
  restore_function_list: [STATIC, READ, pus$literals] ^clt$function_processor_table :=
      ^restore_function_list_entries,

  restore_function_list_entries: [STATIC, READ, pus$literals] array [1 .. 2] of
      clt$function_proc_table_entry := [
  {} ['$BACKUP_FILE                   ', clc$nominal_entry, clc$normal_usage_entry, 1,
        clc$linked_call, ^pup$$backup_file],
  {} ['$BF                            ', clc$abbreviation_entry, clc$normal_usage_entry, 1,
        clc$linked_call, ^pup$$backup_file]];

  PROCEDURE [XREF] pup$$backup_file
    (    parameter_list: clt$parameter_list;
     VAR work_area {input, output} : ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);

?? POP ??
?? TITLE := 'P$RESTORE_PERMANENT_FILE ', EJECT ??

  PROCEDURE p$restore_permanent_file
    (VAR status: ost$status);

    VAR
      attributes: array [1 .. 4] of clt$utility_attribute;

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

    attributes [1].key := clc$utility_command_table;
    attributes [1].command_table := restore_command_list;
    attributes [2].key := clc$utility_function_proc_table;
    attributes [2].function_processor_table := restore_function_list;
    attributes [3].key := clc$utility_prompt;
    attributes [3].prompt.value := 'PUR';
    attributes [3].prompt.size := 3;
    attributes [4].key := clc$utility_termination_command;
    attributes [4].termination_command := 'QUIT';

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

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

    clp$end_utility (puc$restore_utility_name, status);

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

  PROCEDURE [XDCL] pup$quit_restore
    (    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, 17, 13, 35, 4, 405],
    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$restore_utility_name, status);

  PROCEND pup$quit_restore;
?? TITLE := '    [XDCL] pup$push_restore_permanent_file ', EJECT ??

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

{ PROCEDURE push_restore_permanent_file (
{   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, 17, 16, 40, 15, 991],
    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;

    p$restore_permanent_file (status);

  PROCEND pup$push_restore_permanent_file;
?? TITLE := '    [XDCL] pup$restore_permanent_file ', EJECT ??

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

{ PROCEDURE restore_permanent_file (
{   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 .. 3] of clt$pdt_parameter_name,
      parameters: array [1 .. 2] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
        default_value: string (5),
      recend,
      type2: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [104, 5, 14, 13, 25, 20, 947],
    clc$command, 3, 2, 0, 0, 0, 0, 2, ''], [
    ['L                              ',clc$abbreviation_entry, 1],
    ['LIST                           ',clc$nominal_entry, 1],
    ['STATUS                         ',clc$nominal_entry, 2]],
    [
{ PARAMETER 1
    [2, 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 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],
    '$LIST'],
{ PARAMETER 2
    [[1, 0, clc$status_type]]];

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

    CONST
      p$list = 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;

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

    p$restore_permanent_file (status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    pup$close_display_file (status);

  PROCEND pup$restore_permanent_file;
?? TITLE := '    pup$display_restore_options_cm', EJECT ??

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

{ PROCEDURE (pup$disro) display_restore_options, disro (
{   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,
    [92, 2, 7, 15, 4, 39, 796],
    clc$command, 1, 1, 0, 0, 0, 0, 1, 'PUP$DISRO'], [
    ['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
      display_string: string (osc$max_name_size + 35),
      ignore_status: ost$status,
      local_rai: boolean,
      shared_queue_name: ost$name;

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

    pup$display_line (' Restore_Options', ignore_status);

    pup$display_blank_lines (1, status);

    IF puv$mass_storage_info.allocation_size = rmc$unspecified_allocation_size THEN
      pup$display_line ('   Allocation_Size               : Unspecified', ignore_status);
    ELSE
      pup$display_integer ('   Allocation_Size               : ', puv$mass_storage_info.allocation_size,
            ignore_status);
    IFEND;

    pup$display_boolean ('   Create_Objects                :', puv$create_objects, ignore_status);

    IF puv$mass_storage_info.mass_storage_class = rmc$unspecified_file_class THEN
      pup$display_line ('   File_Class                    : Unspecified', ignore_status);
    ELSE
      display_string (1, 35) := '   File_Class                    : ';
      display_string (36, 1) := puv$mass_storage_info.mass_storage_class;
      pup$display_line (display_string (1, 36), ignore_status);
    IFEND;

    IF puv$mass_storage_info.initial_volume = rmc$unspecified_vsn THEN
      pup$display_line ('   Initial_Volume                : Unspecified', ignore_status);
    ELSE
      display_string (1, 41) := '   Initial_Volume                :       ';
      display_string (36, 6) := puv$mass_storage_info.initial_volume;
      pup$display_line (display_string (1, 41), ignore_status);
    IFEND;

    pup$display_boolean ('   Replace_Cycle_Data            :', puv$replace_cycle_data, ignore_status);

    pup$display_boolean ('   Require_Matching_Modification :', puv$require_modification_match, ignore_status);

    IF rai_specified THEN
      local_rai := puv$restore_archive_information;
    ELSE
      local_rai := avp$family_administrator () OR avp$system_administrator ();
    IFEND;
    pup$display_boolean ('   Restore_Archive_Information   :', local_rai, ignore_status);

    IF puv$mass_storage_info.shared_queue = pfc$null_shared_queue THEN
      shared_queue_name := pfc$system_shared_queue_name;
    ELSE
      pfp$convert_ord_to_shared_queue (puv$mass_storage_info.shared_queue, shared_queue_name, status);
      IF NOT status.normal THEN
        shared_queue_name := pfc$system_shared_queue_name;
      IFEND;
    IFEND;
    display_string (1, osc$max_name_size + 35) := '   Shared_Queue                  : ';
    display_string (36, osc$max_name_size) := shared_queue_name;
    pup$display_line (display_string (1, osc$max_name_size + 35), ignore_status);

    pup$set_restore_subcmd_defaults (NOT (avp$system_administrator () OR avp$family_administrator ()));
    pup$display_boolean ('   Update_Cycle_Statistics       :', puv$update_cycle_statistics, ignore_status);

    pup$display_boolean ('   Volume_Overflow_Allowed       :', puv$mass_storage_info.volume_overflow_allowed,
          ignore_status);

    pup$display_blank_lines (1, status);

  PROCEND pup$display_restore_options_cm;

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

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

{ PROCEDURE (pup$setro) set_restore_options, setro (
{   allocation_size, as: (BY_NAME) any of
{       key
{         ($unspecified, unspecified, u)
{       keyend
{       integer 16384..16777215
{     anyend = $optional
{   create_objects, co: (BY_NAME) any of
{       key
{         ($unspecified, unspecified, u)
{       keyend
{       boolean
{     anyend = $optional
{   file_class, fc: (BY_NAME) any of
{       key
{         product
{         (service_critical_product, scp)
{         (system_critical_file, scf)
{         (system_permanent_file, spf)
{         (user_permanent_file, upf)
{         ($unspecified, unspecified)
{       keyend
{       name 1..1
{     anyend = $optional
{   initial_volume, iv: (BY_NAME) any of
{       key
{         ($unspecified, unspecified, u)
{       keyend
{       name 1..6
{     anyend = $optional
{   replace_cycle_data, rcd: (BY_NAME) any of
{       key
{         ($unspecified, unspecified, u)
{       keyend
{       boolean
{     anyend = $optional
{   require_matching_modification, rmm: (BY_NAME) any of
{       key
{         ($unspecified, unspecified, u)
{       keyend
{       boolean
{     anyend = $optional
{   restore_archive_information, rai: (BY_NAME) any of
{       key
{         ($unspecified, unspecified, u)
{       keyend
{       boolean
{     anyend = $optional
{   shared_queue, sq: (BY_NAME, ADVANCED) key
{       site_01, site_02, site_03, site_04, site_05, site_06, site_07,
{ site_08, site_09, site_10, site_11
{       site_12, site_13, site_14, site_15, site_16, site_17, site_18,
{ site_19, site_20, site_21, site_22
{       site_23, site_24, site_25
{       (system, s)
{       ($unspecified, unspecified, u)
{     keyend = $optional
{   update_cycle_statistics, ucs: (BY_NAME) any of
{       key
{         ($unspecified, unspecified, u)
{       keyend
{       boolean
{     anyend = $optional
{   volume_overflow_allowed, voa: (BY_NAME) any of
{       key
{         ($unspecified, unspecified, u)
{       keyend
{       boolean
{     anyend = $optional
{   status)

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

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 21] of clt$pdt_parameter_name,
      parameters: array [1 .. 11] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 3] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$integer_type_qualifier,
        recend,
      recend,
      type2: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 3] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
        recend,
      recend,
      type3: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 11] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$name_type_qualifier,
        recend,
      recend,
      type4: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 3] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$name_type_qualifier,
        recend,
      recend,
      type5: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 3] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
        recend,
      recend,
      type6: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 3] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
        recend,
      recend,
      type7: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 3] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
        recend,
      recend,
      type8: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 30] of clt$keyword_specification,
      recend,
      type9: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 3] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
        recend,
      recend,
      type10: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 3] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
        recend,
      recend,
      type11: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [93, 10, 26, 12, 39, 48, 309],
    clc$command, 21, 11, 0, 1, 0, 0, 11, 'PUP$SETRO'], [
    ['ALLOCATION_SIZE                ',clc$nominal_entry, 1],
    ['AS                             ',clc$abbreviation_entry, 1],
    ['CO                             ',clc$abbreviation_entry, 2],
    ['CREATE_OBJECTS                 ',clc$nominal_entry, 2],
    ['FC                             ',clc$abbreviation_entry, 3],
    ['FILE_CLASS                     ',clc$nominal_entry, 3],
    ['INITIAL_VOLUME                 ',clc$nominal_entry, 4],
    ['IV                             ',clc$abbreviation_entry, 4],
    ['RAI                            ',clc$abbreviation_entry, 7],
    ['RCD                            ',clc$abbreviation_entry, 5],
    ['REPLACE_CYCLE_DATA             ',clc$nominal_entry, 5],
    ['REQUIRE_MATCHING_MODIFICATION  ',clc$nominal_entry, 6],
    ['RESTORE_ARCHIVE_INFORMATION    ',clc$nominal_entry, 7],
    ['RMM                            ',clc$abbreviation_entry, 6],
    ['SHARED_QUEUE                   ',clc$nominal_entry, 8],
    ['SQ                             ',clc$abbreviation_entry, 8],
    ['STATUS                         ',clc$nominal_entry, 11],
    ['UCS                            ',clc$abbreviation_entry, 9],
    ['UPDATE_CYCLE_STATISTICS        ',clc$nominal_entry, 9],
    ['VOA                            ',clc$abbreviation_entry, 10],
    ['VOLUME_OVERFLOW_ALLOWED        ',clc$nominal_entry, 10]],
    [
{ PARAMETER 1
    [1, 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, 158,
  clc$optional_parameter, 0, 0],
{ PARAMETER 2
    [4, 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, 141,
  clc$optional_parameter, 0, 0],
{ PARAMETER 3
    [6, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation,
clc$standard_parameter_checking, 439,
  clc$optional_parameter, 0, 0],
{ PARAMETER 4
    [7, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation,
clc$standard_parameter_checking, 143,
  clc$optional_parameter, 0, 0],
{ PARAMETER 5
    [11, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation,
clc$standard_parameter_checking, 141,
  clc$optional_parameter, 0, 0],
{ PARAMETER 6
    [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, 141,
  clc$optional_parameter, 0, 0],
{ PARAMETER 7
    [13, 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, 141,
  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, 1117,
  clc$optional_parameter, 0, 0],
{ PARAMETER 9
    [19, 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, 141,
  clc$optional_parameter, 0, 0],
{ PARAMETER 10
    [21, 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, 141,
  clc$optional_parameter, 0, 0],
{ PARAMETER 11
    [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$union_type], [[clc$integer_type, clc$keyword_type],
    FALSE, 2],
    118, [[1, 0, clc$keyword_type], [3], [
      ['$UNSPECIFIED                   ', clc$nominal_entry,
clc$normal_usage_entry, 1],
      ['U                              ', clc$abbreviation_entry,
clc$normal_usage_entry, 1],
      ['UNSPECIFIED                    ', clc$alias_entry,
clc$normal_usage_entry, 1]]
      ],
    20, [[1, 0, clc$integer_type], [16384, 16777215, 10]]
    ],
{ PARAMETER 2
    [[1, 0, clc$union_type], [[clc$boolean_type, clc$keyword_type],
    FALSE, 2],
    118, [[1, 0, clc$keyword_type], [3], [
      ['$UNSPECIFIED                   ', clc$nominal_entry,
clc$normal_usage_entry, 1],
      ['U                              ', clc$abbreviation_entry,
clc$normal_usage_entry, 1],
      ['UNSPECIFIED                    ', clc$alias_entry,
clc$normal_usage_entry, 1]]
      ],
    3, [[1, 0, clc$boolean_type]]
    ],
{ PARAMETER 3
    [[1, 0, clc$union_type], [[clc$keyword_type, clc$name_type],
    FALSE, 2],
    414, [[1, 0, clc$keyword_type], [11], [
      ['$UNSPECIFIED                   ', clc$nominal_entry,
clc$normal_usage_entry, 6],
      ['PRODUCT                        ', clc$nominal_entry,
clc$normal_usage_entry, 1],
      ['SCF                            ', clc$abbreviation_entry,
clc$normal_usage_entry, 3],
      ['SCP                            ', clc$abbreviation_entry,
clc$normal_usage_entry, 2],
      ['SERVICE_CRITICAL_PRODUCT       ', clc$nominal_entry,
clc$normal_usage_entry, 2],
      ['SPF                            ', clc$abbreviation_entry,
clc$normal_usage_entry, 4],
      ['SYSTEM_CRITICAL_FILE           ', clc$nominal_entry,
clc$normal_usage_entry, 3],
      ['SYSTEM_PERMANENT_FILE          ', clc$nominal_entry,
clc$normal_usage_entry, 4],
      ['UNSPECIFIED                    ', clc$abbreviation_entry,
clc$normal_usage_entry, 6],
      ['UPF                            ', clc$abbreviation_entry,
clc$normal_usage_entry, 5],
      ['USER_PERMANENT_FILE            ', clc$nominal_entry,
clc$normal_usage_entry, 5]]
      ],
    5, [[1, 0, clc$name_type], [1, 1]]
    ],
{ PARAMETER 4
    [[1, 0, clc$union_type], [[clc$keyword_type, clc$name_type],
    FALSE, 2],
    118, [[1, 0, clc$keyword_type], [3], [
      ['$UNSPECIFIED                   ', clc$nominal_entry,
clc$normal_usage_entry, 1],
      ['U                              ', clc$abbreviation_entry,
clc$normal_usage_entry, 1],
      ['UNSPECIFIED                    ', clc$alias_entry,
clc$normal_usage_entry, 1]]
      ],
    5, [[1, 0, clc$name_type], [1, 6]]
    ],
{ PARAMETER 5
    [[1, 0, clc$union_type], [[clc$boolean_type, clc$keyword_type],
    FALSE, 2],
    118, [[1, 0, clc$keyword_type], [3], [
      ['$UNSPECIFIED                   ', clc$nominal_entry,
clc$normal_usage_entry, 1],
      ['U                              ', clc$abbreviation_entry,
clc$normal_usage_entry, 1],
      ['UNSPECIFIED                    ', clc$alias_entry,
clc$normal_usage_entry, 1]]
      ],
    3, [[1, 0, clc$boolean_type]]
    ],
{ PARAMETER 6
    [[1, 0, clc$union_type], [[clc$boolean_type, clc$keyword_type],
    FALSE, 2],
    118, [[1, 0, clc$keyword_type], [3], [
      ['$UNSPECIFIED                   ', clc$nominal_entry,
clc$normal_usage_entry, 1],
      ['U                              ', clc$abbreviation_entry,
clc$normal_usage_entry, 1],
      ['UNSPECIFIED                    ', clc$alias_entry,
clc$normal_usage_entry, 1]]
      ],
    3, [[1, 0, clc$boolean_type]]
    ],
{ PARAMETER 7
    [[1, 0, clc$union_type], [[clc$boolean_type, clc$keyword_type],
    FALSE, 2],
    118, [[1, 0, clc$keyword_type], [3], [
      ['$UNSPECIFIED                   ', clc$nominal_entry,
clc$normal_usage_entry, 1],
      ['U                              ', clc$abbreviation_entry,
clc$normal_usage_entry, 1],
      ['UNSPECIFIED                    ', clc$alias_entry,
clc$normal_usage_entry, 1]]
      ],
    3, [[1, 0, clc$boolean_type]]
    ],
{ PARAMETER 8
    [[1, 0, clc$keyword_type], [30], [
    ['$UNSPECIFIED                   ', clc$nominal_entry,
clc$normal_usage_entry, 27],
    ['S                              ', clc$abbreviation_entry,
clc$normal_usage_entry, 26],
    ['SITE_01                        ', clc$nominal_entry,
clc$normal_usage_entry, 1],
    ['SITE_02                        ', clc$nominal_entry,
clc$normal_usage_entry, 2],
    ['SITE_03                        ', clc$nominal_entry,
clc$normal_usage_entry, 3],
    ['SITE_04                        ', clc$nominal_entry,
clc$normal_usage_entry, 4],
    ['SITE_05                        ', clc$nominal_entry,
clc$normal_usage_entry, 5],
    ['SITE_06                        ', clc$nominal_entry,
clc$normal_usage_entry, 6],
    ['SITE_07                        ', clc$nominal_entry,
clc$normal_usage_entry, 7],
    ['SITE_08                        ', clc$nominal_entry,
clc$normal_usage_entry, 8],
    ['SITE_09                        ', clc$nominal_entry,
clc$normal_usage_entry, 9],
    ['SITE_10                        ', clc$nominal_entry,
clc$normal_usage_entry, 10],
    ['SITE_11                        ', clc$nominal_entry,
clc$normal_usage_entry, 11],
    ['SITE_12                        ', clc$nominal_entry,
clc$normal_usage_entry, 12],
    ['SITE_13                        ', clc$nominal_entry,
clc$normal_usage_entry, 13],
    ['SITE_14                        ', clc$nominal_entry,
clc$normal_usage_entry, 14],
    ['SITE_15                        ', clc$nominal_entry,
clc$normal_usage_entry, 15],
    ['SITE_16                        ', clc$nominal_entry,
clc$normal_usage_entry, 16],
    ['SITE_17                        ', clc$nominal_entry,
clc$normal_usage_entry, 17],
    ['SITE_18                        ', clc$nominal_entry,
clc$normal_usage_entry, 18],
    ['SITE_19                        ', clc$nominal_entry,
clc$normal_usage_entry, 19],
    ['SITE_20                        ', clc$nominal_entry,
clc$normal_usage_entry, 20],
    ['SITE_21                        ', clc$nominal_entry,
clc$normal_usage_entry, 21],
    ['SITE_22                        ', clc$nominal_entry,
clc$normal_usage_entry, 22],
    ['SITE_23                        ', clc$nominal_entry,
clc$normal_usage_entry, 23],
    ['SITE_24                        ', clc$nominal_entry,
clc$normal_usage_entry, 24],
    ['SITE_25                        ', clc$nominal_entry,
clc$normal_usage_entry, 25],
    ['SYSTEM                         ', clc$nominal_entry,
clc$normal_usage_entry, 26],
    ['U                              ', clc$abbreviation_entry,
clc$normal_usage_entry, 27],
    ['UNSPECIFIED                    ', clc$alias_entry, clc$normal_usage_entry
, 27]]
    ],
{ PARAMETER 9
    [[1, 0, clc$union_type], [[clc$boolean_type, clc$keyword_type],
    FALSE, 2],
    118, [[1, 0, clc$keyword_type], [3], [
      ['$UNSPECIFIED                   ', clc$nominal_entry,
clc$normal_usage_entry, 1],
      ['U                              ', clc$abbreviation_entry,
clc$normal_usage_entry, 1],
      ['UNSPECIFIED                    ', clc$alias_entry,
clc$normal_usage_entry, 1]]
      ],
    3, [[1, 0, clc$boolean_type]]
    ],
{ PARAMETER 10
    [[1, 0, clc$union_type], [[clc$boolean_type, clc$keyword_type],
    FALSE, 2],
    118, [[1, 0, clc$keyword_type], [3], [
      ['$UNSPECIFIED                   ', clc$nominal_entry,
clc$normal_usage_entry, 1],
      ['U                              ', clc$abbreviation_entry,
clc$normal_usage_entry, 1],
      ['UNSPECIFIED                    ', clc$alias_entry,
clc$normal_usage_entry, 1]]
      ],
    3, [[1, 0, clc$boolean_type]]
    ],
{ PARAMETER 11
    [[1, 0, clc$status_type]]];

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

    CONST
      p$allocation_size = 1,
      p$create_objects = 2,
      p$file_class = 3,
      p$initial_volume = 4,
      p$replace_cycle_data = 5,
      p$require_matching_modification = 6,
      p$restore_archive_information = 7,
      p$shared_queue = 8,
      p$update_cycle_statistics = 9,
      p$volume_overflow_allowed = 10,
      p$status = 11;

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

    VAR
      caller_id: ost$caller_identifier,
      display_string: string (osc$max_name_size + 18),
      file_class: rmt$mass_storage_class,
      ignore_status: ost$status,
      local_co: boolean,
      local_mass_storage_info: fmt$mass_storage_request_info,
      local_rai: boolean,
      local_rcd: boolean,
      local_ucs: boolean;

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

    local_mass_storage_info := puv$mass_storage_info;

    IF pvt [p$allocation_size].specified THEN
      IF pvt [p$allocation_size].value^.kind = clc$keyword THEN
        local_mass_storage_info.allocation_size := rmc$unspecified_allocation_size;
      ELSE
        local_mass_storage_info.allocation_size := pvt [p$allocation_size].value^.integer_value.value;
      IFEND;
    IFEND;

    IF pvt [p$file_class].specified THEN
      IF pvt [p$file_class].value^.kind = clc$keyword THEN
        IF pvt [p$file_class].value^.keyword_value = '$UNSPECIFIED' THEN
          file_class := rmc$unspecified_file_class;
        ELSE
          rmp$convert_keyword_to_class (pvt [p$file_class].value^.keyword_value, file_class, status);
          IF NOT status.normal THEN
            RETURN; {----->
          IFEND;
        IFEND;
        local_mass_storage_info.mass_storage_class := file_class;
      ELSE
        local_mass_storage_info.mass_storage_class := pvt [p$file_class].value^.name_value (1);
      IFEND;
    IFEND;

    IF pvt [p$initial_volume].specified THEN
      IF pvt [p$initial_volume].value^.kind = clc$keyword THEN
        local_mass_storage_info.initial_volume := rmc$unspecified_vsn;
      ELSE
        local_mass_storage_info.initial_volume := pvt [p$initial_volume].value^.name_value (1, 6);
      IFEND;
    IFEND;

    IF pvt [p$shared_queue].specified THEN
      IF (pvt [p$shared_queue].value^.keyword_value = '$UNSPECIFIED') OR
            (pvt [p$shared_queue].value^.keyword_value = 'SYSTEM') THEN
        local_mass_storage_info.shared_queue := pfc$null_shared_queue;
      ELSE
        pfp$convert_shared_queue_to_ord (pvt [p$shared_queue].value^.keyword_value,
              local_mass_storage_info.shared_queue, status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
      IFEND;
    IFEND;

    IF pvt [p$volume_overflow_allowed].specified THEN
      IF pvt [p$volume_overflow_allowed].value^.kind = clc$keyword THEN
        local_mass_storage_info.volume_overflow_allowed := TRUE;
      ELSE
        local_mass_storage_info.volume_overflow_allowed := pvt [p$volume_overflow_allowed].value^.
              boolean_value.value;
      IFEND;
    IFEND;

    #CALLER_ID (caller_id);
    rmp$build_mass_storage_info (local_mass_storage_info.allocation_size,
          local_mass_storage_info.estimated_file_size, local_mass_storage_info.initial_volume,
          local_mass_storage_info.mass_storage_class, local_mass_storage_info.shared_queue,
          local_mass_storage_info.transfer_size, local_mass_storage_info.volume_overflow_allowed,
          caller_id.ring, ^local_mass_storage_info, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF pvt [p$create_objects].specified THEN
      IF pvt [p$create_objects].value^.kind = clc$keyword THEN
        local_co := TRUE;
      ELSE
        local_co := pvt [p$create_objects].value^.boolean_value.value;
      IFEND;
    ELSE
      local_co := puv$create_objects;
    IFEND;

    IF pvt [p$replace_cycle_data].specified THEN
      IF pvt [p$replace_cycle_data].value^.kind = clc$keyword THEN
        local_rcd := FALSE;
      ELSE
        local_rcd := pvt [p$replace_cycle_data].value^.boolean_value.value;
      IFEND;
    ELSE
      local_rcd := puv$replace_cycle_data;
    IFEND;

    IF (NOT local_co) AND (NOT local_rcd) THEN
      osp$set_status_abnormal (puc$pf_utility_id, pue$create_replace_conflict, '', status);
      RETURN; {----->
    IFEND;

    IF pvt [p$update_cycle_statistics].specified THEN
      IF pvt [p$update_cycle_statistics].value^.kind = clc$keyword THEN
        local_ucs := FALSE;
      ELSE
        local_ucs := pvt [p$update_cycle_statistics].value^.boolean_value.value;
      IFEND;
    ELSE
      local_ucs := puv$update_cycle_statistics;
    IFEND;

    IF pvt [p$restore_archive_information].specified AND (pvt [p$restore_archive_information].value^.kind <>
          clc$keyword) AND pvt [p$restore_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_rai_true, '', status);
      RETURN; {----->
    IFEND;

    IF pvt [p$restore_archive_information].specified THEN
      IF pvt [p$restore_archive_information].value^.kind = clc$keyword THEN
        local_rai := avp$family_administrator () OR avp$system_administrator ();
      ELSE
        local_rai := pvt [p$restore_archive_information].value^.boolean_value.value;
      IFEND;
    ELSE
      IF rai_specified THEN
        local_rai := puv$restore_archive_information;
      ELSE
        local_rai := avp$family_administrator () OR avp$system_administrator ();
      IFEND;
    IFEND;

    IF (pvt [p$restore_archive_information].specified OR pvt [p$update_cycle_statistics].specified) AND
          (local_rai AND local_ucs) THEN
      osp$set_status_abnormal (puc$pf_utility_id, pue$ucs_rai_conflict, '', status);
      RETURN; {----->
    IFEND;

    puv$mass_storage_info := local_mass_storage_info;

    pup$display_line (' Set_Restore_Options', ignore_status);
    pup$display_blank_lines (1, status);

    IF pvt [p$allocation_size].specified THEN
      IF pvt [p$allocation_size].value^.kind = clc$keyword THEN
        pup$display_line ('   Allocation_Size : Unspecified', ignore_status);
      ELSE
        pup$display_integer ('   Allocation_Size : ', puv$mass_storage_info.allocation_size, ignore_status);
      IFEND;
    IFEND;

    IF pvt [p$create_objects].specified THEN
      puv$create_objects := local_co;
      IF pvt [p$create_objects].value^.kind = clc$keyword THEN
        pup$display_line ('   Create Objects : Unspecified', ignore_status);
      ELSE
        pup$display_boolean ('   Create Objects : ', puv$create_objects, ignore_status);
      IFEND;
    IFEND;

    IF pvt [p$replace_cycle_data].specified THEN
      puv$replace_cycle_data := local_rcd;
      IF pvt [p$replace_cycle_data].value^.kind = clc$keyword THEN
        pup$display_line ('   Replace Cycle Data : Unspecified', ignore_status);
      ELSE
        pup$display_boolean ('   Replace Cycle Data : ', puv$replace_cycle_data, ignore_status);
      IFEND;
      puv$purge_cycle_options.preserve_cycle_entry := puv$replace_cycle_data;
      IF puv$purge_cycle_options.preserve_cycle_entry THEN
        puv$purge_cycle_options.preserve_archive_info := TRUE;
        puv$purge_cycle_options.preserve_file_label := TRUE;
        puv$purge_cycle_options.preserve_modification_date_time := TRUE;
      IFEND;
    IFEND;

    IF pvt [p$file_class].specified THEN
      IF pvt [p$file_class].value^.kind = clc$keyword THEN
        IF pvt [p$file_class].value^.keyword_value = '$UNSPECIFIED' THEN
          pup$display_line ('   File_Class : Unspecified', ignore_status);
        ELSE
          display_string (1, osc$max_name_size + 16) := '   File_Class : ';
          display_string (17, osc$max_name_size) := pvt [p$file_class].value^.keyword_value;
          pup$display_line (display_string (1, osc$max_name_size + 16), ignore_status);
        IFEND;
      ELSE
        display_string (1, 16) := '   File_Class : ';
        display_string (17, 1) := puv$mass_storage_info.mass_storage_class;
        pup$display_line (display_string (1, 17), ignore_status);
      IFEND;
    IFEND;

    IF pvt [p$initial_volume].specified THEN
      IF pvt [p$initial_volume].value^.kind = clc$keyword THEN
        pup$display_line ('   Initial_Volume : Unspecified', ignore_status);
      ELSE
        display_string (1, 26) := '   Initial_Volume :       ';
        display_string (21, 6) := puv$mass_storage_info.initial_volume;
        pup$display_line (display_string (1, 26), ignore_status);
      IFEND;
    IFEND;

    IF pvt [p$require_matching_modification].specified THEN
      IF pvt [p$require_matching_modification].value^.kind = clc$keyword THEN
        puv$require_modification_match := TRUE;
      ELSE
        puv$require_modification_match := pvt [p$require_matching_modification].value^.boolean_value.value;
      IFEND;
      pup$display_boolean ('   Require_Matching_Modification :', puv$require_modification_match,
            ignore_status);
    IFEND;

    IF pvt [p$restore_archive_information].specified THEN
      puv$restore_archive_information := local_rai;
      IF pvt [p$restore_archive_information].value^.kind = clc$keyword THEN
        rai_specified := FALSE;
      ELSE
        rai_specified := TRUE;
      IFEND;
      pup$display_boolean ('   Restore_Archive_Information :', puv$restore_archive_information,
            ignore_status);
    IFEND;

    IF pvt [p$shared_queue].specified THEN
      IF pvt [p$shared_queue].value^.keyword_value = '$UNSPECIFIED' THEN
        pup$display_line ('   Shared_Queue : Unspecified', ignore_status);
      ELSE
        display_string (1, osc$max_name_size + 18) := '   Shared_Queue : ';
        display_string (19, osc$max_name_size) := pvt [p$shared_queue].value^.keyword_value;
        pup$display_line (display_string (1, osc$max_name_size + 18), ignore_status);
      IFEND;
    IFEND;

    IF pvt [p$update_cycle_statistics].specified THEN
      IF pvt [p$update_cycle_statistics].value^.kind = clc$keyword THEN
        update_cycle_statistics_source := utility_default;
        puv$update_cycle_statistics := FALSE;
      ELSE
        update_cycle_statistics_source := set_restore_options_command;
        puv$update_cycle_statistics := local_ucs;
      IFEND;
      pup$display_boolean ('   Update_Cycle_Statistics :', puv$update_cycle_statistics, ignore_status);
    IFEND;

    IF pvt [p$volume_overflow_allowed].specified THEN
      pup$display_boolean ('   Volume_Overflow_Allowed :', puv$mass_storage_info.volume_overflow_allowed,
            ignore_status);
    IFEND;
    pup$display_blank_lines (1, status);

  PROCEND pup$set_restore_options_command;

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

  PROCEDURE [XDCL] pup$set_restore_subcmd_defaults
    (    update_cycle_statistics: boolean);

    IF NOT (update_cycle_statistics_source = set_restore_options_command) THEN
      puv$update_cycle_statistics := update_cycle_statistics;
      update_cycle_statistics_source := subcommand_default;
    IFEND;

  PROCEND pup$set_restore_subcmd_defaults;
?? TITLE := '    [XDCL] pup$trace ', EJECT ??

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

{ PROCEDURE putrace (
{   selection, s: boolean = true
{   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,
        default_value: string (4),
      recend,
      type2: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [104, 5, 17, 13, 42, 57, 519],
    clc$command, 3, 2, 0, 0, 0, 0, 2, ''], [
    ['S                              ',clc$abbreviation_entry, 1],
    ['SELECTION                      ',clc$nominal_entry, 1],
    ['STATUS                         ',clc$nominal_entry, 2]],
    [
{ PARAMETER 1
    [2, 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, 4],
{ 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$boolean_type],
    'true'],
{ PARAMETER 2
    [[1, 0, clc$status_type]]];

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

    CONST
      p$selection = 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;

    puv$trace_selected := pvt [p$selection].value^.boolean_value.value;

  PROCEND pup$trace;
?? OLDTITLE ??
MODEND pum$restore_permanent_files;
