?? RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE Designer Screens - Command Processors' ??
MODULE ofm$designer_screens;
?? RIGHT := 110 ??

{ PURPOSE:
{   This module contains the command processors for the VED UTILITY. This utility allows
{   each site/user to define their own operator displays such as the AJ, IJ or IJD.
{   display.  It also contains the DISPLAY_SITE_VED_NAMES command which displays
{   the names of the current available VED displays.
{
{   This module contains the following command processors::
{       VEDU  utility with the following subcommands:
{           CREATE_UNIT_STATISTIC_DISPLAY
{           CREATE_INITIATED_JOB_DISPLAY
{           CHANGE_INITIATED_JOB_DISPLAY
{           CHANGE_UNIT_STATISTIC_DISPLAY
{           DELETE_DISPLAY
{           DISPLAY_VED_NAMES
{           DISPLAY_VED_DEFINITION
{           DISPLAY_VED_FIELD_DATA
{           QUIT
{
{   Notes:
{       To add a new field that can be displayed on a display:
{              o Add a FIELD_ID to the TYPE oft$field_id (see deck OFT$DESIGNER_SCREENS_TYPES
{              o Make an entry for the field in the FIELD_NAME_ARRAY (see below)
{              o If the field is displayed left justified, add its field_id to
{                   the variable LEFT_JUSTIFIED_FIELDS (see below)
{              o Update the BUILD_LINE procedure in OFM$DESIGNER_SCREENS_R3 to
{                   display the new field.
{              o Update the PDT definitions in OFD$PDT_CREATE_INIT_JOB_DISPLAY and
{                   OFD$PDT_CHANGE_INIT_JOB_DISPLAY.
{

?? NEWTITLE := 'Global Declarations Referenced by This Module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc oss$job_paged_literal
*copyc clc$page_widths
*copyc fsc$max_path_elements
*copyc ofc$condition_limits
*copyc cld$path_description
*copyc ofe$ecc_designer_screens
*copyc amt$page_width
*copyc clt$path_display_chunks
*copyc clt$path_name
*copyc fst$path
*copyc oft$designer_screens_types
*copyc ost$date
*copyc ost$time
*copyc pmt$os_name
?? POP ??
*copyc fip#addl_initialize
*copyc fip#addl_integer
*copyc fip#addl_string
*copyc fip#addl_trimmed_string

*copyc clp$append_status_value_type
*copyc clp$begin_utility
*copyc clp$build_standard_title
*copyc clp$close_display
*copyc clp$convert_integer_to_string
*copyc clp$count_list_elements
*copyc clp$end_include
*copyc clp$end_utility
*copyc clp$evaluate_parameters
*copyc clp$get_work_area
*copyc clp$include_file
*copyc clp$include_line
*copyc clp$new_display_line
*copyc clp$open_display_reference
*copyc clp$put_display
*copyc clp$reset_for_next_display_page
*copyc clp$right_justify_string
*copyc ofp$access_display_description
*copyc ofp$access_ms_display_infos
*copyc ofp$access_unit_stat_descript
*copyc ofp$display_site_ved_names
*copyc ofp$display_ved_field_data
*copyc ofp$purge_incremental_data
*copyc osp$append_status_parameter
*copyc osp$disestablish_cond_handler
*copyc osp$establish_block_exit_hndlr
*copyc osp$set_status_abnormal
*copyc osp$set_status_condition
*copyc clv$nil_display_control
*copyc ofv$displays_initialized
?? OLDTITLE ??
?? NEWTITLE := 'Global Declarations Declared by This Module', EJECT ??

{ The following definitions are used by the CREIJD and CHAIJD command processors to call
{ common command processing routines. The definitions are used to specify the parameter
{ numbers of various parameters, ie. pvt_numbers_list [pn$title] contains p$title where
{ the value of p$title is command dependent.

  CONST
    pn$display_system_line = 0,
    pn$display_blank_lines = 1,
    pn$jobs_per_line = 2,
    pn$job_selection = 3,
    pn$title = 4,
    pn$alias = 5;

{ The following definitions are used by the CREUSD and CHAUSD command processors to call
{ common command processing routines. The definitions are used to specify the parameter
{ numbers of various parameters, ie. pvt_numbers_list [p$us_title] contains p$title where
{ the value of p$title is command dependent.

  CONST
    p$us_display_system_line = 0,
    p$us_display_blank_lines = 1,
    p$us_units_per_line = 2,
    p$us_incremental_reset_freq = 3,
    p$us_title = 4,
    p$us_alias = 5;

  TYPE
    pvt_numbers_list = array [0 .. 5] of 0 .. 255;

{ Utility definitions.

  VAR
    command_file: [STATIC, oss$job_paged_literal, READ] amt$local_file_name := clc$current_command_input,
    utility_name: [STATIC, oss$job_paged_literal, READ] string (31) := 'VIRTUAL_ENVIRO_DISPLAY_UTILITY',
    utility_attributes: [STATIC, oss$job_paged_literal, READ] array
          [1 .. 2] of clt$utility_attribute := [[clc$utility_command_table, ^command_table_entries],
          [clc$utility_prompt, [4, 'VEDU']]];

?? FMT (FORMAT := OFF) ??
{ table command_table
{ command (change_mass_storage_display, chamsd) p=ofp$_change_ms_display
{ command (change_initiated_job_display, chaijd) p=ofp$_change_init_job_display
{ command (change_unit_statistic_display, chausd) p=ofp$_change_unit_stat_display
{ command (create_initiated_job_display, creijd) p=ofp$_create_init_job_display
{ command (create_unit_statistic_display, creusd) p=ofp$_create_unit_stat_display
{ command (delete_display, deld, delete_initiated_job_display, delijd) p=ofp$_delete_init_job_display
{ command (display_mass_storage_display, dismsd) p=ofp$_display_ms_display
{ command (display_ved_field_data, disvfd) p=ofp$_display_ved_field_data a=a
{ command (display_ved_definition, disvd) p=ofp$_display_ved_definition
{ command (display_ved_names, display_site_ved_names, disvn, dissvn) p=ofp$_display_site_ved_names
{ command (purge_incremental_data, purid) p=ofp$_purge_incremental_data a=a
{ command (reset_mass_storage_display, resmsd) p=ofp$_reset_ms_display
{ command (quit, qui) p=ofp$_quit
{ tablend

?? PUSH (LISTEXT := ON) ??

VAR
  command_table: [STATIC, READ] ^clt$command_table := ^command_table_entries,

  command_table_entries: [STATIC, READ] array [1 .. 30] of clt$command_table_entry := [
  {} ['CHAIJD                         ', clc$abbreviation_entry, clc$normal_usage_entry, 2,
        clc$automatically_log, clc$linked_call, ^ofp$_change_init_job_display],
  {} ['CHAMSD                         ', clc$abbreviation_entry, clc$normal_usage_entry, 1,
        clc$automatically_log, clc$linked_call, ^ofp$_change_ms_display],
  {} ['CHANGE_INITIATED_JOB_DISPLAY   ', clc$nominal_entry, clc$normal_usage_entry, 2,
        clc$automatically_log, clc$linked_call, ^ofp$_change_init_job_display],
  {} ['CHANGE_MASS_STORAGE_DISPLAY    ', clc$nominal_entry, clc$normal_usage_entry, 1,
        clc$automatically_log, clc$linked_call, ^ofp$_change_ms_display],
  {} ['CHANGE_UNIT_STATISTIC_DISPLAY  ', clc$nominal_entry, clc$normal_usage_entry, 3,
        clc$automatically_log, clc$linked_call, ^ofp$_change_unit_stat_display],
  {} ['CHAUSD                         ', clc$abbreviation_entry, clc$normal_usage_entry, 3,
        clc$automatically_log, clc$linked_call, ^ofp$_change_unit_stat_display],
  {} ['CREATE_INITIATED_JOB_DISPLAY   ', clc$nominal_entry, clc$normal_usage_entry, 4,
        clc$automatically_log, clc$linked_call, ^ofp$_create_init_job_display],
  {} ['CREATE_UNIT_STATISTIC_DISPLAY  ', clc$nominal_entry, clc$normal_usage_entry, 5,
        clc$automatically_log, clc$linked_call, ^ofp$_create_unit_stat_display],
  {} ['CREIJD                         ', clc$abbreviation_entry, clc$normal_usage_entry, 4,
        clc$automatically_log, clc$linked_call, ^ofp$_create_init_job_display],
  {} ['CREUSD                         ', clc$abbreviation_entry, clc$normal_usage_entry, 5,
        clc$automatically_log, clc$linked_call, ^ofp$_create_unit_stat_display],
  {} ['DELD                           ', clc$alias_entry, clc$normal_usage_entry, 6,
        clc$automatically_log, clc$linked_call, ^ofp$_delete_init_job_display],
  {} ['DELETE_DISPLAY                 ', clc$nominal_entry, clc$normal_usage_entry, 6,
        clc$automatically_log, clc$linked_call, ^ofp$_delete_init_job_display],
  {} ['DELETE_INITIATED_JOB_DISPLAY   ', clc$alias_entry, clc$normal_usage_entry, 6,
        clc$automatically_log, clc$linked_call, ^ofp$_delete_init_job_display],
  {} ['DELIJD                         ', clc$abbreviation_entry, clc$normal_usage_entry, 6,
        clc$automatically_log, clc$linked_call, ^ofp$_delete_init_job_display],
  {} ['DISMSD                         ', clc$abbreviation_entry, clc$normal_usage_entry, 7,
        clc$automatically_log, clc$linked_call, ^ofp$_display_ms_display],
  {} ['DISPLAY_MASS_STORAGE_DISPLAY   ', clc$nominal_entry, clc$normal_usage_entry, 7,
        clc$automatically_log, clc$linked_call, ^ofp$_display_ms_display],
  {} ['DISPLAY_SITE_VED_NAMES         ', clc$alias_entry, clc$normal_usage_entry, 10,
        clc$automatically_log, clc$linked_call, ^ofp$_display_site_ved_names],
  {} ['DISPLAY_VED_DEFINITION         ', clc$nominal_entry, clc$normal_usage_entry, 9,
        clc$automatically_log, clc$linked_call, ^ofp$_display_ved_definition],
  {} ['DISPLAY_VED_FIELD_DATA         ', clc$nominal_entry, clc$normal_usage_entry, 8,
        clc$automatically_log, clc$linked_call, ^ofp$_display_ved_field_data],
  {} ['DISPLAY_VED_NAMES              ', clc$nominal_entry, clc$normal_usage_entry, 10,
        clc$automatically_log, clc$linked_call, ^ofp$_display_site_ved_names],
  {} ['DISSVN                         ', clc$abbreviation_entry, clc$normal_usage_entry, 10,
        clc$automatically_log, clc$linked_call, ^ofp$_display_site_ved_names],
  {} ['DISVD                          ', clc$abbreviation_entry, clc$normal_usage_entry, 9,
        clc$automatically_log, clc$linked_call, ^ofp$_display_ved_definition],
  {} ['DISVFD                         ', clc$abbreviation_entry, clc$normal_usage_entry, 8,
        clc$automatically_log, clc$linked_call, ^ofp$_display_ved_field_data],
  {} ['DISVN                          ', clc$alias_entry, clc$normal_usage_entry, 10,
        clc$automatically_log, clc$linked_call, ^ofp$_display_site_ved_names],
  {} ['PURGE_INCREMENTAL_DATA         ', clc$nominal_entry, clc$normal_usage_entry, 11,
        clc$automatically_log, clc$linked_call, ^ofp$_purge_incremental_data],
  {} ['PURID                          ', clc$abbreviation_entry, clc$normal_usage_entry, 11,
        clc$automatically_log, clc$linked_call, ^ofp$_purge_incremental_data],
  {} ['QUI                            ', clc$abbreviation_entry, clc$normal_usage_entry, 13,
        clc$automatically_log, clc$linked_call, ^ofp$_quit],
  {} ['QUIT                           ', clc$nominal_entry, clc$normal_usage_entry, 13,
        clc$automatically_log, clc$linked_call, ^ofp$_quit],
  {} ['RESET_MASS_STORAGE_DISPLAY     ', clc$nominal_entry, clc$normal_usage_entry, 12,
        clc$automatically_log, clc$linked_call, ^ofp$_reset_ms_display],
  {} ['RESMSD                         ', clc$abbreviation_entry, clc$normal_usage_entry, 12,
        clc$automatically_log, clc$linked_call, ^ofp$_reset_ms_display]];

?? POP ??
?? FMT (FORMAT := ON) ??
?? TITLE := 'Parameter Table', EJECT ??

{
{ The following table defines display field names and default attributes for fields that
{ that can appear on displays.
{
{ Each entry in the table contains the following information:
{    o Name - MUST match the name defined in the command PDTs.
{    o Name abbreviation - MUST match the abbreviation defined in the command PDTs.
{    o Internal identifier for the field - ordinal type specified by OFT$FIELD_ID.
{    o Default field width.
{    o Default field scale. Numeric fields are divided by this number before being
{        displayed. For example, a value of 1000000 will convert an internal field
{        kept in microsecond to a displayed value in seconds.
{        Non-numeric fields must specify a value of ZERO.
{    o Boolean that indicated whether the field may be displayed
{        incrementally, ie., each time the field is displayed, the incremental change
{        in the field value is displayed.
{

  TYPE
    field_name_array_entry = record
      field_name: ost$name,
      field_name_abbrev: string (4),
      field_id: oft$field_id,
      default_width: 0 .. ofc$max_display_width,
      default_scale: oft$scale_divisor,
      incremental: boolean,
    recend;


  TYPE
    field_name_array_index = 1 .. 49;

{ The following set specifies the fields that are displayed left-justified.

  VAR
    left_justified_fields: [STATIC, oss$job_paged_literal, READ] set of oft$field_id :=
          [ofc$fi_ssn_full, ofc$fi_ssn_long, ofc$fi_ssn_short, ofc$fi_fill, ofc$fi_display_message,
          ofc$fi_user_job_name, ofc$fi_dispatching_priority, ofc$fi_dispatching_priority_act,
          ofc$fi_terminal_name],


    field_name_array: [STATIC, oss$job_paged_literal, READ] array [field_name_array_index] of
          field_name_array_entry := [
{ } ['ACTIVE_IO_PAGES                ', 'AIP ', ofc$fi_active_io_pages, 4, 1, FALSE],
{ } ['ACTIVE_IO_REQUESTS             ', 'AIR ', ofc$fi_active_io_requests, 4, 1, FALSE],
{ } ['AJL_ORDINAL                    ', 'AJLO', ofc$fi_ajl_ordinal, 4, 1, FALSE],
{ } ['CPU_TIME_INCREMENT             ', 'CTI ', ofc$fi_cp_time_increment, 7, 1000000, TRUE],
{ } ['CPU_TIME_JOB                   ', 'CTJ ', ofc$fi_cp_time_job, 7, 1000000, TRUE],
{ } ['CPU_TIME_MONITOR               ', 'CTM ', ofc$fi_cp_time_monitor, 7, 1000000, TRUE],
{ } ['CPU_TIME_TOTAL                 ', 'CTT ', ofc$fi_cp_time_total, 7, 1000000, TRUE],
{ } ['DISPATCHING_PRIORITY           ', 'DP  ', ofc$fi_dispatching_priority, 4, 0, FALSE],
{ } ['DISPATCHING_PRIORITY_ACTUAL    ', 'DPA ', ofc$fi_dispatching_priority_act, 4, 0, FALSE],
{ } ['DISPLAY_MESSAGE                ', 'DM  ', ofc$fi_display_message, 30, 0, FALSE],
{ } ['FILL                           ', '    ', ofc$fi_fill, 1, 0, FALSE],
{ } ['GUARANTEED_SERVICE_REMAINING   ', 'GSR ', ofc$fi_guaranteed_service_rem, 10, 1, TRUE],
{ } ['HUNG_TASK                      ', 'HT  ', ofc$fi_hung_task_in_job_flag, 3, 0, FALSE],
{ } ['IJL_ORDINAL                    ', 'IJLO', ofc$fi_ijl_ordinal, 4, 1, FALSE],
{ } ['JOB_ABORT_DISPOSITION          ', 'JAD ', ofc$fi_job_abort_disposition, 2, 0, FALSE],
{ } ['JOB_CLASS                      ', 'JC  ', ofc$fi_job_class, 3, 0, FALSE],
{ } ['JOB_ENTRY_STATUS               ', 'JES ', ofc$fi_job_entry_status, 2, 0, FALSE],
{ } ['JOB_MODE                       ', 'JM  ', ofc$fi_job_mode, 3, 0, FALSE],
{ } ['JOB_PRIORITY                   ', 'JP  ', ofc$fi_job_priority, 10, 1, TRUE],
{ } ['JOB_RECOVERY_DISPOSITION       ', 'JRD ', ofc$fi_job_recovery_disposition, 2, 0, FALSE],
{ } ['JOB_STATUS                     ', 'JS  ', ofc$fi_job_status, 3, 0, FALSE],
{ } ['JOB_SWAP_COUNT                 ', 'JSC ', ofc$fi_job_swap_count, 6, 1, TRUE],
{ } ['LAST_THINK_TIME                ', 'LTT ', ofc$fi_last_think_time, 5, 1000000, FALSE],
{ } ['MEMORY_PAGES                   ', 'MP  ', ofc$fi_memory_pages, 5, 1, FALSE],
{ } ['PAGE_FAULT_COUNT               ', 'PFC ', ofc$fi_page_fault_count, 8, 1, TRUE],
{ } ['PERCENT_CPU_USAGE              ', 'PCU ', ofc$fi_percent_cp_usage, 4, 1, TRUE],
{ } ['PERMANENT_FILE_SPACE           ', 'PFS ', ofc$fi_permanent_file_space, 6, 1000000, FALSE],
{ } ['PAGES_ASSIGNED                 ', 'PA  ', ofc$fi_ps_pages_assigned, 8, 1, TRUE],
{ } ['PAGES_SERVER                   ', 'PS  ', ofc$fi_ps_pages_from_server, 8, 1, TRUE],
{ } ['PAGES_RECLAIMED                ', 'PR  ', ofc$fi_ps_pages_reclaimed, 8, 1, TRUE],
{ } ['PAGE_IN                        ', 'PI  ', ofc$fi_ps_page_in, 8, 1, TRUE],
{ } ['READY_TASK_COUNT               ', 'RTC ', ofc$fi_ready_task_count, 3, 1, FALSE],
{ } ['SERVICE_ACCUMULATOR            ', 'SA  ', ofc$fi_service_accumulator, 10, 1, TRUE],
{ } ['SERVICE_CLASS                  ', 'SC  ', ofc$fi_service_class, 3, 0, FALSE],
{ } ['SERVICE_SINCE_SWAP             ', 'SSS ', ofc$fi_service_since_swap, 10, 1, TRUE],
{ } ['SYSTEM_JOB_NAME                ', 'SJN ', ofc$fi_ssn_full, 20, 0, FALSE],
{ } ['SYSTEM_JOB_NAME_LONG           ', 'SJNL', ofc$fi_ssn_long, 10, 0, FALSE],
{ } ['SYSTEM_JOB_NAME_SHORT          ', 'SJNS', ofc$fi_ssn_short, 6, 0, FALSE],
{ } ['SWAP_ENTRY_STATUS              ', 'SES ', ofc$fi_swap_entry_status, 3, 0, FALSE],
{ } ['SWAP_IN_WAIT_TIME              ', 'SIWT', ofc$fi_swap_in_wait_time, 5, 1000000, FALSE],
{ } ['SWAP_REASON                    ', 'SR  ', ofc$fi_swap_reason, 3, 0, FALSE],
{ } ['SWAP_STATUS                    ', 'SS  ', ofc$fi_swap_status, 3, 0, FALSE],
{ } ['TEMPORARY_FILE_SPACE           ', 'TFS ', ofc$fi_temporary_file_space, 6, 1000000, FALSE],
{ } ['TERMINAL_NAME                  ', 'TN  ', ofc$fi_terminal_name, 32, 0, FALSE],
{ } ['THINK_TIME                     ', 'TT  ', ofc$fi_think_time, 5, 1000000, FALSE],
{ } ['THRASHING_FLAG                 ', 'TF  ', ofc$fi_thrashing_flag, 3, 0, FALSE],
{ } ['TIME_IN_SWAP_STATE             ', 'TISS', ofc$fi_time_in_swap_state, 5, 1000000, FALSE],
{ } ['USER_JOB_NAME                  ', 'UJN ', ofc$fi_user_job_name, 9, 0, FALSE],
{ } ['WORKING_SET_SIZE               ', 'WSS ', ofc$fi_working_set_size, 5, 1, FALSE]];

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

{ The following set specifies the fields that are displayed left-justified.

  VAR
    us_left_justified_fields: [STATIC, oss$job_paged_literal, READ] set of oft$us_unit_statistic_key := [
{ } ofc$us_channel,
{ } ofc$us_element_name,
{ } ofc$us_equipment,
{ } ofc$us_fill,
{ } ofc$us_force_format,
{ } ofc$us_last_request_good,
{ } ofc$us_parity_protect_enabled,
{ } ofc$us_parity_protected_device,
{ } ofc$us_recorded_vsn,
{ } ofc$us_restoring_drive,
{ } ofc$us_strm_request_possible,
{ } ofc$us_unit_configured,
{ } ofc$us_unit_disabled,
{ } ofc$us_unit_type,
{ } ofc$us_unit_used,
{ } ofc$us_configured,
{ } ofc$us_entry_interlock,
{ } ofc$us_element_capabilities,
{ } ofc$us_logical_unit_status,
{ } ofc$us_element_access,
{ } ofc$us_unit_shared,
{ } ofc$us_allocation_allowed,
{ } ofc$us_space_low,
{ } ofc$us_space_gone,
{ } ofc$us_disk_table_status,
{ } ofc$us_class,
{ } ofc$us_logged_in_for_recovery,
{ } ofc$us_internal_vsn,
{ } ofc$us_mainframe_assigned,
{ } ofc$us_set_name,
{ } ofc$us_status,
{ } ofc$us_volume_owner,
{ } ofc$us_volume_unavailable,
{ } ofc$us_prev_allocation_allowed,
{ } ofc$us_logging_process_damaged];

{
{ The following table defines display field names for fields that
{ that can appear on Unit Statistics displays.
{
{ Each entry in the table contains the name (MUST match the name defined in the command PDTs)
{ for each Internal identifier:

  TYPE
    t$unit_statistics_field_names = array [oft$us_unit_statistic_key] of ost$name;

  VAR
    unit_statistics_field_names: [STATIC, oss$job_paged_literal, READ] t$unit_statistics_field_names := [
{ OFC$US_FILL                     } 'FILL                           ',
{ OFC$US_AVRG_BYTE_COUNT_PER_REQ  } 'AVERAGE_BYTE_COUNT_PER_REQUEST ',
{ OFC$US_BYTES_PER_MAU            } 'BYTES_PER_MAU                  ',
{ OFC$US_CHANNEL                  } 'CHANNEL                        ',
{ OFC$US_CURRENT_CYLINDER         } 'CURRENT_CYLINDER               ',
{ OFC$US_ELEMENT_NAME             } 'ELEMENT_NAME                   ',
{ OFC$US_EQUIPMENT                } 'EQUIPMENT                      ',
{ OFC$US_FORCE_FORMAT             } 'FORCE_FORMAT                   ',
{ OFC$US_INTERMEDIATE_ERRORS      } 'INTERMEDIATE_ERRORS            ',
{ OFC$US_IOU_NUMBER               } 'IOU_NUMBER                     ',
{ OFC$US_LAST_REQUEST_GOOD        } 'LAST_REQUEST_GOOD              ',
{ OFC$US_LOGICAL_UNIT_NUMBER      } 'LOGICAL_UNIT_NUMBER            ',
{ OFC$US_OFF_LINE_DRIVE_NUMBER    } 'OFF_LINE_DRIVE_NUMBER          ',
{ OFC$US_PARITY_PROTECT_ENABLED   } 'PARITY_PROTECT_ENABLED         ',
{ OFC$US_PARITY_PROTECTED_DEVICE  } 'PARITY_PROTECTED_DEVICE        ',
{ OFC$US_QTIME_PER_READ_REQUEST   } 'QUEUE_TIME_PER_READ_REQUEST    ',
{ OFC$US_QTIME_PER_SWAP_IN_REQ    } 'QUEUE_TIME_PER_SWAP_IN_REQUEST ',
{ OFC$US_QTIME_PER_SWAP_OUT_REQ   } 'QUEUE_TIME_PER_SWAP_OUT_REQUEST',
{ OFC$US_QTIME_PER_TOTAL_REQUEST  } 'QUEUE_TIME_PER_TOTAL_REQUEST   ',
{ OFC$US_QTIME_PER_WRITE_REQUEST  } 'QUEUE_TIME_PER_WRITE_REQUEST   ',
{ OFC$US_READ_MAU_COUNT           } 'READ_MAU_COUNT                 ',
{ OFC$US_READ_QTIME               } 'READ_QUEUE_TIME                ',
{ OFC$US_READ_REQUESTS            } 'READ_REQUESTS                  ',
{ OFC$US_RECORDED_VSN             } 'RECORDED_VSN                   ',
{ OFC$US_RECOVERED_ERRORS         } 'RECOVERED_ERRORS               ',
{ OFC$US_REQUESTS_CAUSE_SKIP_CYL  } 'REQUESTS_CAUSING_SKIPPED_CYL   ',
{ OFC$US_RESTORING_DRIVE          } 'RESTORING_DRIVE                ',
{ OFC$US_SEEKS                    } 'SEEKS                          ',
{ OFC$US_STREAM_REQ_ATTEMPT_TOTAL } 'STREAM_REQUEST_ATTEMPT_TOTAL   ',
{ OFC$US_STREAM_REQ_COUNT_TOTAL   } 'STREAM_REQUEST_COUNT_TOTAL     ',
{ OFC$US_STREAM_REQ_FAILED_TOTAL  } 'STREAM_REQUEST_FAILED_TOTAL    ',
{ OFC$US_STREAMED_SUCCESS         } 'STREAMED_SUCCESS               ',
{ OFC$US_STRM_REQ_COUNT_READ      } 'STREAM_REQUEST_COUNT_READ      ',
{ OFC$US_STRM_REQ_COUNT_WRITE     } 'STREAM_REQUEST_COUNT_WRITE     ',
{ OFC$US_STRM_REQ_FAIL_CNT_READ   } 'STREAM_REQUEST_FAIL_COUNT_READ ',
{ OFC$US_STRM_REQ_FAIL_CNT_WRT    } 'STREAM_REQUEST_FAIL_COUNT_WRITE',
{ OFC$US_STRM_REQUEST_POSSIBLE    } 'STREAM_REQUEST_POSSIBLE        ',
{ OFC$US_SWAP_IN_MAU_COUNT        } 'SWAP_IN_MAU_COUNT              ',
{ OFC$US_SWAP_IN_QTIME            } 'SWAP_IN_QUEUE_TIME             ',
{ OFC$US_SWAP_IN_REQUESTS         } 'SWAP_IN_REQUESTS               ',
{ OFC$US_SWAP_OUT_DATA_MAU_COUNT  } 'SWAP_OUT_DATA_MAU_COUNT        ',
{ OFC$US_SWAP_OUT_DATAPRES_MAUS   } 'SWAP_OUT_DATA_PRESET_MAUS      ',
{ OFC$US_SWAP_OUT_QTIME           } 'SWAP_OUT_QUEUE_TIME            ',
{ OFC$US_SWAP_OUT_REQUESTS        } 'SWAP_OUT_REQUESTS              ',
{ OFC$US_TOTAL_BYTES              } 'TOTAL_BYTES                    ',
{ OFC$US_TOTAL_CYLINDERS_SKIPPED  } 'TOTAL_CYLINDERS_SKIPPED        ',
{ OFC$US_TOTAL_ERRORS             } 'TOTAL_ERRORS                   ',
{ OFC$US_TOTAL_INPUT_BYTES        } 'TOTAL_INPUT_BYTES              ',
{ OFC$US_TOTAL_OUTPUT_BYTES       } 'TOTAL_OUTPUT_BYTES             ',
{ OFC$US_TOTAL_QTIME              } 'TOTAL_QUEUE_TIME               ',
{ OFC$US_TOTAL_REQUESTS           } 'TOTAL_REQUESTS                 ',
{ OFC$US_UNIT_CONFIGURED          } 'UNIT_CONFIGURED                ',
{ OFC$US_UNIT_DISABLED            } 'UNIT_DISABLED                  ',
{ OFC$US_UNIT_TYPE                } 'UNIT_TYPE                      ',
{ OFC$US_UNIT_USED                } 'UNIT_USED                      ',
{ OFC$US_UNRECOVERED_ERRORS       } 'UNRECOVERED_ERRORS             ',
{ OFC$US_WRITE_DATA_MAU_COUNT     } 'WRITE_DATA_MAU_COUNT           ',
{ OFC$US_WRITE_DATAPRES_MAUS      } 'WRITE_DATA_PRESET_MAUS         ',
{ OFC$US_WRITE_QTIME              } 'WRITE_QUEUE_TIME               ',
{ OFC$US_WRITE_REQUESTS           } 'WRITE_REQUESTS                 ',
{ OFC$US_CONFIGURED               } 'CONFIGURED                     ',
{ OFC$US_ENTRY_INTERLOCK          } 'ENTRY_INTERLOCK                ',
{ OFC$US_ELEMENT_CAPABILITIES     } 'ELEMENT_CAPABILITIES           ',
{ OFC$US_LOGICAL_UNIT_STATUS      } 'LOGICAL_UNIT_STATUS            ',
{ OFC$US_ELEMENT_ACCESS           } 'ELEMENT_ACCESS                 ',
{ OFC$US_QUEUE_COUNT              } 'QUEUE_COUNT                    ',
{ OFC$US_UNIT_SHARED              } 'UNIT_SHARED                    ',
{ OFC$US_ALLOCATION_ALLOWED       } 'ALLOCATION_ALLOWED             ',
{ OFC$US_SPACE_LOW                } 'SPACE_LOW                      ',
{ OFC$US_SPACE_GONE               } 'SPACE_GONE                     ',
{ OFC$US_DISK_TABLE_STATUS        } 'DISK_TABLE_STATUS              ',
{ OFC$US_CLASS                    } 'CLASS                          ',
{ OFC$US_SCA_SWAP_FILE_ACTIVITY   } 'SWAP_FILE_ACTIVITY             ',
{ OFC$US_SCA_CRIT_FILE_ACTIVITY   } 'CRITICAL_FILE_ACTIVITY         ',
{ OFC$US_SCA_TEMP_FILE_ACTIVITY   } 'TEMPORARY_FILE_ACTIVITY        ',
{ OFC$US_LOGGED_IN_FOR_RECOVERY   } 'LOGGED_IN_FOR_RECOVERY         ',
{ OFC$US_INTERNAL_VSN             } 'INTERNAL_VSN                   ',
{ OFC$US_MAINFRAME_ASSIGNED       } 'MAINFRAME_ASSIGNED             ',
{ OFC$US_SET_NAME                 } 'SET_NAME                       ',
{ OFC$US_STATUS                   } 'STATUS                         ',
{ OFC$US_VOLUME_OWNER             } 'VOLUME_OWNER                   ',
{ OFC$US_CURRENT_POSITION_N_LOG   } 'CURRENT_POSITION_N_LOG         ',
{ OFC$US_ALLOCATED_LOG_SIZE       } 'ALLOCATED_LOG_SIZE             ',
{ OFC$US_DEVICE_LOG_ENTRY_COUNT   } 'DEVICE_LOG_ENTRY_COUNT         ',
{ OFC$US_VOLUME_UNAVAILABLE       } 'VOLUME_UNAVAILABLE             ',
{ OFC$US_PREV_ALLOCATION_ALLOWED  } 'PREV_ALLOCATION_ALLOWED        ',
{ OFC$US_LOGGING_PROCESS_DAMAGED  } 'LOGGING_PROCESS_DAMAGED        ',
{ OFC$US_BYTES_PER_CYLINDER       } 'BYTES_PER_CYLINDER             ',
{ OFC$US_ALLOCATION_SIZE          } 'ALLOCATION_SIZE                ',
{ OFC$US_TRANSFER_SIZE            } 'TRANSFER_SIZE                  ',
{ OFC$US_NUMBER_DFL_ENTRIES       } 'NUMBER_DFL_ENTRIES             ',
{ OFC$US_NUMBER_DIRECTORY_ENTRIES } 'NUMBER_DIRECTORY_ENTRIES       ',
{ OFC$US_CYLINDERS_PER_DEVICE     } 'CYLINDERS_PER_DEVICE           ',
{ OFC$US_MAUS_PER_CYLINDER        } 'MAUS_PER_CYLINDER              ',
{ OFC$US_MAUS_PER_DAU             } 'MAUS_PER_DAU                   ',
{ OFC$US_SECTORS_PER_MAU          } 'SECTORS_PER_MAU                ',
{ OFC$US_SECTORS_PER_TRACK        } 'SECTORS_PER_TRACK              ',
{ OFC$US_CAPACITY                 } 'CAPACITY                       ',
{ OFC$US_AVAILABLE_MAT_SPACE      } 'AVAILABLE_MAT_SPACE            ',
{ OFC$US_AVAILABLE_DAT_SPACE      } 'AVAILABLE_DAT_SPACE            ',
{ OFC$US_BYTES_PER_DAU            } 'BYTES_PER_DAU                  ',
{ OFC$US_NO_SPACE                 } 'NO_SPACE                       ',
{ OFC$US_NO_FILE_ENTRIES          } 'NO_FILE_ENTRIES                ',
{ OFC$US_REMAINING_BYTES          } 'REMAINING_BYTES                '];

?? EJECT ??
{
{ The following table defines default attributes for fields that
{ that can appear on Unit Statistics displays.
{
{ Each entry in the table contains the following information:
{    o Default field width.
{    o Default field scale. Numeric fields are divided by this number before being
{        displayed. For example, a value of 1000000 will convert an internal field
{        kept in microsecond to a displayed value in seconds.
{        Non-numeric fields must specify a value of ZERO.
{    o Default field incremental.
{    o Boolean that indicated whether the field may be displayed
{        incrementally, ie., each time the field is displayed, the incremental change
{        in the field value is displayed.
{

  TYPE
    t$unit_statistic_default_values = array [oft$us_unit_statistic_key] of t$unit_statistic_default_value,
    t$unit_statistic_default_value = record
      width: 0 .. ofc$max_display_width,
      fraction_width: 0 .. ofc$max_display_width,
      scale: oft$scale_divisor,
      numeric_display_mode: oft$numeric_display_mode,
      numeric_selection_mode: oft$numeric_selection_mode,
      incremental_allowed: boolean,
      title: ost$name,
      field_selections: oft$us_field_selections,
    recend;

  CONST
    c$clock_second = 1000000,
    c$clock_minute = 60 * c$clock_second,
    c$clock_hour = 60 * c$clock_minute,
    c$clock_day = 24 * c$clock_hour;

  VAR
    default_field_selections: [STATIC, oss$job_paged_literal, READ] oft$us_field_selections := [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]];

  VAR
    nil_field_selections: [STATIC, oss$job_paged_literal, READ] oft$us_field_selections := [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]];

  VAR
    unit_statistics_default_values: [STATIC, oss$job_paged_literal, READ] t$unit_statistic_default_values := [
{ OFC$US_FILL                    } [01, 0, 0, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } '', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } - $oft$us_boolean_selector []]],
{ OFC$US_AVRG_BYTE_COUNT_PER_REQ } [10, 0, 1, [ofc$ndm_total], ofc$nsm_incremental, TRUE,
{   TITLE                          } 'AvgB/Req', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_BYTES_PER_MAU           } [06, 0, 1, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'B/MAU', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_CHANNEL                 } [07, 0, 0, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'Channel', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_CURRENT_CYLINDER        } [05, 0, 1, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'C-Cyl', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_ELEMENT_NAME            } [16, 0, 0, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'Element-Name', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_EQUIPMENT               } [02, 0, 1, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'Equipment', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_FORCE_FORMAT            } [06, 0, 0, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'FF', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } $oft$us_boolean_selector [TRUE],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_INTERMEDIATE_ERRORS     } [05, 0, 1, [ofc$ndm_interval, c$clock_day], ofc$nsm_incremental, TRUE,
{   TITLE                          } 'I-Err', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_IOU_NUMBER              } [02, 0, 1, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'IO', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_LAST_REQUEST_GOOD       } [06, 0, 0, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'LReqOK', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_LOGICAL_UNIT_NUMBER     } [03, 0, 1, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'LUN', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_OFF_LINE_DRIVE_NUMBER   } [03, 0, 1, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'OFF', [
{   PARITY_PROTECT_ENABLED_SELECTOR} $oft$us_boolean_selector [FALSE],
{   PARITY_PROTECTED_DEVICE_SELECT } $oft$us_boolean_selector [TRUE],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_PARITY_PROTECT_ENABLED  } [06, 0, 0, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'PP-ON', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } $oft$us_boolean_selector [TRUE],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_PARITY_PROTECTED_DEVICE } [06, 0, 0, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'PP-Dev', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_QTIME_PER_READ_REQUEST  } [10, 0, 1, [ofc$ndm_total], ofc$nsm_incremental, TRUE,
{   TITLE                          } 'Q/Read', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_QTIME_PER_SWAP_IN_REQ   } [10, 0, 1, [ofc$ndm_total], ofc$nsm_incremental, TRUE,
{   TITLE                          } 'Q/SwapIn', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_QTIME_PER_SWAP_OUT_REQ  } [10, 0, 1, [ofc$ndm_total], ofc$nsm_incremental, TRUE,
{   TITLE                          } 'Q/Swapout', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_QTIME_PER_TOTAL_REQUEST } [10, 0, 1, [ofc$ndm_total], ofc$nsm_incremental, TRUE,
{   TITLE                          } 'Q/Total', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_QTIME_PER_WRITE_REQUEST } [10, 0, 1, [ofc$ndm_total], ofc$nsm_incremental, TRUE,
{   TITLE                          } 'Q/Write', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_READ_MAU_COUNT          } [10, 0, 1, [ofc$ndm_interval, c$clock_second], ofc$nsm_incremental, TRUE,
{   TITLE                          } 'R-MauCnt', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_READ_QTIME              } [10, 0, 1, [ofc$ndm_interval, c$clock_second], ofc$nsm_incremental, TRUE,
{   TITLE                          } 'R-QTime', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_READ_REQUESTS           } [10, 0, 1, [ofc$ndm_interval, c$clock_second], ofc$nsm_incremental, TRUE,
{   TITLE                          } 'R-Req', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_RECORDED_VSN            } [07, 0, 0, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'VSN', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } - $oft$us_boolean_selector []]],
{ OFC$US_RECOVERED_ERRORS        } [05, 0, 1, [ofc$ndm_interval, c$clock_day], ofc$nsm_incremental, TRUE,
{   TITLE                          } 'R-Err', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_REQUESTS_CAUSE_SKIP_CYL } [10, 0, 1, [ofc$ndm_interval, c$clock_second], ofc$nsm_incremental, TRUE,
{   TITLE                          } 'Req-Cyl-Sk', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_RESTORING_DRIVE         } [06, 0, 0, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'ResDrv', [
{   PARITY_PROTECT_ENABLED_SELECTOR} $oft$us_boolean_selector [FALSE],
{   PARITY_PROTECTED_DEVICE_SELECT } $oft$us_boolean_selector [TRUE],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_SEEKS                   } [10, 0, 1, [ofc$ndm_total], ofc$nsm_incremental, TRUE,
{   TITLE                          } 'Seeks', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_STREAM_REQ_ATTEMPT_TOTAL} [10, 0, 1, [ofc$ndm_interval, c$clock_second], ofc$nsm_incremental, TRUE,
{   TITLE                          } 'Strm-Att', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_STREAM_REQ_COUNT_TOTAL  } [10, 0, 1, [ofc$ndm_interval, c$clock_second], ofc$nsm_incremental, TRUE,
{   TITLE                          } 'Strm-Cnt', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_STREAM_REQ_FAILED_TOTAL } [10, 0, 1, [ofc$ndm_interval, c$clock_second], ofc$nsm_incremental, TRUE,
{   TITLE                          } 'StrmFail', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_STREAMED_SUCCESS        } [10, 0, 1, [ofc$ndm_interval, c$clock_second], ofc$nsm_incremental, TRUE,
{   TITLE                          } 'StrmSucc', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_STRM_REQ_COUNT_READ     } [10, 0, 1, [ofc$ndm_interval, c$clock_second], ofc$nsm_incremental, TRUE,
{   TITLE                          } 'StrmR-Cnt', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_STRM_REQ_COUNT_WRITE    } [10, 0, 1, [ofc$ndm_interval, c$clock_second], ofc$nsm_incremental, TRUE,
{   TITLE                          } 'StrmW-Cnt', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_STRM_REQ_FAIL_CNT_READ  } [10, 0, 1, [ofc$ndm_interval, c$clock_second], ofc$nsm_incremental, TRUE,
{   TITLE                          } 'StrmRFCR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_STRM_REQ_FAIL_CNT_WRT   } [10, 0, 1, [ofc$ndm_interval, c$clock_second], ofc$nsm_incremental, TRUE,
{   TITLE                          } 'StrmRFCW', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_STRM_REQUEST_POSSIBLE   } [06, 0, 0, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'Strm', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_SWAP_IN_MAU_COUNT       } [10, 0, 1, [ofc$ndm_interval, c$clock_second], ofc$nsm_incremental, TRUE,
{   TITLE                          } 'SiMC', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_SWAP_IN_QTIME           } [10, 0, 1, [ofc$ndm_interval, c$clock_second], ofc$nsm_incremental, TRUE,
{   TITLE                          } 'Swap-InQt', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_SWAP_IN_REQUESTS        } [10, 0, 1, [ofc$ndm_interval, c$clock_second], ofc$nsm_incremental, TRUE,
{   TITLE                          } 'Swap-InR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_SWAP_OUT_DATA_MAU_COUNT } [10, 0, 1, [ofc$ndm_interval, c$clock_second], ofc$nsm_incremental, TRUE,
{   TITLE                          } 'BODMC', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_SWAP_OUT_DATAPRES_MAUS  } [10, 0, 1, [ofc$ndm_interval, c$clock_second], ofc$nsm_incremental, TRUE,
{   TITLE                          } 'SODM', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_SWAP_OUT_QTIME          } [10, 0, 1, [ofc$ndm_interval, c$clock_second], ofc$nsm_incremental, TRUE,
{   TITLE                          } 'Swap-OutQt', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_SWAP_OUT_REQUESTS       } [10, 0, 1, [ofc$ndm_interval, c$clock_second], ofc$nsm_incremental, TRUE,
{   TITLE                          } 'Swap-OutR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_TOTAL_BYTES             } [10, 0, 1, [ofc$ndm_interval, c$clock_second], ofc$nsm_incremental, TRUE,
{   TITLE                          } 'Tot Byte', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_TOTAL_CYLINDERS_SKIPPED } [10, 0, 1, [ofc$ndm_interval, c$clock_second], ofc$nsm_incremental, TRUE,
{   TITLE                          } 'Cyl-Skip', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_TOTAL_ERRORS            } [06, 0, 1, [ofc$ndm_interval, c$clock_day], ofc$nsm_incremental, TRUE,
{   TITLE                          } 'Tot-Err', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_TOTAL_INPUT_BYTES       } [10, 0, 1, [ofc$ndm_interval, c$clock_second], ofc$nsm_incremental, TRUE,
{   TITLE                          } 'Tot InpB', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_TOTAL_OUTPUT_BYTES      } [10, 0, 1, [ofc$ndm_interval, c$clock_second], ofc$nsm_incremental, TRUE,
{   TITLE                          } 'Tot OutB', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_TOTAL_QTIME             } [10, 0, 1, [ofc$ndm_interval, c$clock_second], ofc$nsm_incremental, TRUE,
{   TITLE                          } 'Tot QTime', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_TOTAL_REQUESTS          } [10, 0, 1, [ofc$ndm_interval, c$clock_second], ofc$nsm_incremental, TRUE,
{   TITLE                          } 'Tot Req', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_UNIT_CONFIGURED         } [06, 0, 0, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'Config', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } - $oft$us_boolean_selector []]],
{ OFC$US_UNIT_DISABLED           } [09, 0, 0, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'Down', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } - $oft$us_boolean_selector []]],
{ OFC$US_UNIT_TYPE               } [10, 0, 0, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'Type', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } - $oft$us_boolean_selector []]],
{ OFC$US_UNIT_USED               } [06, 0, 0, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'Used', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } - $oft$us_boolean_selector []]],
{ OFC$US_UNRECOVERED_ERRORS      } [05, 0, 1, [ofc$ndm_interval, c$clock_day], ofc$nsm_incremental, TRUE,
{   TITLE                          } 'U-Err', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_WRITE_DATA_MAU_COUNT    } [10, 0, 1, [ofc$ndm_interval, c$clock_second], ofc$nsm_incremental, TRUE,
{   TITLE                          } 'WDMC', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_WRITE_DATAPRES_MAUS     } [10, 0, 1, [ofc$ndm_interval, c$clock_second], ofc$nsm_incremental, TRUE,
{   TITLE                          } 'WDPM', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_WRITE_QTIME             } [10, 0, 1, [ofc$ndm_interval, c$clock_second], ofc$nsm_incremental, TRUE,
{   TITLE                          } 'WriteQt', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_WRITE_REQUESTS          } [10, 0, 1, [ofc$ndm_interval, c$clock_second], ofc$nsm_incremental, TRUE,
{   TITLE                          } 'WriteR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_CONFIGURED              } [10, 0, 0, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'WriteR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_ENTRY_INTERLOCK         } [10, 0, 0, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'WriteR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_ELEMENT_CAPABILITIES    } [10, 0, 0, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'WriteR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_LOGICAL_UNIT_STATUS     } [10, 0, 0, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'WriteR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_ELEMENT_ACCESS          } [10, 0, 0, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'WriteR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_QUEUE_COUNT             } [10, 0, 1, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'WriteR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_UNIT_SHARED             } [10, 0, 0, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'WriteR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_ALLOCATION_ALLOWED      } [10, 0, 0, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'WriteR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_SPACE_LOW               } [10, 0, 0, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'WriteR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_SPACE_GONE              } [10, 0, 0, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'WriteR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_DISK_TABLE_STATUS       } [10, 0, 0, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'WriteR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_CLASS                   } [10, 0, 0, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'WriteR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_SCA_SWAP_FILE_ACTIVITY  } [10, 0, 0, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'Swap A', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_SCA_CRIT_FILE_ACTIVITY  } [10, 0, 0, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'Crit A', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_SCA_TEMP_FILE_ACTIVITY  } [10, 0, 0, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'Temp A', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_LOGGED_IN_FOR_RECOVERY  } [10, 0, 0, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'Recov', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_INTERNAL_VSN            } [10, 0, 0, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'WriteR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_MAINFRAME_ASSIGNED      } [10, 0, 0, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'WriteR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_SET_NAME                } [10, 0, 0, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'WriteR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_STATUS                  } [10, 0, 0, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'WriteR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_VOLUME_OWNER            } [10, 0, 0, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'WriteR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_CURRENT_POSITION_N_LOG  } [10, 0, 1, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'WriteR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_ALLOCATED_LOG_SIZE      } [10, 0, 1, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'WriteR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_DEVICE_LOG_ENTRY_COUNT  } [10, 0, 1, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'WriteR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_VOLUME_UNAVAILABLE      } [10, 0, 0, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'WriteR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_PREV_ALLOCATION_ALLOWED } [10, 0, 0, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'WriteR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_LOGGING_PROCESS_DAMAGED } [10, 0, 0, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'WriteR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_BYTES_PER_CYLINDER      } [10, 0, 1, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'WriteR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_ALLOCATION_SIZE         } [10, 0, 1, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'WriteR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_TRANSFER_SIZE           } [10, 0, 1, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'WriteR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_NUMBER_DFL_ENTRIES      } [10, 0, 1, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'WriteR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_NUMBER_DIRECTORY_ENTRIES} [10, 0, 1, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'WriteR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_CYLINDERS_PER_DEVICE    } [10, 0, 1, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'WriteR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_MAUS_PER_CYLINDER       } [10, 0, 1, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'WriteR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_MAUS_PER_DAU            } [10, 0, 1, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'WriteR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_SECTORS_PER_MAU         } [10, 0, 1, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'WriteR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_SECTORS_PER_TRACK       } [10, 0, 1, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'WriteR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_CAPACITY                } [10, 0, 1, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'WriteR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_AVAILABLE_MAT_SPACE     } [10, 0, 1, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'WriteR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_AVAILABLE_DAT_SPACE     } [10, 0, 1, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'WriteR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_BYTES_PER_DAU           } [10, 0, 1, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'WriteR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_NO_SPACE                } [10, 0, 0, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'WriteR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_NO_FILE_ENTRIES         } [10, 0, 0, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'WriteR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]],
{ OFC$US_REMAINING_BYTES         } [10, 0, 1, [ofc$ndm_total], ofc$nsm_total, FALSE,
{   TITLE                          } 'WriteR', [
{   PARITY_PROTECT_ENABLED_SELECTOR} - $oft$us_boolean_selector [],
{   PARITY_PROTECTED_DEVICE_SELECT } - $oft$us_boolean_selector [],
{   UNIT_DISABLED_SELECTOR         } $oft$us_boolean_selector [FALSE]]]];

?? TITLE := 'convert_field_id_to_name ', EJECT ??

  PROCEDURE convert_field_id_to_name
    (    field_id: oft$field_id;
     VAR name: ost$name);

    VAR
      i: integer;

    name := '';
    i := UPPERBOUND (field_name_array);
    WHILE (i > 0) AND (field_name_array [i].field_id <> field_id) DO
      i := i - 1;
    WHILEND;

    IF i > 0 THEN
      name := field_name_array [i].field_name;
    IFEND;

  PROCEND convert_field_id_to_name;
?? TITLE := 'convert_field_name_to_id ', EJECT ??

{ PURPOSE:
{    This procedure converts a string value of a field name to its ordinal value.
{ INPUT:
{    name: ascii value of the field name
{ OUTPUT:
{    field_id: ordinal value of the field name
{    fna_index: index into the FIELD_NAME_ARRAY of the entry for this field.
{    status: ofe$unknown_field_name
{


  PROCEDURE convert_field_name_to_id
    (    name: ost$name;
     VAR field_id: oft$field_id;
     VAR fna_index: field_name_array_index;
     VAR status: ost$status);

    VAR
      i: integer;

    status.normal := TRUE;
    i := UPPERBOUND (field_name_array);
    WHILE (i > 0) AND (field_name_array [i].field_name <> name) AND
          (field_name_array [i].field_name_abbrev <> name) DO
      i := i - 1;
    WHILEND;

    IF i = 0 THEN
      osp$set_status_abnormal ('OF', ofe$unknown_field_name, name, status);
    ELSE
      fna_index := i;
      field_id := field_name_array [i].field_id;
    IFEND;

  PROCEND convert_field_name_to_id;
?? TITLE := 'conv_field_name_to_descr_index ', EJECT ??

{ PURPOSE:
{    This procedure searches a display description for a field_id. If the field_id
{    is found, the index to the entry is returned.
{ INPUT:
{    name: ascii value of the field name
{    dd_p: pointer to the display description to be searched
{    field_count: number of field entries in dd_p that are actually in use.
{    start_search_index: index in dd_p of where to start the search
{ OUTPUT:
{    field_index: dd_p index to the field entry specified by <name>.
{    status: ofe$unknown_field_name
{            ofe$field_name_not_in_display


  PROCEDURE conv_field_name_to_descr_index
    (    name: ost$name;
         dd_p: ^oft$display_description;
         field_count: oft$field_count;
         start_search_index: oft$field_index;
     VAR field_index: oft$field_index;
     VAR status: ost$status);

    VAR
      field_id: oft$field_id,
      fna_index: field_name_array_index;

    status.normal := TRUE;

    convert_field_name_to_id (name, field_id, fna_index, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    field_index := start_search_index;
    WHILE (field_index <= field_count) DO
      IF dd_p^.fields [field_index].field_id = field_id THEN
        RETURN; {----->
      IFEND;
      field_index := field_index + 1;
    WHILEND;

    osp$set_status_abnormal ('OF', ofe$field_name_not_in_display, name, status);

  PROCEND conv_field_name_to_descr_index;
?? TITLE := 'convert_us_field_id_to_name ', EJECT ??

  PROCEDURE convert_us_field_id_to_name
    (    field_id: oft$us_unit_statistic_key;
     VAR name: ost$name);

    IF (field_id < LOWERBOUND (unit_statistics_field_names))
{ } OR (field_id > UPPERBOUND (unit_statistics_field_names)) THEN
      name := '';
    ELSE
      name := unit_statistics_field_names [field_id];
    IFEND;

  PROCEND convert_us_field_id_to_name;
?? TITLE := 'convert_us_field_name_to_id ', EJECT ??

{ PURPOSE:
{    This procedure converts a string value of a field name to its ordinal value.
{ INPUT:
{    name: ascii value of the field name
{ OUTPUT:
{    field_id: ordinal value of the field name
{    fna_index: index into the FIELD_NAME_ARRAY of the entry for this field.
{    status: ofe$unknown_field_name
{

  PROCEDURE convert_us_field_name_to_id
    (    name: ost$name;
     VAR field_id: oft$us_unit_statistic_key;
     VAR status: ost$status);

    VAR
      i: integer;

    status.normal := TRUE;
    i := UPPERBOUND (unit_statistics_field_names);
    FOR field_id := LOWERBOUND (unit_statistics_field_names) TO UPPERBOUND (unit_statistics_field_names) DO
      IF unit_statistics_field_names [field_id] = name THEN
        RETURN; {----->
      IFEND;
    FOREND;

    osp$set_status_abnormal ('OF', ofe$unknown_field_name, name, status);

  PROCEND convert_us_field_name_to_id;
?? TITLE := 'conv_us_field_name_to_desc_idx ', EJECT ??

{ PURPOSE:
{    This procedure searches a display description for a field_id. If the field_id
{    is found, the index to the entry is returned.
{ INPUT:
{    name: ascii value of the field name
{    dd_p: pointer to the display description to be searched
{    field_count: number of field entries in dd_p that are actually in use.
{    start_search_index: index in dd_p of where to start the search
{ OUTPUT:
{    field_index: dd_p index to the field entry specified by <name>.
{    status: ofe$unknown_field_name
{            ofe$field_name_not_in_display

  PROCEDURE conv_us_field_name_to_desc_idx
    (    name: ost$name;
         ud_p: ^oft$unit_stat_display_desc;
         field_count: oft$field_count;
         start_search_index: oft$field_index;
     VAR field_index: oft$field_index;
     VAR status: ost$status);

    VAR
      field_id: oft$us_unit_statistic_key;

    status.normal := TRUE;

    convert_us_field_name_to_id (name, field_id, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    field_index := start_search_index;
    WHILE (field_index <= field_count) DO
      IF ud_p^.fields [field_index].field_id = field_id THEN
        RETURN; {----->
      IFEND;
      field_index := field_index + 1;
    WHILEND;

    osp$set_status_abnormal ('OF', ofe$field_name_not_in_display, name, status);

  PROCEND conv_us_field_name_to_desc_idx;
?? TITLE := 'delete_fields ', EJECT ??

{ PURPOSE:
{    This procedure deletes a range of fields from a display description.
{ INPUT:
{    low_field_name, high_field_name: These parameters define the range of fields
{       to be deleted
{ INPUT/OUTPUT:
{    dd_p: pointer to the display description to be updated
{    field_count: number of field entries in dd_p that are actually in use.
{ OUTPUT:
{    start_field_index: display description index to first field deleted.
{

  PROCEDURE delete_fields
    (    low_field_name: ost$name;
         high_field_name: ost$name;
         dd_p: ^oft$display_description;
     VAR field_count: oft$field_count;
     VAR start_field_index: oft$field_index;
     VAR status: ost$status);


    VAR
      delta: integer,
      end_field_index: oft$field_index,
      field_id: oft$field_id,
      field_index: oft$field_index;

    conv_field_name_to_descr_index (low_field_name, dd_p, field_count, 1, start_field_index, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    conv_field_name_to_descr_index (high_field_name, dd_p, field_count, start_field_index, end_field_index,
          status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    delta := end_field_index - start_field_index + 1;
    FOR field_index := start_field_index TO field_count - delta DO
      dd_p^.fields [field_index] := dd_p^.fields [field_index + delta];
    FOREND;

    field_count := field_count - delta;

  PROCEND delete_fields;
?? OLDTITLE ??
?? TITLE := 'delete_us_fields ', EJECT ??

{ PURPOSE:
{    This procedure deletes a range of fields from a display description.
{ INPUT:
{    low_field_name, high_field_name: These parameters define the range of fields
{       to be deleted
{ INPUT/OUTPUT:
{    dd_p: pointer to the display description to be updated
{    field_count: number of field entries in dd_p that are actually in use.
{ OUTPUT:
{    start_field_index: display description index to first field deleted.
{

  PROCEDURE delete_us_fields
    (    low_field_name: ost$name;
         high_field_name: ost$name;
         ud_p: ^oft$unit_stat_display_desc;
     VAR field_count: oft$field_count;
     VAR start_field_index: oft$field_index;
     VAR status: ost$status);


    VAR
      delta: integer,
      end_field_index: oft$field_index,
      field_id: oft$field_id,
      field_index: oft$field_index;

    conv_us_field_name_to_desc_idx (low_field_name, ud_p, field_count, 1, start_field_index, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    conv_us_field_name_to_desc_idx (high_field_name, ud_p, field_count, start_field_index, end_field_index,
          status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    delta := end_field_index - start_field_index + 1;
    FOR field_index := start_field_index TO field_count - delta DO
      ud_p^.fields [field_index] := ud_p^.fields [field_index + delta];
    FOREND;

    field_count := field_count - delta;

  PROCEND delete_us_fields;
?? OLDTITLE ??
?? NEWTITLE := 'EVALUATE_DISK_STATS_SELECTORS', EJECT ??

  PROCEDURE evaluate_disk_stats_selectors
    (    value_p: ^clt$data_value;
     VAR disk_unit_statistic_selectors: oft$us_unit_stat_selections;
     VAR status: ost$status);

    VAR
      node_p: ^clt$data_value;

?? NEWTITLE := 'EVALUATE_DISK_UNIT_SELECTOR', EJECT ??

    PROCEDURE evaluate_disk_unit_selector
      (    value_p: ^clt$data_value;
       VAR disk_unit_selector: oft$us_unit_stat_selection;
       VAR status: ost$status);

      VAR
        v$ibm_disk_units: [READ, oss$job_paged_literal] oft$us_disk_unit_selector :=
              [ioc$dt_ms47444_1, ioc$dt_ms47444_1p, ioc$dt_ms47444_2, ioc$dt_ms47444_3p, ioc$dt_ms47444_4],
        v$elite_disk_units: [READ, oss$job_paged_literal] oft$us_disk_unit_selector :=
              [ioc$dt_ms5838_1, ioc$dt_ms5838_1p, ioc$dt_ms5838_2, ioc$dt_ms5838_3p, ioc$dt_ms5838_4],
        v$sabre_disk_units: [READ, oss$job_paged_literal] oft$us_disk_unit_selector :=
              [ioc$dt_ms5833_1, ioc$dt_ms5833_1p, ioc$dt_ms5833_2, ioc$dt_ms5833_3p, ioc$dt_ms5833_4],
        v$solid_state_disk_units: [READ, oss$job_paged_literal] oft$us_disk_unit_selector :=
              [ioc$dt_ms5832_1, ioc$dt_ms5832_2],

        v$das_disk_units: [READ, oss$job_paged_literal] oft$us_disk_unit_selector :=
              [ioc$dt_ms5832_1, ioc$dt_ms5832_2, ioc$dt_ms5833_1, ioc$dt_ms5833_1p, ioc$dt_ms5833_2,
              ioc$dt_ms5833_3p, ioc$dt_ms5833_4, ioc$dt_ms5838_1, ioc$dt_ms5838_1p, ioc$dt_ms5838_2,
              ioc$dt_ms5838_3p, ioc$dt_ms5838_4, ioc$dt_ms47444_1, ioc$dt_ms47444_1p, ioc$dt_ms47444_2,
              ioc$dt_ms47444_3p, ioc$dt_ms47444_4],

        v$das_disk_units_1x: [READ, oss$job_paged_literal] oft$us_disk_unit_selector :=
              [ioc$dt_ms5832_1, ioc$dt_ms5833_1, ioc$dt_ms5838_1, ioc$dt_ms47444_1],
        v$das_disk_units_1xp: [READ, oss$job_paged_literal] oft$us_disk_unit_selector :=
              [ioc$dt_ms5833_1p, ioc$dt_ms5838_1p, ioc$dt_ms47444_1p],
        v$das_disk_units_2x: [READ, oss$job_paged_literal] oft$us_disk_unit_selector :=
              [ioc$dt_ms5832_2, ioc$dt_ms5833_2, ioc$dt_ms5838_2, ioc$dt_ms47444_2],
        v$das_disk_units_3xp: [READ, oss$job_paged_literal] oft$us_disk_unit_selector :=
              [ioc$dt_ms5833_3p, ioc$dt_ms5838_3p, ioc$dt_ms47444_3p],
        v$das_disk_units_4x: [READ, oss$job_paged_literal] oft$us_disk_unit_selector :=
              [ioc$dt_ms5833_4, ioc$dt_ms5838_4, ioc$dt_ms47444_4],

        v$parity_protected_units: [READ, oss$job_paged_literal] oft$us_disk_unit_selector :=
              [ioc$dt_ms5833_1p, ioc$dt_ms5833_3p, ioc$dt_ms5838_1p, ioc$dt_ms5838_3p, ioc$dt_ms47444_1p,
              ioc$dt_ms47444_3p],
        v$non_parity_protected_units: [READ, oss$job_paged_literal] oft$us_disk_unit_selector :=
              -$oft$us_disk_unit_selector [ioc$dt_ms5833_1p, ioc$dt_ms5833_3p, ioc$dt_ms5838_1p,
              ioc$dt_ms5838_3p, ioc$dt_ms47444_1p, ioc$dt_ms47444_3p],
        v$non_parity_protect_das_units: [READ, oss$job_paged_literal] oft$us_disk_unit_selector :=
              [ioc$dt_ms5832_1, ioc$dt_ms5832_2, ioc$dt_ms5833_1, ioc$dt_ms5833_2, ioc$dt_ms5833_4,
              ioc$dt_ms5838_1, ioc$dt_ms5838_2, ioc$dt_ms5838_4, ioc$dt_ms47444_1, ioc$dt_ms47444_2,
              ioc$dt_ms47444_4];

{NOTE: The only list value currently is the UNIT_TYPE

      VAR
        disk_unit_selector_p: ^oft$us_disk_unit_selector,
        keyword_p: ^clt$keyword,
        node_p: ^clt$data_value;

      status.normal := TRUE;
      disk_unit_selector.key := ofc$us_unit_type;

{NOTE: currently, we support only disk unit selectors.
      disk_unit_selector_p := ^disk_unit_selector.unit_type_selector;
      disk_unit_selector_p^ := $oft$us_disk_unit_selector [];

      node_p := value_p;
      WHILE (node_p <> NIL) AND (node_p^.kind = clc$list) DO

        IF node_p^.element_value = NIL THEN
          ;
        ELSEIF node_p^.element_value^.kind <> clc$keyword THEN
          osp$set_status_abnormal ('US', ofe$illegal_data_value_kind,
                'Evaluate_Disk_Statistic_Selector Unit_Type', status);
          clp$append_status_value_type (osc$status_parameter_delimiter, node_p^.element_value, status);
          osp$append_status_parameter (osc$status_parameter_delimiter,
                'Disk_Statistic_Selector Disk Unit kind', status);
          RETURN; {----->

        ELSE {keyword
          keyword_p := ^node_p^.element_value^.keyword_value;

          IF keyword_p^ = '$5830' {= 'DAS_DISKS'} THEN
            disk_unit_selector_p^ := disk_unit_selector_p^ +v$das_disk_units;

          ELSEIF keyword_p^ = '$5830_1' {= 'DAS_DISKS_1X'} THEN
            disk_unit_selector_p^ := disk_unit_selector_p^ +v$das_disk_units_1x;

          ELSEIF keyword_p^ = '$5830_1P' {= 'DAS_DISKS_1XP'} THEN
            disk_unit_selector_p^ := disk_unit_selector_p^ +v$das_disk_units_1xp;

          ELSEIF keyword_p^ = '$5830_2' {= 'DAS_DISKS_2X'} THEN
            disk_unit_selector_p^ := disk_unit_selector_p^ +v$das_disk_units_2x;

          ELSEIF keyword_p^ = '$5830_3P' {= 'DAS_DISKS_3XP'} THEN
            disk_unit_selector_p^ := disk_unit_selector_p^ +v$das_disk_units_3xp;

          ELSEIF keyword_p^ = '$5830_4' {= 'DAS_DISKS_4X'} THEN
            disk_unit_selector_p^ := disk_unit_selector_p^ +v$das_disk_units_4x;

          ELSEIF keyword_p^ = '$5838' {= 'ELITE_DISKS'} THEN
            disk_unit_selector_p^ := disk_unit_selector_p^ +v$elite_disk_units;

          ELSEIF keyword_p^ = '$47444' {= 'IBM_DISKS'} THEN
            disk_unit_selector_p^ := disk_unit_selector_p^ +v$ibm_disk_units;

          ELSEIF keyword_p^ = '$5833' {= 'SABRE_DISKS'} THEN
            disk_unit_selector_p^ := disk_unit_selector_p^ +v$sabre_disk_units;

          ELSEIF keyword_p^ = '$5832' {= 'SOLID_STATE_DISKS'} THEN
            disk_unit_selector_p^ := disk_unit_selector_p^ +v$solid_state_disk_units;

          ELSEIF keyword_p^ = 'NON_PARITY_PROTECTED_DAS_DISKS' THEN
            disk_unit_selector_p^ := disk_unit_selector_p^ +v$non_parity_protect_das_units;

          ELSEIF keyword_p^ = 'NON_PARITY_PROTECTED_DISKS' THEN
            disk_unit_selector_p^ := disk_unit_selector_p^ +v$non_parity_protected_units;

          ELSEIF keyword_p^ = 'PARITY_PROTECTED_DISKS' THEN
            disk_unit_selector_p^ := disk_unit_selector_p^ +v$parity_protected_units;

          ELSEIF keyword_p^ = '$844' THEN
            disk_unit_selector_p^ := disk_unit_selector_p^ +$oft$us_disk_unit_selector [ioc$dt_ms844_4x];

          ELSEIF keyword_p^ = '$885_1X' THEN
            disk_unit_selector_p^ := disk_unit_selector_p^ +$oft$us_disk_unit_selector [ioc$dt_ms885_1x];

          ELSEIF keyword_p^ = '$885_42' THEN
            disk_unit_selector_p^ := disk_unit_selector_p^ +$oft$us_disk_unit_selector [ioc$dt_ms885_42];

          ELSEIF keyword_p^ = '$834' THEN
            disk_unit_selector_p^ := disk_unit_selector_p^ +$oft$us_disk_unit_selector [ioc$dt_ms834_2];

          ELSEIF keyword_p^ = '$836' THEN
            disk_unit_selector_p^ := disk_unit_selector_p^ +$oft$us_disk_unit_selector [ioc$dt_msfsd_2];

          ELSEIF keyword_p^ = '$895' THEN
            disk_unit_selector_p^ := disk_unit_selector_p^ +$oft$us_disk_unit_selector [ioc$dt_ms895_2];

          ELSEIF keyword_p^ = '$887' THEN
            disk_unit_selector_p^ := disk_unit_selector_p^ +$oft$us_disk_unit_selector [ioc$dt_mshydra];

          ELSEIF keyword_p^ = '$9836' THEN
            disk_unit_selector_p^ := disk_unit_selector_p^ +$oft$us_disk_unit_selector [ioc$dt_ms9836_1];

          ELSEIF keyword_p^ = '$9853' THEN
            disk_unit_selector_p^ := disk_unit_selector_p^ +$oft$us_disk_unit_selector [ioc$dt_msxmd_3];

          ELSEIF keyword_p^ = '$5832_1' THEN
            disk_unit_selector_p^ := disk_unit_selector_p^ +$oft$us_disk_unit_selector [ioc$dt_ms5832_1];

          ELSEIF keyword_p^ = '$5832_2' THEN
            disk_unit_selector_p^ := disk_unit_selector_p^ +$oft$us_disk_unit_selector [ioc$dt_ms5832_2];

          ELSEIF keyword_p^ = '$5833_1' THEN
            disk_unit_selector_p^ := disk_unit_selector_p^ +$oft$us_disk_unit_selector [ioc$dt_ms5833_1];

          ELSEIF keyword_p^ = '$5833_1P' THEN
            disk_unit_selector_p^ := disk_unit_selector_p^ +$oft$us_disk_unit_selector [ioc$dt_ms5833_1p];

          ELSEIF keyword_p^ = '$5833_2' THEN
            disk_unit_selector_p^ := disk_unit_selector_p^ +$oft$us_disk_unit_selector [ioc$dt_ms5833_2];

          ELSEIF keyword_p^ = '$5833_3P' THEN
            disk_unit_selector_p^ := disk_unit_selector_p^ +$oft$us_disk_unit_selector [ioc$dt_ms5833_3p];

          ELSEIF keyword_p^ = '$5833_4' THEN
            disk_unit_selector_p^ := disk_unit_selector_p^ +$oft$us_disk_unit_selector [ioc$dt_ms5833_4];

          ELSEIF keyword_p^ = '$5838_1' THEN
            disk_unit_selector_p^ := disk_unit_selector_p^ +$oft$us_disk_unit_selector [ioc$dt_ms5838_1];

          ELSEIF keyword_p^ = '$5838_1P' THEN
            disk_unit_selector_p^ := disk_unit_selector_p^ +$oft$us_disk_unit_selector [ioc$dt_ms5838_1p];

          ELSEIF keyword_p^ = '$5838_2' THEN
            disk_unit_selector_p^ := disk_unit_selector_p^ +$oft$us_disk_unit_selector [ioc$dt_ms5838_2];

          ELSEIF keyword_p^ = '$5838_3P' THEN
            disk_unit_selector_p^ := disk_unit_selector_p^ +$oft$us_disk_unit_selector [ioc$dt_ms5838_3p];

          ELSEIF keyword_p^ = '$5838_4' THEN
            disk_unit_selector_p^ := disk_unit_selector_p^ +$oft$us_disk_unit_selector [ioc$dt_ms5838_4];

          ELSEIF keyword_p^ = '$47444_1' THEN
            disk_unit_selector_p^ := disk_unit_selector_p^ +$oft$us_disk_unit_selector [ioc$dt_ms47444_1];

          ELSEIF keyword_p^ = '$47444_1P' THEN
            disk_unit_selector_p^ := disk_unit_selector_p^ +$oft$us_disk_unit_selector [ioc$dt_ms47444_1p];

          ELSEIF keyword_p^ = '$47444_2' THEN
            disk_unit_selector_p^ := disk_unit_selector_p^ +$oft$us_disk_unit_selector [ioc$dt_ms47444_2];

          ELSEIF keyword_p^ = '$47444_3P' THEN
            disk_unit_selector_p^ := disk_unit_selector_p^ +$oft$us_disk_unit_selector [ioc$dt_ms47444_3p];

          ELSEIF keyword_p^ = '$47444_4' THEN
            disk_unit_selector_p^ := disk_unit_selector_p^ +$oft$us_disk_unit_selector [ioc$dt_ms47444_4];

          ELSE
            osp$set_status_abnormal ('US', ofe$illegal_data_value_kind,
                  'Evaluate_Disk_Statistic_Selector Unit_Type', status);
            osp$append_status_parameter (osc$status_parameter_delimiter, keyword_p^, status);
            osp$append_status_parameter (osc$status_parameter_delimiter,
                  'Disk_Statistic_Selector Disk Unit kind', status);
            RETURN; {----->
          IFEND;
        IFEND;

        node_p := node_p^.link;
      WHILEND;

    PROCEND evaluate_disk_unit_selector;
?? OLDTITLE ??
?? NEWTITLE := 'EVALUATE_DISK_STAT_SELECTOR', EJECT ??

    PROCEDURE evaluate_disk_stat_rec_select
      (    value_p: ^clt$data_value;
       VAR disk_unit_stat_selector: oft$us_unit_stat_selection;
       VAR status: ost$status);

{We know, value_p is not NIL and the kind is clc$record.

      VAR
        field_value_p: ^clt$data_value,
        keyword_p: ^clt$keyword;

?? NEWTITLE := 'EVALUATE_BOOLEAN_SELECTOR', EJECT ??

      PROCEDURE evaluate_boolean_selector
        (    value_p: ^clt$data_value;
         VAR boolean_selector: oft$us_boolean_selector);

        IF value_p = NIL THEN
          osp$set_status_abnormal ('US', ofe$illegal_data_value_kind, 'Boolean Selector', status);
          osp$append_status_parameter (osc$status_parameter_delimiter, 'NIL value', status);
          EXIT evaluate_disk_stat_rec_select; {----->

        ELSEIF value_p^.kind <> clc$boolean THEN

          osp$set_status_abnormal ('US', ofe$illegal_data_value_kind, 'Boolean Selector', status);
          clp$append_status_value_type (osc$status_parameter_delimiter, value_p, status);
          EXIT evaluate_disk_stat_rec_select; {----->

        ELSE
          boolean_selector := $oft$us_boolean_selector [value_p^.boolean_value.value];
        IFEND;

      PROCEND evaluate_boolean_selector;
?? OLDTITLE ??
?? NEWTITLE := 'EVALUATE_CHANNEL_SELECTOR', EJECT ??

{Evaluate:
{
{  channel_number: range of integer 0..31
{  channel_port: list of key
{    (unspecified, u)
{    (port_a, pa, a)
{    (port_b, pb, b)
{  keyend = $optional
{  concurrent_channel: boolean = $optional

      PROCEDURE evaluate_channel_selector
        (    number_value_p: ^clt$data_value;
             port_value_p: ^clt$data_value;
             concurrent_value_p: ^clt$data_value;
         VAR channel_selector: oft$us_channel_selector);

?? NEWTITLE := 'EVALUATE_PORT_SELECTOR', EJECT ??

{Evaluate:
{  channel_port: list of key
{    (unspecified, u)
{    (port_a, pa, a)
{    (port_b, pb, b)
{  keyend

        PROCEDURE evaluate_port_selector
          (    value_p: ^clt$data_value;
           VAR port_selector: oft$us_port_selector);

          VAR
            node_p: ^clt$data_value,
            element_value_p: ^clt$data_value;

          port_selector := $oft$us_port_selector [];
          node_p := value_p;

          WHILE (node_p <> NIL) AND (node_p^.kind = clc$list) DO
            element_value_p := node_p^.element_value;

            IF element_value_p = NIL THEN
              ;
            ELSEIF element_value_p^.keyword_value = 'UNSPECIFIED' THEN
              port_selector := port_selector + $oft$us_port_selector [cmc$unspecified_port];

            ELSEIF element_value_p^.keyword_value = 'PORT_A' THEN
              port_selector := port_selector + $oft$us_port_selector [cmc$port_a];

            ELSEIF element_value_p^.keyword_value = 'PORT_B' THEN
              port_selector := port_selector + $oft$us_port_selector [cmc$port_b];
            ELSE
            IFEND;

            node_p := node_p^.link;
          WHILEND;

        PROCEND evaluate_port_selector;
?? OLDTITLE ??
?? EJECT ??

{Channel_Number
        evaluate_integer_selector (number_value_p, channel_selector.number_selector);

{Channel_Port
        IF port_value_p = NIL THEN
          channel_selector.port_selector := -$oft$us_port_selector [];
        ELSE
          evaluate_port_selector (port_value_p, channel_selector.port_selector);
        IFEND;

{Concurrent_Channel
        IF concurrent_value_p = NIL THEN
          channel_selector.concurrent_selector := -$oft$us_boolean_selector [];
        ELSE
          evaluate_boolean_selector (concurrent_value_p, channel_selector.concurrent_selector);
        IFEND;

      PROCEND evaluate_channel_selector;
?? OLDTITLE ??
?? NEWTITLE := 'EVALUATE_INTEGER_SELECTOR', EJECT ??

      PROCEDURE evaluate_integer_selector
        (    value_p: ^clt$data_value;
         VAR integer_selector: oft$us_integer_selector);

        IF value_p = NIL THEN
          osp$set_status_abnormal ('US', ofe$illegal_data_value_kind, 'Integer Selector', status);
          osp$append_status_parameter (osc$status_parameter_delimiter, 'NIL value', status);
          EXIT evaluate_disk_stat_rec_select; {----->

        ELSEIF (value_p^.kind <> clc$range)
{     } OR (value_p^.low_value = NIL)
{     } OR (value_p^.high_value = NIL)
{     } OR (value_p^.low_value^.kind <> clc$integer)
{     } OR (value_p^.high_value^.kind <> clc$integer) THEN

          osp$set_status_abnormal ('US', ofe$illegal_data_value_kind, 'Integer Selector', status);
          IF value_p^.low_value^.kind <> clc$integer THEN
            clp$append_status_value_type (osc$status_parameter_delimiter, value_p^.low_value, status);
          ELSEIF value_p^.high_value^.kind <> clc$integer THEN
            clp$append_status_value_type (osc$status_parameter_delimiter, value_p^.high_value, status);
          ELSE
            clp$append_status_value_type (osc$status_parameter_delimiter, value_p, status);
          IFEND;
          EXIT evaluate_disk_stat_rec_select; {----->

        ELSE
          integer_selector.min_value := value_p^.low_value^.integer_value.value;
          integer_selector.max_value := value_p^.high_value^.integer_value.value;
        IFEND;

      PROCEND evaluate_integer_selector;
?? OLDTITLE ??
?? NEWTITLE := 'EVALUATE_NAME_SELECTOR', EJECT ??

{ Evaluates the following SCL structure into an OFT$US_NAME_SELECTOR.
{
{ value: any of
{   string 1..255
{   name
{ anyend

      PROCEDURE evaluate_name_selector
        (    value_p: ^clt$data_value;
         VAR name_selector: oft$us_name_selector);

        IF value_p = NIL THEN
          osp$set_status_abnormal ('US', ofe$illegal_data_value_kind, 'Name Selector', status);
          osp$append_status_parameter (osc$status_parameter_delimiter, 'NIL value', status);
          EXIT evaluate_disk_stat_rec_select; {----->

        ELSEIF value_p^.kind = clc$name THEN

{Name Selector
          name_selector.kind := ofc$us_name_value;
          name_selector.value := value_p^.name_value;

        ELSEIF value_p^.kind = clc$string THEN

{String (wild-card) Selector
          name_selector.kind := ofc$us_string_selector;
          name_selector.string_selector.upper_case := TRUE; {VSN and Element Names are always upper-case
          name_selector.string_selector.value := value_p^.string_value^;

        ELSE {unsupported SCL type
          osp$set_status_abnormal ('US', ofe$illegal_data_value_kind, 'Evaluate_Disk_Statistic_Selector',
                status);
          osp$append_status_parameter (osc$status_parameter_delimiter, 'Unknown Name Selector', status);
          osp$append_status_parameter (osc$status_parameter_delimiter,
                'Disk_Statistic_Selector list list record', status);
          EXIT evaluate_disk_stat_rec_select; {----->
        IFEND;

      PROCEND evaluate_name_selector;
?? OLDTITLE ??
?? EJECT ??
      status.normal := TRUE;
      IF value_p^.field_values = NIL THEN
        osp$set_status_abnormal ('US', ofe$illegal_data_value_kind, 'Evaluate_Disk_Statistic_Selector',
              status);
        osp$append_status_parameter (osc$status_parameter_delimiter, 'field_values = NIL', status);
        osp$append_status_parameter (osc$status_parameter_delimiter,
              'Disk_Statistic_Selector list list record', status);
        RETURN; {----->

      ELSEIF (UPPERBOUND (value_p^.field_values^) >= 2)
{       } AND (value_p^.field_values^ [1].name = 'KIND')
{       } AND (value_p^.field_values^ [2].name = 'VALUE') THEN

{      set incremental value
        disk_unit_stat_selector.incremental := (UPPERBOUND (value_p^.field_values^) > 2)
{       } AND (value_p^.field_values^ [3].name = 'NUMERIC_SELECTION_MODE')
{       } AND (value_p^.field_values^ [3].value <> NIL)
{       } AND (value_p^.field_values^ [3].value^.keyword_value = 'INCREMENTAL');

        field_value_p := value_p^.field_values^ [1].value;

        IF (field_value_p = NIL) OR (field_value_p^.kind <> clc$keyword) THEN

        ELSE
          keyword_p := ^field_value_p^.keyword_value;
          field_value_p := value_p^.field_values^ [2].value;

          IF keyword_p^ = 'BYTES_PER_MAU                  ' THEN
            disk_unit_stat_selector.key := ofc$us_bytes_per_mau;
            evaluate_integer_selector (field_value_p, disk_unit_stat_selector.bytes_per_mau_selector);

          ELSEIF keyword_p^ = 'CURRENT_CYLINDER               ' THEN
            disk_unit_stat_selector.key := ofc$us_current_cylinder;
            evaluate_integer_selector (field_value_p, disk_unit_stat_selector.current_cylinder_selector);

          ELSEIF keyword_p^ = 'ELEMENT_NAME                   ' THEN
            disk_unit_stat_selector.key := ofc$us_element_name;
            evaluate_name_selector (field_value_p, disk_unit_stat_selector.element_name_selector);

          ELSEIF keyword_p^ = 'EQUIPMENT                      ' THEN
            disk_unit_stat_selector.key := ofc$us_equipment;
            evaluate_integer_selector (field_value_p, disk_unit_stat_selector.equipment_selector);

          ELSEIF keyword_p^ = 'FORCE_FORMAT                   ' THEN
            disk_unit_stat_selector.key := ofc$us_force_format;
            evaluate_boolean_selector (field_value_p, disk_unit_stat_selector.force_format_selector);

          ELSEIF keyword_p^ = 'INTERMEDIATE_ERRORS            ' THEN
            disk_unit_stat_selector.key := ofc$us_intermediate_errors;
            evaluate_integer_selector (field_value_p, disk_unit_stat_selector.intermediate_errors_selector);

          ELSEIF keyword_p^ = 'IOU_NUMBER                     ' THEN
            disk_unit_stat_selector.key := ofc$us_iou_number;
            evaluate_integer_selector (field_value_p, disk_unit_stat_selector.iou_number_selector);

          ELSEIF keyword_p^ = 'LAST_REQUEST_GOOD              ' THEN
            disk_unit_stat_selector.key := ofc$us_last_request_good;
            evaluate_boolean_selector (field_value_p, disk_unit_stat_selector.last_request_good_selector);

          ELSEIF keyword_p^ = 'LOGICAL_UNIT_NUMBER            ' THEN
            disk_unit_stat_selector.key := ofc$us_logical_unit_number;
            evaluate_integer_selector (field_value_p, disk_unit_stat_selector.logical_unit_number_selector);

          ELSEIF keyword_p^ = 'OFF_LINE_DRIVE_NUMBER          ' THEN
            disk_unit_stat_selector.key := ofc$us_off_line_drive_number;
            evaluate_integer_selector (field_value_p, disk_unit_stat_selector.off_line_drive_number_selector);

          ELSEIF keyword_p^ = 'PARITY_PROTECTION_ENABLED      ' THEN
            disk_unit_stat_selector.key := ofc$us_parity_protect_enabled;
            evaluate_boolean_selector (field_value_p, disk_unit_stat_selector.
                  parity_protect_enabled_selector);

          ELSEIF keyword_p^ = 'PARITY_PROTECTED_DEVICE        ' THEN
            disk_unit_stat_selector.key := ofc$us_parity_protected_device;
            evaluate_boolean_selector (field_value_p, disk_unit_stat_selector.parity_protected_device_select);

          ELSEIF keyword_p^ = 'READ_MAU_COUNT                 ' THEN
            disk_unit_stat_selector.key := ofc$us_read_mau_count;
            evaluate_integer_selector (field_value_p, disk_unit_stat_selector.read_mau_count_selector);

          ELSEIF keyword_p^ = 'READ_QUEUE_TIME                ' THEN
            disk_unit_stat_selector.key := ofc$us_read_qtime;
            evaluate_integer_selector (field_value_p, disk_unit_stat_selector.read_qtime_selector);

          ELSEIF keyword_p^ = 'READ_REQUESTS                  ' THEN
            disk_unit_stat_selector.key := ofc$us_read_requests;
            evaluate_integer_selector (field_value_p, disk_unit_stat_selector.read_requests_selector);

          ELSEIF keyword_p^ = 'RECORDED_VSN                   ' THEN
            disk_unit_stat_selector.key := ofc$us_recorded_vsn;
            evaluate_name_selector (field_value_p, disk_unit_stat_selector.recorded_vsn_selector);

          ELSEIF keyword_p^ = 'RECOVERED_ERRORS               ' THEN
            disk_unit_stat_selector.key := ofc$us_recovered_errors;
            evaluate_integer_selector (field_value_p, disk_unit_stat_selector.recovered_errors_selector);

          ELSEIF keyword_p^ = 'REQUESTS_CAUSING_SKIPPED_CYL   ' THEN
            disk_unit_stat_selector.key := ofc$us_requests_cause_skip_cyl;
            evaluate_integer_selector (field_value_p, disk_unit_stat_selector.requests_cause_skip_cyl_select);

          ELSEIF keyword_p^ = 'RESTORING_DRIVE                ' THEN
            disk_unit_stat_selector.key := ofc$us_restoring_drive;
            evaluate_boolean_selector (field_value_p, disk_unit_stat_selector.restoring_drive_selector);

          ELSEIF keyword_p^ = 'STREAM_REQUEST_COUNT_READ      ' THEN
            disk_unit_stat_selector.key := ofc$us_strm_req_count_read;
            evaluate_integer_selector (field_value_p, disk_unit_stat_selector.strm_req_count_read_selector);

          ELSEIF keyword_p^ = 'STREAM_REQUEST_COUNT_WRITE     ' THEN
            disk_unit_stat_selector.key := ofc$us_strm_req_count_write;
            evaluate_integer_selector (field_value_p, disk_unit_stat_selector.strm_req_count_write_selector);

          ELSEIF keyword_p^ = 'STREAM_REQUEST_FAIL_COUNT_READ ' THEN
            disk_unit_stat_selector.key := ofc$us_strm_req_fail_cnt_read;
            evaluate_integer_selector (field_value_p, disk_unit_stat_selector.
                  strm_req_fail_cnt_read_selector);

          ELSEIF keyword_p^ = 'STREAM_REQUEST_FAIL_COUNT_WRITE' THEN
            disk_unit_stat_selector.key := ofc$us_strm_req_fail_cnt_wrt;
            evaluate_integer_selector (field_value_p, disk_unit_stat_selector.strm_req_fail_cnt_wrt_selector);

          ELSEIF keyword_p^ = 'STREAM_REQUEST_POSSIBLE        ' THEN
            disk_unit_stat_selector.key := ofc$us_strm_request_possible;
            evaluate_boolean_selector (field_value_p, disk_unit_stat_selector.strm_request_possible_selector);

          ELSEIF keyword_p^ = 'SWAP_IN_MAU_COUNT              ' THEN
            disk_unit_stat_selector.key := ofc$us_swap_in_mau_count;
            evaluate_integer_selector (field_value_p, disk_unit_stat_selector.swap_in_mau_count_selector);

          ELSEIF keyword_p^ = 'SWAP_IN_QUEUE_TIME             ' THEN
            disk_unit_stat_selector.key := ofc$us_swap_in_qtime;
            evaluate_integer_selector (field_value_p, disk_unit_stat_selector.swap_in_qtime_selector);

          ELSEIF keyword_p^ = 'SWAP_IN_REQUESTS               ' THEN
            disk_unit_stat_selector.key := ofc$us_swap_in_requests;
            evaluate_integer_selector (field_value_p, disk_unit_stat_selector.swap_in_requests_selector);

          ELSEIF keyword_p^ = 'SWAP_OUT_DATA_MAU_COUNT        ' THEN
            disk_unit_stat_selector.key := ofc$us_swap_out_data_mau_count;
            evaluate_integer_selector (field_value_p, disk_unit_stat_selector.swap_out_data_mau_count_select);

          ELSEIF keyword_p^ = 'SWAP_OUT_DATA_PRESET_MAUS      ' THEN
            disk_unit_stat_selector.key := ofc$us_swap_out_datapres_maus;
            evaluate_integer_selector (field_value_p, disk_unit_stat_selector.
                  swap_out_datapres_maus_selector);

          ELSEIF keyword_p^ = 'SWAP_OUT_QUEUE_TIME            ' THEN
            disk_unit_stat_selector.key := ofc$us_swap_out_qtime;
            evaluate_integer_selector (field_value_p, disk_unit_stat_selector.swap_out_qtime_selector);

          ELSEIF keyword_p^ = 'SWAP_OUT_REQUESTS              ' THEN
            disk_unit_stat_selector.key := ofc$us_swap_out_requests;
            evaluate_integer_selector (field_value_p, disk_unit_stat_selector.swap_out_requests_selector);

          ELSEIF keyword_p^ = 'TOTAL_CYLINDERS_SKIPPED        ' THEN
            disk_unit_stat_selector.key := ofc$us_total_cylinders_skipped;
            evaluate_integer_selector (field_value_p, disk_unit_stat_selector.total_cylinders_skipped_select);

          ELSEIF keyword_p^ = 'TOTAL_ERRORS                   ' THEN
            disk_unit_stat_selector.key := ofc$us_total_errors;
            evaluate_integer_selector (field_value_p, disk_unit_stat_selector.total_errors_selector);

          ELSEIF keyword_p^ = 'UNIT_CONFIGURED                ' THEN
            disk_unit_stat_selector.key := ofc$us_unit_configured;
            evaluate_boolean_selector (field_value_p, disk_unit_stat_selector.unit_configured_selector);

          ELSEIF keyword_p^ = 'UNIT_DISABLED                  ' THEN
            disk_unit_stat_selector.key := ofc$us_unit_disabled;
            evaluate_boolean_selector (field_value_p, disk_unit_stat_selector.unit_disabled_selector);

          ELSEIF keyword_p^ = 'UNIT_USED                      ' THEN
            disk_unit_stat_selector.key := ofc$us_unit_used;
            evaluate_boolean_selector (field_value_p, disk_unit_stat_selector.unit_used_selector);

          ELSEIF keyword_p^ = 'UNRECOVERED_ERRORS             ' THEN
            disk_unit_stat_selector.key := ofc$us_unrecovered_errors;
            evaluate_integer_selector (field_value_p, disk_unit_stat_selector.unrecovered_errors_selector);

          ELSEIF keyword_p^ = 'WRITE_DATA_MAU_COUNT           ' THEN
            disk_unit_stat_selector.key := ofc$us_write_data_mau_count;
            evaluate_integer_selector (field_value_p, disk_unit_stat_selector.write_data_mau_count_selector);

          ELSEIF keyword_p^ = 'WRITE_DATA_PRESET_MAUS         ' THEN
            disk_unit_stat_selector.key := ofc$us_write_datapres_maus;
            evaluate_integer_selector (field_value_p, disk_unit_stat_selector.write_datapres_maus_selector);

          ELSEIF keyword_p^ = 'WRITE_QUEUE_TIME               ' THEN
            disk_unit_stat_selector.key := ofc$us_write_qtime;
            evaluate_integer_selector (field_value_p, disk_unit_stat_selector.write_qtime_selector);

          ELSEIF keyword_p^ = 'WRITE_REQUESTS                 ' THEN
            disk_unit_stat_selector.key := ofc$us_write_requests;
            evaluate_integer_selector (field_value_p, disk_unit_stat_selector.write_requests_selector);

          ELSE {Unsupported Keyword
            osp$set_status_abnormal ('US', ofe$illegal_data_value_kind, 'Evaluate_Disk_Statistic_Selector',
                  status);
            osp$append_status_parameter (osc$status_parameter_delimiter, keyword_p^, status);
            osp$append_status_parameter (osc$status_parameter_delimiter, 'Unknown field_value', status);
            RETURN; {----->
          IFEND;
        IFEND;

      ELSEIF (UPPERBOUND (value_p^.field_values^) = 3)
{       } AND (value_p^.field_values^ [1].name = 'CHANNEL_NUMBER')
{       } AND (value_p^.field_values^ [2].name = 'CHANNEL_PORT')
{       } AND (value_p^.field_values^ [3].name = 'CONCURRENT_CHANNEL') THEN

        disk_unit_stat_selector.key := ofc$us_channel;
        evaluate_channel_selector (value_p^.field_values^ [1].value, value_p^.field_values^ [2].
              value, value_p^.field_values^ [3].value, disk_unit_stat_selector.channel_selector);

      ELSE
        osp$set_status_abnormal ('US', ofe$illegal_data_value_kind, 'Evaluate_Disk_Statistic_Selector',
              status);
        osp$append_status_parameter (osc$status_parameter_delimiter, 'Unknown field_values', status);
        osp$append_status_parameter (osc$status_parameter_delimiter,
              'Disk_Statistic_Selector list list record', status);
        RETURN; {----->
      IFEND;

    PROCEND evaluate_disk_stat_rec_select;
?? OLDTITLE ??
?? NEWTITLE := 'EVALUATE_DISK_STAT_SELECTOR', EJECT ??

    PROCEDURE evaluate_disk_stats_selector
      (    value_p: ^clt$data_value;
       VAR disk_unit_statistic_selector: oft$us_or_unit_stat_selection;
       VAR status: ost$status);

{NOTE: value_p can't be NIL.

      VAR
        disk_unit_stat_selector_p: ^oft$us_unit_stat_selection,
        node_p: ^clt$data_value;

      disk_unit_statistic_selector.number_of_and_selections := 0;
      node_p := value_p;

      WHILE (node_p <> NIL) AND (node_p^.kind = clc$list) DO

        IF node_p^.element_value = NIL THEN
          ;
        ELSEIF node_p^.element_value^.kind = clc$keyword THEN
          disk_unit_statistic_selector.number_of_and_selections :=
                disk_unit_statistic_selector.number_of_and_selections + 1;

          disk_unit_stat_selector_p := ^disk_unit_statistic_selector.
                and_selections [disk_unit_statistic_selector.number_of_and_selections];

{   Abbreaviation
          IF node_p^.element_value^.keyword_value = 'EXCLUDE_DISABLED_ELEMENTS' THEN
            disk_unit_stat_selector_p^.key := ofc$us_unit_disabled;
            disk_unit_stat_selector_p^.unit_disabled_selector := $oft$us_boolean_selector [FALSE];

          ELSEIF node_p^.element_value^.keyword_value = 'EXCLUDE_ELEMENTS_WITHOUT_ERRORS' THEN
            disk_unit_stat_selector_p^.key := ofc$us_total_errors;
            disk_unit_stat_selector_p^.total_errors_selector.min_value := 1;
            disk_unit_stat_selector_p^.total_errors_selector.max_value := clc$max_integer;

          ELSE
            osp$set_status_abnormal ('US', ofe$illegal_data_value_kind, 'Evaluate_Disk_Statistic_Selector',
                  status);
            osp$append_status_parameter (osc$status_parameter_delimiter, node_p^.element_value^.keyword_value,
                  status);
            osp$append_status_parameter (osc$status_parameter_delimiter,
                  'Disk_Statistic_Selector list list entry', status);
            RETURN; {----->
          IFEND;

        ELSEIF node_p^.element_value^.kind = clc$record THEN
          evaluate_disk_stat_rec_select (node_p^.element_value, disk_unit_stat_selector_p^, status);
          IF NOT status.normal THEN
            RETURN; {----->
          IFEND;

        ELSEIF (node_p^.element_value^.kind = clc$list) THEN
          evaluate_disk_unit_selector (node_p^.element_value, disk_unit_stat_selector_p^, status);
          IF NOT status.normal THEN
            RETURN; {----->
          IFEND;

        ELSE {
          osp$set_status_abnormal ('US', ofe$illegal_data_value_kind, 'Evaluate_Disk_Statistic_Selector',
                status);
          clp$append_status_value_type (osc$status_parameter_delimiter, node_p^.element_value, status);
          osp$append_status_parameter (osc$status_parameter_delimiter,
                'Disk_Statistic_Selector list list entry', status);
          RETURN; {----->
        IFEND;

        node_p := node_p^.link;
      WHILEND;

    PROCEND evaluate_disk_stats_selector;
?? OLDTITLE ??
?? EJECT ??
    status.normal := TRUE;
    disk_unit_statistic_selectors.number_of_or_selections := 0;

{NOTE: key ALL resolves to no selectors.

    node_p := value_p;
    WHILE (node_p <> NIL) AND (node_p^.kind = clc$list) DO
      IF node_p^.element_value = NIL THEN
        ;
      ELSE { CLC$LIST
        disk_unit_statistic_selectors.number_of_or_selections :=
              disk_unit_statistic_selectors.number_of_or_selections + 1;

        evaluate_disk_stats_selector (node_p^.element_value, disk_unit_statistic_selectors.
              or_selections [disk_unit_statistic_selectors.number_of_or_selections], status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
      IFEND;

      node_p := node_p^.link;
    WHILEND;

  PROCEND evaluate_disk_stats_selectors;
?? OLDTITLE ??
?? NEWTITLE := 'process_field_description', EJECT ??

{ PURPOSE:
{    This procedure processes a field description entry from a command and makes
{    a table entry in the display description table.
{ INPUT:
{    field_values: pointer to the PVT record entry that defines the attributes of
{        the field.
{ OUTPUT:
{    field: field description entry for the display descriptor.
{    status
{
{ NOTES: percent CP usage is forced to be incremental since it has no other meaning.

  PROCEDURE process_field_description
    (    field_values: ^array [1 .. * ] of clt$field_value;
     VAR field: oft$field_description;
     VAR status: ost$status);

    VAR
      field_name: ost$name,
      field_overflow_specified: boolean,
      field_width_specified: boolean,
      fna_index: field_name_array_index,
      i: integer,
      incremental_specified: boolean,
      scale_specified: boolean,
      strlen: 0 .. 132,
      title_p: ^clt$string_value;

    status.normal := TRUE;

    field_width_specified := FALSE;
    field_overflow_specified := FALSE;
    incremental_specified := FALSE;
    scale_specified := FALSE;
    title_p := NIL;

    field.incremental := FALSE;
    field.field_overflow_action := ofc$foa_scale;
    field.field_selection := ofc$fs_unconditional;
    field.non_selection_action := ofc$nsa_blank;

    FOR i := LOWERBOUND (field_values^) TO UPPERBOUND (field_values^) DO
      IF field_values^ [i].value <> NIL THEN
        IF field_values^ [i].name = 'FIELD_NAME' THEN
          field_name := field_values^ [i].value^.name_value;
        ELSEIF field_values^ [i].name = 'FIELD_WIDTH' THEN
          field_width_specified := TRUE;
          field.width := field_values^ [i].value^.integer_value.value;
        ELSEIF field_values^ [i].name = 'SCALE' THEN
          scale_specified := TRUE;
          field.scale := field_values^ [i].value^.integer_value.value;
        ELSEIF field_values^ [i].name = 'FIELD_TITLE' THEN
          title_p := field_values^ [i].value^.string_value;
        ELSEIF field_values^ [i].name = 'NUMERIC_DISPLAY_MODE' THEN
          incremental_specified := TRUE;
          IF field_values^ [i].value^.name_value = 'INCREMENTAL' THEN
            field.incremental := TRUE;
          IFEND;
        ELSEIF field_values^ [i].name = 'FIELD_SELECTION' THEN
          IF field_values^ [i].value^.name_value = 'UNCONDITIONAL' THEN
            field.field_selection := ofc$fs_unconditional;
          ELSEIF field_values^ [i].value^.name_value = 'ACTIVE' THEN
            field.field_selection := ofc$fs_active;
          ELSE
            field.field_selection := ofc$fs_swapped;
          IFEND;
        ELSEIF field_values^ [i].name = 'FIELD_OVERFLOW_ACTION' THEN
          IF field_values^ [i].value^.name_value = 'MAXIMUM' THEN
            field.field_overflow_action := ofc$foa_maximum;
          ELSEIF field_values^ [i].value^.name_value = 'ASTERISK' THEN
            field.field_overflow_action := ofc$foa_asterisk;
          IFEND;
        ELSEIF field_values^ [i].name = 'NON_SELECTION_ACTION' THEN
          IF field_values^ [i].value^.name_value = 'SKIP' THEN
            field.non_selection_action := ofc$nsa_skip;
          ELSE
            field.non_selection_action := ofc$nsa_blank;
          IFEND;
        IFEND;
      IFEND;
    FOREND;

    convert_field_name_to_id (field_name, field.field_id, fna_index, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF field.field_id = ofc$fi_percent_cp_usage THEN
      field.incremental := TRUE;
    IFEND;

    IF (field_name_array [fna_index].default_scale = 0) AND
          (scale_specified OR incremental_specified OR field_overflow_specified) THEN
      osp$set_status_abnormal ('OF', ofe$invalid_numeric_attribute, field_name, status);
    IFEND;

    IF NOT field_width_specified THEN
      field.width := field_name_array [fna_index].default_width;
    IFEND;
    IF NOT scale_specified THEN
      field.scale := field_name_array [fna_index].default_scale;
    IFEND;

    IF title_p = NIL THEN
      title_p := ^field_name_array [fna_index].field_name_abbrev;
    IFEND;
    IF field.field_id IN left_justified_fields THEN
      field.field_title := title_p^;
    ELSE
      field.field_title := '';
      strlen := STRLENGTH (title_p^);
      WHILE (strlen > 1) AND (title_p^ (strlen) = ' ') DO
        strlen := strlen - 1;
      WHILEND;
      field.field_title (STRLENGTH (field.field_title) - strlen + 1, * ) := title_p^;
    IFEND;

  PROCEND process_field_description;

?? TITLE := 'process_field_descriptions', EJECT ??

{ PURPOSE:
{    This procedure processes all the PVT entries for display field definitions.
{    and builds an array of field descriptors in the display descriptor.
{ INPUT:
{    first_list_data_value: first data value from the PVT entry for the field descriptions
{    dd_p: pointer to display description
{    starting_field_index: index to first entry in display description for new field descriptions
{ OUTPUT:
{    count: number of field descriptions found

  PROCEDURE process_field_descriptions
    (    first_list_data_value: ^clt$data_value;
         dd_p: ^oft$display_description;
         starting_field_index: oft$field_index;
     VAR count: oft$field_count;
     VAR status: ost$status);

    VAR
      field_index: oft$field_index,
      i: integer,
      list_data_value: ^clt$data_value;

    status.normal := TRUE;
    field_index := starting_field_index;
    list_data_value := first_list_data_value;

    WHILE list_data_value <> NIL DO
      process_field_description (list_data_value^.element_value^.field_values, dd_p^.fields [field_index],
            status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;
      field_index := field_index + 1;
      list_data_value := list_data_value^.link;
    WHILEND;

    count := field_index - starting_field_index;

  PROCEND process_field_descriptions;
?? TITLE := 'process_header_parameters ', EJECT ??

{ PURPOSE:
{    This procedure processes the command parameters EXCEPT for field descriptions.
{    and builds the display description header record. This procedure is used by
{    both the CREATE and CHANGE commands. The CREATE command will use  default values
{    values of parameters; CHANGE uses only parameters explicitly specified
{ INPUT:
{    pvt - the PVT from the command
{    pvt_numbers - an array that maps logical parameters to PVT parameter numbers
{    accept_DEFAULTS - boolean to specify whether to use DEFAULT values from the PVT.
{ OUTPUT:
{    dd_p: pointer to the display description. This procedure fills in the
{           header parameter values
{    title_specified: boolean that indicates if the TITLE parameter was explicitly specified
{


  PROCEDURE process_header_parameters
    (VAR pvt {input} : array [1 .. * ] of clt$parameter_value;
         pvt_numbers: pvt_numbers_list;
         accept_defaults: boolean;
         dd_p: ^oft$display_description;
     VAR title_specified: boolean);

    IF accept_defaults OR pvt [pvt_numbers [pn$display_system_line]].specified THEN
      dd_p^.header.display_system_line := pvt [pvt_numbers [pn$display_system_line]].value^.boolean_value.
            value;
    IFEND;

    IF accept_defaults OR pvt [pvt_numbers [pn$display_blank_lines]].specified THEN
      dd_p^.header.display_blank_lines := pvt [pvt_numbers [pn$display_blank_lines]].value^.boolean_value.
            value;
    IFEND;

    IF pvt [pvt_numbers [pn$alias]].specified THEN
      dd_p^.header.display_name_abbrev := pvt [pvt_numbers [pn$alias]].value^.name_value;
    IFEND;

    IF accept_defaults OR pvt [pvt_numbers [pn$jobs_per_line]].specified THEN
      dd_p^.header.jobs_per_line := pvt [pvt_numbers [pn$jobs_per_line]].value^.integer_value.value;
    IFEND;

    IF accept_defaults OR pvt [pvt_numbers [pn$job_selection]].specified THEN
      IF pvt [pvt_numbers [pn$job_selection]].value^.keyword_value = 'ACTIVE' THEN
        dd_p^.header.job_selection := ofc$js_active;
      ELSE
        dd_p^.header.job_selection := ofc$js_initiated;
      IFEND;
    IFEND;

    title_specified := pvt [pvt_numbers [pn$title]].value <> NIL;
    IF title_specified THEN
      dd_p^.header.title := pvt [pvt_numbers [pn$title]].value^.string_value^;
    IFEND;


  PROCEND process_header_parameters;
?? OLDTITLE ??
?? NEWTITLE := 'process_us_field_description', EJECT ??

  PROCEDURE process_us_field_description
    (    field_values: ^array [1 .. * ] of clt$field_value;
     VAR field: oft$us_field_description;
     VAR status: ost$status);

    VAR
      field_name_p: ^ost$name,
      field_overflow_action_p: ^clt$keyword,
      field_selections_p: ^array [1 .. * ] of clt$field_value,
      field_title_p: ^clt$string_value,
      field_width_p: ^integer,
      field_fraction_width_p: ^integer,
      i: integer,
      non_selection_action_p: ^clt$keyword,
      numeric_display_mode_p: ^clt$data_value,
      numeric_selection_mode_p: ^clt$keyword,
      unit_statistics_default_value_p: ^t$unit_statistic_default_value,
      strlen: 0 .. 132,
      scale_p: ^integer;

?? NEWTITLE := 'process_us_field_selections', EJECT ??

    PROCEDURE process_us_field_selections
      (    field_values: ^array [1 .. * ] of clt$field_value;
       VAR field_selections: oft$us_field_selections);

      VAR
        i: integer,
        field_name: ost$name;

?? NEWTITLE := 'EVALUATE_BOOLEAN_SELECTOR', EJECT ??

      PROCEDURE evaluate_boolean_selector
        (    value_p: ^clt$data_value;
         VAR boolean_selector: oft$us_boolean_selector);

        VAR
          node_p: ^clt$data_value;

        IF value_p^.kind = clc$list THEN
          node_p := value_p;
          boolean_selector := $oft$us_boolean_selector [];

          WHILE (node_p <> NIL) AND (node_p^.kind = clc$list) DO

            IF (node_p^.element_value <> NIL) AND (node_p^.element_value^.kind = clc$boolean) THEN
              boolean_selector := boolean_selector + $oft$us_boolean_selector
                    [node_p^.element_value^.boolean_value.value];
            IFEND;
            node_p := node_p^.link;
          WHILEND;
        ELSE
          boolean_selector := $oft$us_boolean_selector [value_p^.boolean_value.value];
        IFEND;

      PROCEND evaluate_boolean_selector;
?? OLDTITLE ??
?? EJECT ??

      FOR i := LOWERBOUND (field_values^) TO UPPERBOUND (field_values^) DO
        IF field_values^ [i].value <> NIL THEN
          IF field_values^ [i].name = 'PARITY_PROTECTION_ENABLED' THEN
            evaluate_boolean_selector (field_values^ [i].value,
                  field_selections.parity_protect_enabled_selector);
          ELSEIF field_values^ [i].name = 'PARITY_PROTECTED_DEVICE' THEN
            evaluate_boolean_selector (field_values^ [i].value,
                  field_selections.parity_protected_device_select);
          ELSEIF field_values^ [i].name = 'UNIT_DISABLED' THEN
            evaluate_boolean_selector (field_values^ [i].value, field_selections.unit_disabled_selector);
          IFEND;
        IFEND;
      FOREND;

    PROCEND process_us_field_selections;
?? OLDTITLE ??
?? EJECT ??
    status.normal := TRUE;
    field_name_p := NIL;
    field_overflow_action_p := NIL;
    field_selections_p := NIL;
    field_title_p := NIL;
    field_width_p := NIL;
    field_fraction_width_p := NIL;
    non_selection_action_p := NIL;
    numeric_display_mode_p := NIL;
    numeric_selection_mode_p := NIL;
    scale_p := NIL;

    FOR i := LOWERBOUND (field_values^) TO UPPERBOUND (field_values^) DO
      IF field_values^ [i].value <> NIL THEN
        IF field_values^ [i].name = 'FIELD_NAME' THEN
          field_name_p := ^field_values^ [i].value^.name_value;
        ELSEIF field_values^ [i].name = 'FIELD_WIDTH' THEN
          field_width_p := ^field_values^ [i].value^.integer_value.value;
        ELSEIF field_values^ [i].name = 'FRACTION_WIDTH' THEN
          field_fraction_width_p := ^field_values^ [i].value^.integer_value.value;
        ELSEIF field_values^ [i].name = 'SCALE' THEN
          scale_p := ^field_values^ [i].value^.integer_value.value;
        ELSEIF field_values^ [i].name = 'FIELD_TITLE' THEN
          field_title_p := field_values^ [i].value^.string_value;
        ELSEIF field_values^ [i].name = 'NUMERIC_DISPLAY_MODE' THEN
          numeric_display_mode_p := field_values^ [i].value;
        ELSEIF field_values^ [i].name = 'NUMERIC_SELECTION_MODE' THEN
          numeric_selection_mode_p := ^field_values^ [i].value^.name_value;
        ELSEIF field_values^ [i].name = 'FIELD_SELECTIONS' THEN
          field_selections_p := field_values^ [i].value^.field_values;
        ELSEIF field_values^ [i].name = 'FIELD_OVERFLOW_ACTION' THEN
          field_overflow_action_p := ^field_values^ [i].value^.name_value;
        ELSEIF field_values^ [i].name = 'NON_SELECTION_ACTION' THEN
          non_selection_action_p := ^field_values^ [i].value^.name_value;
        IFEND;
      IFEND;
    FOREND;

{Field_Name
    IF field_name_p = NIL THEN
      PUSH field_name_p;
      field_name_p^ := '';
    IFEND;
    convert_us_field_name_to_id (field_name_p^, field.field_id, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    unit_statistics_default_value_p := ^unit_statistics_default_values [field.field_id];

    IF (unit_statistics_default_value_p^.scale = 0)
{    } AND ((scale_p <> NIL) OR (numeric_display_mode_p <> NIL) OR (numeric_selection_mode_p <> NIL) OR
          (field_overflow_action_p <> NIL) OR (field_fraction_width_p <> NIL)) THEN
      osp$set_status_abnormal ('OF', ofe$invalid_numeric_attribute, field_name_p^, status);
      RETURN; {----->
    IFEND;

{Field Overflow Action
    IF field_overflow_action_p = NIL THEN
      field.field_overflow_action := ofc$foa_scale;
    ELSEIF field_overflow_action_p^ = 'MAXIMUM' THEN
      field.field_overflow_action := ofc$foa_maximum;
    ELSEIF field_overflow_action_p^ = 'ASTERISK' THEN
      field.field_overflow_action := ofc$foa_asterisk;
    IFEND;

{Field Selections
    field.field_selections := unit_statistics_default_value_p^.field_selections;
    IF field_selections_p <> NIL THEN
      process_us_field_selections (field_selections_p, field.field_selections);
    IFEND;

{Field Width
    IF field_width_p = NIL THEN
      field.width := unit_statistics_default_value_p^.width;
    ELSE
      field.width := field_width_p^;
    IFEND;

{Fraction_Width
    IF field_fraction_width_p = NIL THEN
      field.fraction_width := unit_statistics_default_value_p^.fraction_width;
    ELSE
      field.fraction_width := field_fraction_width_p^;
    IFEND;

{Display_Option
    field.display_option := 0;

{Scale
    IF scale_p = NIL THEN
      field.scale := unit_statistics_default_value_p^.scale;
    ELSE
      field.scale := scale_p^;
    IFEND;

{Numeric Selection Mode
    IF numeric_selection_mode_p = NIL THEN
      field.numeric_selection_mode := unit_statistics_default_value_p^.numeric_selection_mode;
    ELSEIF numeric_selection_mode_p^ = 'TOTAL' THEN
      field.numeric_selection_mode := ofc$nsm_total;
    ELSEIF numeric_selection_mode_p^ = 'INCREMENTAL' THEN
      field.numeric_selection_mode := ofc$nsm_incremental;
    IFEND;

{Numeric Display Mode
    IF numeric_display_mode_p = NIL THEN
      field.numeric_display_mode := unit_statistics_default_value_p^.numeric_display_mode;
    ELSE
      CASE numeric_display_mode_p^.kind OF
      = clc$keyword =
        IF numeric_display_mode_p^.keyword_value = 'TOTAL' THEN
          field.numeric_display_mode.kind := ofc$ndm_total;
        ELSEIF numeric_display_mode_p^.keyword_value = 'COUNT_PER_SECOND' THEN
          field.numeric_display_mode.kind := ofc$ndm_interval;
          field.numeric_display_mode.interval := c$clock_second;
        ELSEIF numeric_display_mode_p^.keyword_value = 'COUNT_PER_MINUTE' THEN
          field.numeric_display_mode.kind := ofc$ndm_interval;
          field.numeric_display_mode.interval := c$clock_minute;
        ELSEIF numeric_display_mode_p^.keyword_value = 'COUNT_PER_HOUR' THEN
          field.numeric_display_mode.kind := ofc$ndm_interval;
          field.numeric_display_mode.interval := c$clock_hour;
        ELSE {per day
          field.numeric_display_mode.kind := ofc$ndm_interval;
          field.numeric_display_mode.interval := c$clock_day;
        IFEND;

      = clc$integer =
        field.numeric_display_mode.kind := ofc$ndm_interval;
        field.numeric_display_mode.interval := 1000000 * numeric_display_mode_p^.integer_value.value;

      = clc$time_increment =
        field.numeric_display_mode.interval :=
{       } (1000 * numeric_display_mode_p^.time_increment_value^.millisecond) +
{       } (1000 * 1000 * numeric_display_mode_p^.time_increment_value^.second) +
{       } (1000 * 1000 * 60 * numeric_display_mode_p^.time_increment_value^.minute) +
{       } (1000 * 1000 * 60 * 60 * numeric_display_mode_p^.time_increment_value^.hour) +
{       } (1000 * 1000 * 60 * 60 * 24 * numeric_display_mode_p^.time_increment_value^.day) +
{       } (1000 * 1000 * 60 * 60 * 24 * 31 * numeric_display_mode_p^.time_increment_value^.month) +
{       } (1000 * 1000 * 60 * 60 * 24 * 365 * numeric_display_mode_p^.time_increment_value^.year);
      CASEND
    IFEND;

    IF (field.numeric_selection_mode <> ofc$nsm_total)
{ } AND (unit_statistics_default_value_p^.incremental_allowed = FALSE) THEN
      osp$set_status_abnormal ('OF', ofe$invalid_numeric_attribute, field_name_p^, status);
      RETURN; {----->
    IFEND;

{Non Selection Action
    IF non_selection_action_p = NIL THEN
      field.non_selection_action := ofc$nsa_blank;
    ELSEIF non_selection_action_p^ = 'SKIP' THEN
      field.non_selection_action := ofc$nsa_skip;
    ELSE
      field.non_selection_action := ofc$nsa_blank;
    IFEND;

{Title
    IF field_title_p = NIL THEN
      field_title_p := ^unit_statistics_default_value_p^.title;
    IFEND;

{Note: We moved the justification of the field title to VERIFY_UNIT_STAT_DISPLAY_DESC,
{      as there is a problem with field titles when a field is right justified and bigger than
{      osc$max_name_size.

    field.field_title := field_title_p^;

  PROCEND process_us_field_description;
?? OLDTITLE ??
?? NEWTITLE := 'process_us_field_descriptions', EJECT ??

{ PURPOSE:
{    This procedure processes all the PVT entries for display field definitions.
{    and builds an array of field descriptors in the display descriptor.
{ INPUT:
{    first_list_data_value: first data value from the PVT entry for the field descriptions
{    dd_p: pointer to display description
{    starting_field_index: index to first entry in display description for new field descriptions
{ OUTPUT:
{    count: number of field descriptions found

  PROCEDURE process_us_field_descriptions
    (    first_list_data_value: ^clt$data_value;
         ud_p: ^oft$unit_stat_display_desc;
         starting_field_index: oft$field_index;
     VAR count: oft$field_count;
     VAR status: ost$status);

    VAR
      field_index: oft$field_index,
      i: integer,
      list_data_value: ^clt$data_value;

    status.normal := TRUE;
    field_index := starting_field_index;
    list_data_value := first_list_data_value;

    WHILE list_data_value <> NIL DO
      process_us_field_description (list_data_value^.element_value^.field_values, ud_p^.fields [field_index],
            status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;
      field_index := field_index + 1;
      list_data_value := list_data_value^.link;
    WHILEND;

    count := field_index - starting_field_index;

  PROCEND process_us_field_descriptions;
?? TITLE := 'process_us_header_parameters ', EJECT ??

{ PURPOSE:
{    This procedure processes the command parameters EXCEPT for field descriptions.
{    and builds the display description header record. This procedure is used by
{    both the CREATE and CHANGE commands. The CREATE command will use  default values
{    values of parameters; CHANGE uses only parameters explicitly specified
{ INPUT:
{    pvt - the PVT from the command
{    pvt_numbers - an array that maps logical parameters to PVT parameter numbers
{    accept_DEFAULTS - boolean to specify whether to use DEFAULT values from the PVT.
{ OUTPUT:
{    ud_p: pointer to the display description. This procedure fills in the
{           header parameter values
{    title_specified: boolean that indicates if the TITLE parameter was explicitly specified
{

  PROCEDURE process_us_header_parameters
    (VAR pvt {input} : array [1 .. * ] of clt$parameter_value;
         pvt_numbers: pvt_numbers_list;
         accept_defaults: boolean;
         ud_p: ^oft$unit_stat_display_desc;
     VAR title_specified: boolean);

    VAR
      value_p: ^clt$data_value;

    IF accept_defaults OR pvt [pvt_numbers [p$us_display_system_line]].specified THEN
      ud_p^.header.display_system_line := pvt [pvt_numbers [p$us_display_system_line]].value^.boolean_value.
            value;
    IFEND;

    IF accept_defaults OR pvt [pvt_numbers [p$us_display_blank_lines]].specified THEN
      ud_p^.header.display_blank_lines := pvt [pvt_numbers [p$us_display_blank_lines]].value^.boolean_value.
            value;
    IFEND;

    IF accept_defaults OR pvt [pvt_numbers [p$us_units_per_line]].specified THEN
      ud_p^.header.units_per_line := pvt [pvt_numbers [p$us_units_per_line]].value^.integer_value.value;
    IFEND;

    IF accept_defaults OR pvt [pvt_numbers [p$us_incremental_reset_freq]].specified THEN
      value_p := pvt [pvt_numbers [p$us_incremental_reset_freq]].value;
      CASE value_p^.kind OF
      = clc$keyword =
        IF value_p^.keyword_value = 'SESSION' THEN
          ud_p^.header.incremental_data_reset_freq := clc$max_integer;
        ELSE {Command
          ud_p^.header.incremental_data_reset_freq := 0;
        IFEND;
      = clc$integer =
        ud_p^.header.incremental_data_reset_freq := 1000000 * value_p^.integer_value.value;
      = clc$time_increment =
        ud_p^.header.incremental_data_reset_freq :=
{         } (1000 * value_p^.time_increment_value^.millisecond) +
{         } (1000 * 1000 * value_p^.time_increment_value^.second) +
{         } (1000 * 1000 * 60 * value_p^.time_increment_value^.minute) +
{         } (1000 * 1000 * 60 * 60 * value_p^.time_increment_value^.hour) +
{         } (1000 * 1000 * 60 * 60 * 24 * value_p^.time_increment_value^.day) +
{         } (1000 * 1000 * 60 * 60 * 24 * 31 * value_p^.time_increment_value^.month) +
{         } (1000 * 1000 * 60 * 60 * 24 * 365 * value_p^.time_increment_value^.year);

      CASEND;
    IFEND;

    title_specified := pvt [pvt_numbers [p$us_title]].value <> NIL;
    IF title_specified THEN
      ud_p^.header.title := pvt [pvt_numbers [p$us_title]].value^.string_value^;
    IFEND;

    IF pvt [pvt_numbers [p$us_alias]].specified THEN
      ud_p^.header.display_name_abbrev := pvt [pvt_numbers [p$us_alias]].value^.name_value;
    IFEND;

  PROCEND process_us_header_parameters;
?? OLDTITLE ??
?? NEWTITLE := 'verify_display_description', EJECT ??

{
{ PURPOSE:
{    This procedure is called after a display_description is completed. This
{    procedure checks whether the description is valid. Items verified include things
{    such as display_too_wide, too_many_incremental_fields, etc.
{    This procedure also generates the display title if it was not explicitly specified.
{ INPUT:
{    dd_p - pointer to display description.
{    field_count - number of fields actually specified for the display
{    title_specified - boolean that indicates if the display TITLE was explicitly specified.
{ OUTPUT:
{    The following field are updated in the display decription:
{        title, column_width
{    status

  PROCEDURE verify_display_description
    (    dd_p: ^oft$display_description;
         field_count: oft$field_count;
         title_specified: boolean;
     VAR status: ost$status);

    VAR
      field_title: ost$name,
      i: oft$field_index,
      incremental_field_count: integer,
      title: string (ofc$max_display_width),
      title_index: integer,
      width: 1 .. ofc$max_display_width;

    status.normal := TRUE;

    title_index := 2;
    title := ' ';
    incremental_field_count := 0;
    FOR i := 1 TO field_count DO
      width := dd_p^.fields [i].width;
      IF (title_index + width) > (ofc$max_display_width + 2) THEN
        osp$set_status_condition (ofe$line_too_long, status);
        RETURN; {----->
      IFEND;
      IF dd_p^.fields [i].incremental THEN
        incremental_field_count := incremental_field_count + 1;
      IFEND;
      IF (dd_p^.fields [i].field_selection <> ofc$fs_swapped) OR
            (dd_p^.fields [i].non_selection_action = ofc$nsa_blank) THEN
        IF dd_p^.fields [i].field_id = ofc$fi_fill THEN
          field_title := '';
        ELSE
          field_title := dd_p^.fields [i].field_title;
        IFEND;
        IF dd_p^.fields [i].field_id IN left_justified_fields THEN
          title (title_index, width) := field_title;
        ELSE
          title (title_index, width) := field_title (STRLENGTH (field_title) - width + 1, * );
        IFEND;
        title_index := title_index + width;
      IFEND;
    FOREND;

    IF incremental_field_count > ofc$max_incremental_fields THEN
      osp$set_status_condition (ofe$too_many_incremental_fields, status);
      RETURN; {----->
    IFEND;

    IF title_specified THEN
      title (2, * ) := dd_p^.header.title;
    IFEND;

    title_index := title_index - 1;
    IF dd_p^.header.jobs_per_line > 1 THEN
      IF (title_index * dd_p^.header.jobs_per_line - 1) > ofc$max_display_width THEN
        osp$set_status_condition (ofe$line_too_long, status);
        RETURN; {----->
      IFEND;
      FOR i := 1 TO dd_p^.header.jobs_per_line - 1 DO
        title (i * title_index + 1, title_index) := title (1, title_index);
      FOREND;
    IFEND;

    dd_p^.header.title := title;
    dd_p^.header.column_width := title_index;

  PROCEND verify_display_description;
?? TITLE := 'verify_unit_stat_display_desc', EJECT ??

{
{ PURPOSE:
{    This procedure is called after a display_description is completed. This
{    procedure checks whether the description is valid. Items verified include things
{    such as display_too_wide, etc.
{    This procedure also generates the display title if it was not explicitly specified.
{ INPUT:
{    ud_p - pointer to display description.
{    field_count - number of fields actually specified for the display
{    title_specified - boolean that indicates if the display TITLE was explicitly specified.
{ OUTPUT:
{    The following field are updated in the display decription:
{        title, column_width
{    status

  PROCEDURE verify_unit_stat_display_desc
    (    ud_p: ^oft$unit_stat_display_desc;
         field_count: oft$field_count;
         title_specified: boolean;
     VAR status: ost$status);

    VAR
      field_title: string (ofc$max_display_width),
      field_title_size: integer,
      i: oft$field_index,
      title: string (ofc$max_display_width),
      title_index: integer,
      width: 1 .. ofc$max_display_width;

    status.normal := TRUE;

    title_index := 2;
    title := ' ';
    FOR i := 1 TO field_count DO
      width := ud_p^.fields [i].width;
      IF (title_index + width) > (ofc$max_display_width + 2) THEN
        osp$set_status_condition (ofe$line_too_long, status);
        RETURN; {----->
      IFEND;

      IF (ud_p^.fields [i].field_selections = default_field_selections)
{      } OR (ud_p^.fields [i].field_selections = nil_field_selections)
{      } OR (ud_p^.fields [i].non_selection_action = ofc$nsa_blank) THEN
        IF ud_p^.fields [i].field_id = ofc$us_fill THEN
          field_title := '';
        ELSE
          field_title := ud_p^.fields [i].field_title;
        IFEND;

        field_title_size := STRLENGTH (field_title);
        WHILE (field_title_size > 1) AND (field_title (field_title_size) = ' ') DO
          field_title_size := field_title_size - 1;
        WHILEND;

        IF (ud_p^.fields [i].field_id IN us_left_justified_fields)
{     } OR (field_title_size >= width) THEN
          title (title_index, width) := field_title;
        ELSE
          title (title_index, width - field_title_size) := '';
          title (title_index + width - field_title_size, * ) := field_title (1, field_title_size);
          IF field_title_size > osc$max_name_size THEN
            ud_p^.fields [i].field_title := '';
            ud_p^.fields [i].field_title (osc$max_name_size - field_title_size + 1, * ) := field_title;
          IFEND;
        IFEND;
        title_index := title_index + width;
      IFEND;
    FOREND;

    IF title_specified THEN
      title (2, * ) := ud_p^.header.title;
    IFEND;

    title_index := title_index - 1;
    IF ud_p^.header.units_per_line > 1 THEN
      IF (title_index * ud_p^.header.units_per_line - 1) > ofc$max_display_width THEN
        osp$set_status_condition (ofe$line_too_long, status);
        RETURN; {----->
      IFEND;
      FOR i := 1 TO ud_p^.header.units_per_line - 1 DO
        title (i * title_index + 1, title_index) := title (1, title_index);
      FOREND;
    IFEND;

    ud_p^.header.title := title;
    ud_p^.header.column_width := title_index;

  PROCEND verify_unit_stat_display_desc;
?? TITLE := 'ofp$_change_init_job_display ', EJECT ??

{ PURPOSE:
{   Processes the CHANGE_INITIATED_JOB_DISPLAY command .
{

  PROCEDURE ofp$_change_init_job_display
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

*copyc ofd$pdt_change_init_job_display

    VAR
      count: oft$field_count,
      dd_p: ^oft$display_description,
      delta: integer,
      end_field_index: oft$field_index,
      field_id: oft$field_id,
      field_index: oft$field_index,
      field_count: oft$field_count,
      insertion_index: oft$field_index,
      list_data_value: ^clt$data_value,
      low_value: ost$name,
      high_value: ost$name,
      pvt_numbers: [STATIC, READ, oss$job_paged_literal] pvt_numbers_list :=
            [p$display_system_line, p$display_blank_lines, p$jobs_per_line, p$job_selection, p$title,
            p$alias],
      start_field_index: oft$field_index,
      title_specified: boolean;

    status.normal := TRUE;

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

    PUSH dd_p: [1 .. ofc$max_display_fields];

    dd_p^.header.display_name := pvt [p$name].value^.name_value;

    field_count := 0;
    ofp$access_display_description (ofc$adrc_get, dd_p, field_count, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;


    IF pvt [p$delete_fields].specified THEN
      delete_fields (pvt [p$delete_fields].value^.low_value^.name_value,
            pvt [p$delete_fields].value^.high_value^.name_value, dd_p, field_count, insertion_index, status);
    IFEND;

    IF pvt [p$replace_fields].specified THEN
      delete_fields (pvt [p$replace_fields].value^.low_value^.name_value,
            pvt [p$replace_fields].value^.high_value^.name_value, dd_p, field_count, insertion_index, status);
    IFEND;

    count := $INTEGER (pvt [p$replace_fields].specified) + $INTEGER (pvt [p$insert_before].specified) +
          $INTEGER (pvt [p$insert_after].specified);
    IF (count = 0) THEN
      IF pvt [p$fields].specified THEN
        osp$set_status_condition (ofe$no_field_placement, status);
        RETURN; {----->
      IFEND;
    ELSEIF count > 1 THEN
      osp$set_status_condition (ofe$multiple_field_placement, status);
      RETURN; {----->
    ELSEIF NOT pvt [p$fields].specified THEN
      osp$set_status_condition (ofe$field_must_be_specified, status);
      RETURN; {----->
    IFEND;

    IF pvt [p$insert_after].specified THEN
      conv_field_name_to_descr_index (pvt [p$insert_after].value^.name_value, dd_p, field_count, 1,
            insertion_index, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;
      insertion_index := insertion_index + 1;
    ELSEIF pvt [p$insert_before].specified THEN
      conv_field_name_to_descr_index (pvt [p$insert_before].value^.name_value, dd_p, field_count, 1,
            insertion_index, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;
    IFEND;

    count := 0;
    list_data_value := pvt [p$fields].value;
    WHILE list_data_value <> NIL DO
      count := count + 1;
      list_data_value := list_data_value^.link;
    WHILEND;


    IF count > 0 THEN
      FOR field_index := field_count DOWNTO insertion_index DO
        dd_p^.fields [field_index + count] := dd_p^.fields [field_index];
      FOREND;
      field_count := field_count + count;

      process_field_descriptions (pvt [p$fields].value, dd_p, insertion_index, count, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;
    IFEND;

    process_header_parameters (pvt, pvt_numbers, FALSE {accept defaults} , dd_p, title_specified);

    verify_display_description (dd_p, field_count, title_specified, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF field_count = 0 THEN
      osp$set_status_condition (ofe$display_must_have_fields, status);
    ELSE
      ofp$access_display_description (ofc$adrc_change, dd_p, field_count, status);
    IFEND;

  PROCEND ofp$_change_init_job_display;
?? TITLE := 'ofp$_change_unit_stat_display', EJECT ??

{ PURPOSE:
{   Processes the CHANGE_UNIT_STATISTIC_DISPLAY command .
{

  PROCEDURE ofp$_change_unit_stat_display
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

*copyc ofd$pdt_change_unitstat_display

    VAR
      pvt_numbers: [STATIC, READ, oss$job_paged_literal] pvt_numbers_list := [
{ P$US_DISPLAY_SYSTEM_LINE             } p$display_system_line,
{ P$US_DISPLAY_BLANK_LINES             } p$display_blank_lines,
{ P$US_UNITS_PER_LINE                  } p$units_per_line,
{ P$US_INCREMENTAL_RESET_FREQ          } p$incremental_reset_frequency,
{ P$US_TITLE                           } p$title,
{ P$US_ALIAS                           } p$alias];

    VAR
      count: oft$field_count,
      ud_p: ^oft$unit_stat_display_desc,
      delta: integer,
      end_field_index: oft$field_index,
      field_id: oft$field_id,
      field_index: oft$field_index,
      field_count: oft$field_count,
      insertion_index: oft$field_index,
      list_data_value: ^clt$data_value,
      low_value: ost$name,
      high_value: ost$name,
      start_field_index: oft$field_index,
      title_specified: boolean;

    status.normal := TRUE;

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

    PUSH ud_p: [1 .. ofc$max_display_fields];

    ud_p^.header.display_name := pvt [p$name].value^.name_value;

    field_count := 0;
    ofp$access_unit_stat_descript (ofc$adrc_get, ud_p, field_count, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;


    IF pvt [p$delete_fields].specified THEN
      delete_us_fields (pvt [p$delete_fields].value^.low_value^.name_value,
            pvt [p$delete_fields].value^.high_value^.name_value, ud_p, field_count, insertion_index, status);
    IFEND;

    IF pvt [p$replace_fields].specified THEN
      delete_us_fields (pvt [p$replace_fields].value^.low_value^.name_value,
            pvt [p$replace_fields].value^.high_value^.name_value, ud_p, field_count, insertion_index, status);
    IFEND;

    count := $INTEGER (pvt [p$replace_fields].specified) + $INTEGER (pvt [p$insert_before].specified) +
          $INTEGER (pvt [p$insert_after].specified);
    IF (count = 0) THEN
      IF pvt [p$fields].specified THEN
        osp$set_status_condition (ofe$no_field_placement, status);
        RETURN; {----->
      IFEND;
    ELSEIF count > 1 THEN
      osp$set_status_condition (ofe$multiple_field_placement, status);
      RETURN; {----->
    ELSEIF NOT pvt [p$fields].specified THEN
      osp$set_status_condition (ofe$field_must_be_specified, status);
      RETURN; {----->
    IFEND;

    IF pvt [p$insert_after].specified THEN
      conv_us_field_name_to_desc_idx (pvt [p$insert_after].value^.name_value, ud_p, field_count, 1,
            insertion_index, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;
      insertion_index := insertion_index + 1;
    ELSEIF pvt [p$insert_before].specified THEN
      conv_us_field_name_to_desc_idx (pvt [p$insert_before].value^.name_value, ud_p, field_count, 1,
            insertion_index, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;
    IFEND;

    count := 0;
    list_data_value := pvt [p$fields].value;
    WHILE list_data_value <> NIL DO
      count := count + 1;
      list_data_value := list_data_value^.link;
    WHILEND;


    IF count > 0 THEN
      FOR field_index := field_count DOWNTO insertion_index DO
        ud_p^.fields [field_index + count] := ud_p^.fields [field_index];
      FOREND;
      field_count := field_count + count;

      process_us_field_descriptions (pvt [p$fields].value, ud_p, insertion_index, count, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;
    IFEND;

    process_us_header_parameters (pvt, pvt_numbers, FALSE {accept defaults} , ud_p, title_specified);

    verify_unit_stat_display_desc (ud_p, field_count, title_specified, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF field_count = 0 THEN
      osp$set_status_condition (ofe$display_must_have_fields, status);
    ELSE
      ofp$access_unit_stat_descript (ofc$adrc_change, ud_p, field_count, status);
    IFEND;

  PROCEND ofp$_change_unit_stat_display;

?? TITLE := 'ofp$_change_ms_display', EJECT ??

  PROCEDURE ofp$_change_ms_display
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

*copyc ofd$pdt_change_ms_display

    TYPE
      t$mass_storage_display_screens = set of oft$mass_storage_display_screen;

    VAR
      count: integer,
      display_options: oft$msdi_display_options,
      mass_storage_display_infos: oft$mass_storage_display_infos,
      node_p: ^clt$data_value,
      screen: oft$mass_storage_display_screen,
      screens: t$mass_storage_display_screens,
      sort_option: oft$msdi_sort_option,
      value_p: ^clt$data_value,
      work_area_pp: ^^clt$work_area;

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

    screens := $t$mass_storage_display_screens [];
    node_p := pvt [p$display_screens].value;
    WHILE (node_p <> NIL) AND (node_p^.kind = clc$list) DO
      value_p := node_p^.element_value;
      IF (value_p <> NIL) AND (value_p^.kind = clc$keyword) THEN
        IF value_p^.keyword_value = 'MASS_STORAGE' THEN
          screens := screens + $t$mass_storage_display_screens [ofc$ved_ms];
        ELSEIF value_p^.keyword_value = 'MASS_STORAGE_SPACE' THEN
          screens := screens + $t$mass_storage_display_screens [ofc$ved_mss];
        ELSEIF value_p^.keyword_value = 'MASS_STORAGE_USAGE' THEN
          screens := screens + $t$mass_storage_display_screens [ofc$ved_msu];
        IFEND;
      IFEND;

      node_p := node_p^.link;
    WHILEND;

    clp$get_work_area (#RING (^work_area_pp), work_area_pp, status);
    IF NOT status.normal THEN
      RETURN {----->
    IFEND;

    ofp$access_ms_display_infos (ofc$adrc_get, work_area_pp^, mass_storage_display_infos, status);
    IF NOT status.normal THEN
      RETURN {----->
    IFEND;

    FOR screen := LOWERVALUE (screen) TO UPPERVALUE (screen) DO
      IF screen IN screens THEN
        IF pvt [p$display_options].value <> NIL THEN
          node_p := pvt [p$display_options].value;
          IF node_p^.kind = clc$keyword THEN
            IF node_p^.keyword_value = 'ALL' THEN
              display_options.default := FALSE;
              display_options.values := -$oft$msdi_display_option_values [];
            ELSEIF node_p^.keyword_value = 'NONE' THEN
              display_options.default := FALSE;
              display_options.values := $oft$msdi_display_option_values [];
            ELSE {Default
              display_options.default := TRUE;
              display_options.values := $oft$msdi_display_option_values [];
            IFEND;
          ELSE
            display_options.default := FALSE;
            display_options.values := $oft$msdi_display_option_values [];
            WHILE (node_p <> NIL) AND (node_p^.kind = clc$list) DO
              value_p := node_p^.element_value;
              IF (value_p <> NIL) AND (value_p^.kind = clc$keyword) THEN
                IF value_p^.keyword_value = 'TOTAL' THEN
                  display_options.values := display_options.values +
                        $oft$msdi_display_option_values [ofc$msdi_total];
                ELSEIF value_p^.keyword_value = 'VOLUME_STATUS_SUMMARY' THEN
                  display_options.values := display_options.values +
                        $oft$msdi_display_option_values [ofc$msdi_volume_status_summary];
                ELSEIF value_p^.keyword_value = 'CLASSES_OUT_OF_SPACE' THEN
                  display_options.values := display_options.values +
                        $oft$msdi_display_option_values [ofc$msdi_classes_out_of_space];
                ELSEIF value_p^.keyword_value = 'CRITICAL_CLASS_ADDED_COUNT' THEN
                  display_options.values := display_options.values +
                        $oft$msdi_display_option_values [ofc$msdi_crit_class_added_count];
                IFEND;
              IFEND;

              node_p := node_p^.link;
            WHILEND;
          IFEND;
          mass_storage_display_infos [screen].display_options := display_options;
        IFEND;

        IF pvt [p$sort_option].value <> NIL THEN
          sort_option.saved_sort_option := FALSE;
          sort_option.key := ofc$msdi_avt;
          node_p := pvt [p$sort_option].value;
          IF node_p^.kind = clc$keyword THEN
            IF node_p^.keyword_value = 'DEFAULT' THEN
              sort_option.key := ofc$msdi_avt;
            ELSEIF node_p^.keyword_value = 'LOGICAL_UNIT_TABLE' THEN
              sort_option.key := ofc$msdi_lut;
            ELSE {recorded_vsn
              sort_option.key := ofc$msdi_vsn;
            IFEND;
          ELSEIF node_p^.field_values <> NIL THEN
            sort_option.key := ofc$msdi_user_defined;
            sort_option.entries_p := NIL;
            sort_option.sorted_by_vsn := FALSE;
            value_p := node_p^.field_values^ [2].value;
            IF value_p <> NIL THEN
              sort_option.display_omitted_units := value_p^.boolean_value.value;
            ELSE
              sort_option.display_omitted_units := TRUE;
            IFEND;

            node_p := node_p^.field_values^ [1].value;
            count := clp$count_list_elements (node_p);
            NEXT sort_option.entries_p: [1 .. count] IN work_area_pp^;
            IF sort_option.entries_p = NIL THEN
              osp$set_status_abnormal ('CL', cle$work_area_overflow, 'CHANGE_MASS_STORAGE_DISPLAY', status);
              RETURN; {----->
            IFEND;

            count := 1;
            WHILE (node_p <> NIL) AND (node_p^.kind = clc$list) DO
              value_p := node_p^.element_value;
              IF value_p <> NIL THEN
                sort_option.entries_p^ [count].vsn := value_p^.name_value;
                sort_option.entries_p^ [count].avt_index := 0;
                count := count + 1;
              IFEND;

              node_p := node_p^.link;
            WHILEND;
          IFEND;
          mass_storage_display_infos [screen].sort_option := sort_option;
        IFEND;

        IF pvt [p$space_quantity].value <> NIL THEN
          IF pvt [p$space_quantity].value^.keyword_value = 'DEFAULT' THEN
            mass_storage_display_infos [screen].space_quantity := ofc$msdi_default_space_quantity;
          ELSEIF pvt [p$space_quantity].value^.keyword_value = 'DEVICE_ALLOCATION_UNITS' THEN
            mass_storage_display_infos [screen].space_quantity := ofc$msdi_dau;
          ELSEIF pvt [p$space_quantity].value^.keyword_value = 'MEGA_BYTES' THEN
            mass_storage_display_infos [screen].space_quantity := ofc$msdi_mbytes;
          IFEND;
        IFEND;

        IF pvt [p$space_selection].value <> NIL THEN
          IF pvt [p$space_selection].value^.keyword_value = 'DEFAULT' THEN
            mass_storage_display_infos [screen].space_selection := ofc$msdi_default_space_select;
          ELSEIF pvt [p$space_selection].value^.keyword_value = 'MAINFRAME_AND_DEVICE_ALLOCATION' THEN
            mass_storage_display_infos [screen].space_selection := ofc$msdi_mat_dat;
          ELSEIF pvt [p$space_selection].value^.keyword_value = 'CAPACITY_AND_AVAILABLE' THEN
            mass_storage_display_infos [screen].space_selection := ofc$msdi_capacity_available;
          IFEND;
        IFEND;
      IFEND;
    FOREND;

    ofp$access_ms_display_infos (ofc$adrc_change, work_area_pp^, mass_storage_display_infos, status);

  PROCEND ofp$_change_ms_display;
?? TITLE := 'ofp$_create_init_job_display ', EJECT ??

{ PURPOSE:
{   Processes the CREATE_INITIATED_JOB_DISPLAY command.
{

  PROCEDURE ofp$_create_init_job_display
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

*copyc ofd$pdt_create_init_job_display

    VAR
      dd_p: ^oft$display_description,
      field_count: oft$field_count,
      pvt_numbers: [STATIC, READ, oss$job_paged_literal] pvt_numbers_list :=
            [p$display_system_line, p$display_blank_lines, p$jobs_per_line, p$job_selection, p$title,
            p$alias],
      title_specified: boolean;

    status.normal := TRUE;

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

    IF pvt [p$fields].specified AND pvt [p$same_as].specified THEN
      osp$set_status_condition (ofe$same_as_and_field_error, status);
      RETURN; {----->
    IFEND;

    PUSH dd_p: [1 .. ofc$max_display_fields];

    IF pvt [p$fields].specified THEN
      process_field_descriptions (pvt [p$fields].value, dd_p, 1, field_count, status);
    ELSEIF pvt [p$same_as].specified THEN
      dd_p^.header.display_name := pvt [p$same_as].value^.name_value;
      field_count := 0;
      ofp$access_display_description (ofc$adrc_get, dd_p, field_count, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;
    ELSE
      osp$set_status_condition (ofe$display_must_have_fields, status);
    IFEND;
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    dd_p^.header.display_name := pvt [p$name].value^.name_value;
    dd_p^.header.display_name_abbrev := dd_p^.header.display_name;

    process_header_parameters (pvt, pvt_numbers, NOT pvt [p$same_as].specified, dd_p, title_specified);

    verify_display_description (dd_p, field_count, title_specified, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    ofp$access_display_description (ofc$adrc_create, dd_p, field_count, status);

  PROCEND ofp$_create_init_job_display;
?? TITLE := 'ofp$_create_unit_stat_display', EJECT ??

{ PURPOSE:
{   Processes the CREATE_UNIT_STATISTIC_DISPLAY command .
{

  PROCEDURE ofp$_create_unit_stat_display
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

*copyc ofd$pdt_create_unitstat_display

    VAR
      pvt_numbers: [STATIC, READ, oss$job_paged_literal] pvt_numbers_list := [
{ P$US_DISPLAY_SYSTEM_LINE             } p$display_system_line,
{ P$US_DISPLAY_BLANK_LINES             } p$display_blank_lines,
{ P$US_UNITS_PER_LINE                  } p$units_per_line,
{ P$US_INCREMENTAL_RESET_FREQ          } p$incremental_reset_frequency,
{ P$US_TITLE                           } p$title,
{ P$US_ALIAS                           } p$alias];

    VAR
      title_specified: boolean,
      field_count: oft$field_count,
      ud_p: ^oft$unit_stat_display_desc;

    status.normal := TRUE;

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

    IF pvt [p$fields].specified AND pvt [p$same_as].specified THEN
      osp$set_status_condition (ofe$same_as_and_field_error, status);
      RETURN; {----->
    IFEND;

    PUSH ud_p: [1 .. ofc$max_display_fields];

    IF pvt [p$fields].specified THEN
      process_us_field_descriptions (pvt [p$fields].value, ud_p, 1, field_count, status);
    ELSEIF pvt [p$same_as].specified THEN
      ud_p^.header.display_name := pvt [p$same_as].value^.name_value;
      field_count := 0;
      ofp$access_unit_stat_descript (ofc$adrc_get, ud_p, field_count, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;
    ELSE
      osp$set_status_condition (ofe$display_must_have_fields, status);
    IFEND;
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    evaluate_disk_stats_selectors (pvt [p$unit_selections].value, ud_p^.header.unit_selection, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    ud_p^.header.display_name := pvt [p$name].value^.name_value;
    ud_p^.header.display_name_abbrev := ud_p^.header.display_name;

    process_us_header_parameters (pvt, pvt_numbers, NOT pvt [p$same_as].specified, ud_p, title_specified);

    verify_unit_stat_display_desc (ud_p, field_count, title_specified, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF field_count = 0 THEN
      osp$set_status_condition (ofe$display_must_have_fields, status);
    ELSE
      ofp$access_unit_stat_descript (ofc$adrc_create, ud_p, field_count, status);
    IFEND;

  PROCEND ofp$_create_unit_stat_display;
?? TITLE := 'ofp$_delete_init_job_display ', EJECT ??

{ PURPOSE:
{   Processes the DELETE_INITIATED_JOB_DISPLAY command.
{

  PROCEDURE ofp$_delete_init_job_display
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

*copyc ofd$pdt_delete_init_job_display

    VAR
      dd_p: ^oft$display_description,
      field_count: oft$field_count,
      ud_p: ^oft$unit_stat_display_desc;

    status.normal := TRUE;

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

    PUSH dd_p: [1 .. 1];
    PUSH ud_p: [1 .. 1];

    dd_p^.header.display_name := pvt [p$name].value^.name_value;
    ud_p^.header.display_name := pvt [p$name].value^.name_value;

    ofp$access_display_description (ofc$adrc_delete, dd_p, field_count, status);
    IF NOT status.normal THEN
      IF status.condition = ofe$alternate_display_exists THEN
        ofp$access_unit_stat_descript (ofc$adrc_delete, ud_p, field_count, status);
      ELSE
        RETURN; {----->
      IFEND;
    IFEND;

  PROCEND ofp$_delete_init_job_display;

?? TITLE := 'ofp$_display_ms_display', EJECT ??

  PROCEDURE ofp$_display_ms_display
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

*copyc ofd$pdt_display_ms_display
*copy clv$display_variables

    VAR
      v$screen_name: [STATIC, oss$job_paged_literal, READ] array [oft$mass_storage_display_screen] of
            string (18) := ['Mass_Storage', 'Mass_Storage_Space', 'Mass_Storage_Usage'];

    VAR
      default_ring_attributes: amt$ring_attributes,
      display_control: clt$display_control,
      display_option: oft$msdi_display_option_value,
      display_options_count: integer,
      display_options_displayed: integer,
      line: ost$string,
      local_status: ost$status,
      mass_storage_display_infos: oft$mass_storage_display_infos,
      screen: oft$mass_storage_display_screen,
      work_area_pp: ^^clt$work_area;

?? OLDTITLE ??
?? NEWTITLE := 'abort_handler', EJECT ??

    PROCEDURE abort_handler
      (    condition: pmt$condition;
           condition_information: ^pmt$condition_information;
           save_area: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      VAR
        ignore_status: ost$status;

      clp$close_display (display_control, ignore_status);

    PROCEND abort_handler;

*copy clp$new_page_procedure

?? OLDTITLE ??
?? NEWTITLE := '[inline] put_subtitle', EJECT ??

    PROCEDURE [INLINE] put_line
      (    str: string ( * ));

      clp$put_display (display_control, str, clc$no_trim, status);

    PROCEND put_line;
?? OLDTITLE ??
?? NEWTITLE := '    put_subtitle', EJECT ??

    PROCEDURE put_subtitle
      (VAR display_control: clt$display_control;
       VAR status: ost$status);

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

    clp$get_work_area (#RING (^work_area_pp), work_area_pp, status);
    IF NOT status.normal THEN
      RETURN {----->
    IFEND;

    ofp$access_ms_display_infos (ofc$adrc_get, work_area_pp^, mass_storage_display_infos, status);
    IF NOT status.normal THEN
      RETURN {----->
    IFEND;

  /display_ms_display/
    BEGIN
      display_control := clv$nil_display_control;
      #SPOIL (display_control);
      osp$establish_block_exit_hndlr (^abort_handler);
      default_ring_attributes.r1 := #RING (^default_ring_attributes);
      default_ring_attributes.r2 := #RING (^default_ring_attributes);
      default_ring_attributes.r3 := #RING (^default_ring_attributes);
      clp$open_display_reference (pvt [p$output].value^.file_value^, ^clp$new_page_procedure, fsc$list,
            default_ring_attributes, display_control, status);
      IF NOT status.normal THEN
        EXIT /display_ms_display/; {----->
      IFEND;

      clv$titles_built := FALSE;
      clv$command_name := 'DISPLAY_MASS_STORAGE_DISPLAY';

      IF display_control.page_width < clc$narrow_page_width THEN
        clv$page_width := clc$narrow_page_width;
      ELSEIF display_control.page_width > clc$wide_page_width THEN
        clv$page_width := clc$wide_page_width;
      ELSE
        clv$page_width := display_control.page_width;
      IFEND;

      FOR screen := LOWERVALUE (screen) TO UPPERVALUE (screen) DO
        fip#addl_initialize (line, 'Display_Screen_Name     : ');
        fip#addl_string (line, v$screen_name [screen]);

        put_line (line.value (1, line.size));
        IF NOT status.normal THEN
          EXIT /display_ms_display/; {----->
        IFEND;

        display_options_count := 0;
        display_options_displayed := 0;
        FOR display_option := LOWERVALUE (oft$msdi_display_option_value)
              TO UPPERVALUE (oft$msdi_display_option_value) DO
          IF display_option IN mass_storage_display_infos [screen].display_options.values THEN
            display_options_count := display_options_count + 1;
          IFEND;
        FOREND;

        IF display_options_count = 0 THEN
          put_line ('  Display_Options       : None');
        ELSE
          IF display_options_count = 1 THEN
            fip#addl_initialize (line, '  Display_Options       : ');
          ELSE
            fip#addl_initialize (line, '  Display_Options       : (');
          IFEND;
          FOR display_option := LOWERVALUE (oft$msdi_display_option_value)
                TO UPPERVALUE (oft$msdi_display_option_value) DO
            IF display_option IN mass_storage_display_infos [screen].display_options.values THEN
              CASE display_option OF
              = ofc$msdi_total =
                fip#addl_string (line, 'Total');
              = ofc$msdi_volume_status_summary =
                fip#addl_string (line, 'Volume_Status_Summary');
              = ofc$msdi_classes_out_of_space =
                fip#addl_string (line, 'Classes_Out_Of_Space');
              = ofc$msdi_crit_class_added_count =
                fip#addl_string (line, 'Critical_Class_Added_Count');
              ELSE
              CASEND;

              display_options_displayed := display_options_displayed + 1;
              IF display_options_count <> display_options_displayed THEN
                fip#addl_string (line, ', ');
              ELSEIF display_options_count <> 1 THEN
                fip#addl_string (line, ')');
              IFEND;

              put_line (line.value (1, line.size));

              fip#addl_initialize (line, '                           ');
            IFEND;
          FOREND;
        IFEND;

        fip#addl_initialize (line, '  Sort_Option           : ');
        CASE mass_storage_display_infos [screen].sort_option.key OF
        = ofc$msdi_avt =
          fip#addl_string (line, 'Active_Volume_Table');
          put_line (line.value (1, line.size));

        = ofc$msdi_lut =
          fip#addl_string (line, 'Logical_Unit_Table');
          put_line (line.value (1, line.size));

        = ofc$msdi_vsn =
          fip#addl_string (line, 'Recorded_VSN');
          put_line (line.value (1, line.size));

        = ofc$msdi_user_defined =
          put_line (line.value (1, line.size));

          fip#addl_initialize (line, '  Display_Omitted_Units : ');
          IF mass_storage_display_infos [screen].sort_option.display_omitted_units THEN
            fip#addl_string (line, 'TRUE');
          ELSE
            fip#addl_string (line, 'FALSE');
          IFEND;

          put_line (line.value (1, line.size));

          IF mass_storage_display_infos [screen].sort_option.entries_p = NIL THEN
            display_options_count := 0;
          ELSE
            display_options_count := UPPERBOUND (mass_storage_display_infos [screen].sort_option.entries_p^)
          IFEND;

          IF display_options_count = 0 THEN
            fip#addl_initialize (line, '  VSN_List              : NONE');
            put_line (line.value (1, line.size));
          ELSEIF display_options_count = 1 THEN
            fip#addl_initialize (line, '  VSN_List              : ');
          ELSE
            fip#addl_initialize (line, '  VSN_List              : (');
          IFEND;

          FOR display_options_displayed := 1 TO display_options_count DO
            fip#addl_string (line, mass_storage_display_infos [screen].
                  sort_option.entries_p^ [display_options_displayed].vsn);
            IF (display_options_displayed = display_options_count) AND (display_options_displayed <> 1) THEN
              fip#addl_string (line, ')');
            IFEND;
            put_line (line.value (1, line.size));
            fip#addl_initialize (line, '                           ');
          FOREND;
        ELSE
        CASEND;

        fip#addl_initialize (line, '  Space_Quantity        : ');
        CASE mass_storage_display_infos [screen].space_quantity OF
        = ofc$msdi_default_space_quantity =
          fip#addl_string (line, 'Default');
        = ofc$msdi_dau =
          fip#addl_string (line, 'Device_Allocation_Units');
        = ofc$msdi_mbytes =
          fip#addl_string (line, 'Mega_Bytes');
        ELSE
        CASEND;
        put_line (line.value (1, line.size));

        fip#addl_initialize (line, '  Space_Selection       : ');
        CASE mass_storage_display_infos [screen].space_selection OF
        = ofc$msdi_default_space_select =
          fip#addl_string (line, 'Default');
        = ofc$msdi_mat_dat =
          fip#addl_string (line, 'Mainframe_And_Device_Allocation');
        = ofc$msdi_capacity_available =
          fip#addl_string (line, 'Capacity_And_Available');
        ELSE
        CASEND;

        put_line (line.value (1, line.size));
      FOREND;
    END /display_ms_display/;

    clp$close_display (display_control, local_status);
    IF status.normal AND (NOT local_status.normal) THEN
      status := local_status;
    IFEND;
    osp$disestablish_cond_handler;

  PROCEND ofp$_display_ms_display;
?? NEWTITLE := 'ofp$_display_site_ved_names ', EJECT ??

{ PURPOSE:
{   Processes the DISPLAY_SITE_VED_NAMES command.
{

  PROCEDURE [XDCL, #GATE] ofp$_display_site_ved_names
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{ PROCEDURE (osm$dissvn) display_site_ved_names, dissvn (
{   display_option, do: key
{       (brief, b)
{       (full, all, f, a)
{     keyend = brief
{   output, o: file = $output
{   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,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 6] of clt$keyword_specification,
        default_value: string (5),
      recend,
      type2: record
        header: clt$type_specification_header,
        default_value: string (7),
      recend,
      type3: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [99, 3, 10, 14, 16, 20, 948],
    clc$command, 5, 3, 0, 0, 0, 0, 3, 'OSM$DISSVN'], [
    ['DISPLAY_OPTION                 ',clc$nominal_entry, 1],
    ['DO                             ',clc$abbreviation_entry, 1],
    ['O                              ',clc$abbreviation_entry, 2],
    ['OUTPUT                         ',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, 229,
  clc$optional_default_parameter, 0, 5],
{ 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, 7],
{ 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$keyword_type], [6], [
    ['A                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
    ['ALL                            ', clc$alias_entry, clc$normal_usage_entry, 2],
    ['B                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
    ['BRIEF                          ', clc$nominal_entry, clc$normal_usage_entry, 1],
    ['F                              ', clc$alias_entry, clc$normal_usage_entry, 2],
    ['FULL                           ', clc$nominal_entry, clc$normal_usage_entry, 2]]
    ,
    'brief'],
{ PARAMETER 2
    [[1, 0, clc$file_type],
    '$output'],
{ PARAMETER 3
    [[1, 0, clc$status_type]]];

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

    CONST
      p$display_option = 1,
      p$output = 2,
      p$status = 3;

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

*copy clv$display_variables

    VAR
      default_ring_attributes: amt$ring_attributes,
      display_control: clt$display_control,
      local_status: ost$status;

?? OLDTITLE ??
?? NEWTITLE := 'abort_handler', EJECT ??

    PROCEDURE abort_handler
      (    condition: pmt$condition;
           condition_information: ^pmt$condition_information;
           save_area: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      VAR
        ignore_status: ost$status;

      clp$close_display (display_control, ignore_status);

    PROCEND abort_handler;

*copy clp$new_page_procedure

?? OLDTITLE ??
?? NEWTITLE := '    put_subtitle', EJECT ??

    PROCEDURE put_subtitle
      (VAR display_control: clt$display_control;
       VAR status: ost$status);

{ The display_site_ved_names command has no subtitles, this
{ is merely a dummy routine used to keep the module consistent
{ with those that do produce subtitles.

    PROCEND put_subtitle;

?? OLDTITLE ??
    status.normal := TRUE;

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

  /display_site_ved_names/
    BEGIN
      display_control := clv$nil_display_control;
      #SPOIL (display_control);
      osp$establish_block_exit_hndlr (^abort_handler);
      default_ring_attributes.r1 := #RING (^default_ring_attributes);
      default_ring_attributes.r2 := #RING (^default_ring_attributes);
      default_ring_attributes.r3 := #RING (^default_ring_attributes);
      clp$open_display_reference (pvt [p$output].value^.file_value^, ^clp$new_page_procedure, fsc$list,
            default_ring_attributes, display_control, status);
      IF NOT status.normal THEN
        EXIT /display_site_ved_names/; {----->
      IFEND;
      clv$titles_built := FALSE;
      clv$command_name := 'DISPLAY_SITE_VED_NAMES';

      IF display_control.page_width < clc$narrow_page_width THEN
        clv$page_width := clc$narrow_page_width;
      ELSEIF display_control.page_width > clc$wide_page_width THEN
        clv$page_width := clc$wide_page_width;
      ELSE
        clv$page_width := display_control.page_width;
      IFEND;

      ofp$display_site_ved_names (display_control, pvt [p$display_option].value^.keyword_value = 'FULL',
            status);

    END /display_site_ved_names/;

    clp$close_display (display_control, local_status);
    IF status.normal AND (NOT local_status.normal) THEN
      status := local_status;
    IFEND;
    osp$disestablish_cond_handler;
  PROCEND ofp$_display_site_ved_names;

?? NEWTITLE := 'ofp$_display_ved_definition', EJECT ??

  PROCEDURE [XDCL, #GATE] ofp$_display_ved_definition
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{ PROCEDURE display_ved_definition, disvd (
{   name, n: name = $required
{   display_option, do: key
{       (elements, e)
{       (source, s)
{     keyend = elements
{   output, o: file = $output
{   status)

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

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 7] of clt$pdt_parameter_name,
      parameters: array [1 .. 4] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
        qualifier: clt$name_type_qualifier,
      recend,
      type2: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 4] of clt$keyword_specification,
        default_value: string (8),
      recend,
      type3: record
        header: clt$type_specification_header,
        default_value: string (7),
      recend,
      type4: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [99, 10, 22, 17, 2, 10, 808],
    clc$command, 7, 4, 1, 0, 0, 0, 4, ''], [
    ['DISPLAY_OPTION                 ',clc$nominal_entry, 2],
    ['DO                             ',clc$abbreviation_entry, 2],
    ['N                              ',clc$abbreviation_entry, 1],
    ['NAME                           ',clc$nominal_entry, 1],
    ['O                              ',clc$abbreviation_entry, 3],
    ['OUTPUT                         ',clc$nominal_entry, 3],
    ['STATUS                         ',clc$nominal_entry, 4]],
    [
{ PARAMETER 1
    [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, 5, clc$required_parameter, 0
  , 0],
{ PARAMETER 2
    [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, 155,
  clc$optional_default_parameter, 0, 8],
{ PARAMETER 3
    [6, 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, 7],
{ PARAMETER 4
    [7, 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$name_type], [1, osc$max_name_size]],
{ PARAMETER 2
    [[1, 0, clc$keyword_type], [4], [
    ['E                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
    ['ELEMENTS                       ', clc$nominal_entry, clc$normal_usage_entry, 1],
    ['S                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
    ['SOURCE                         ', clc$nominal_entry, clc$normal_usage_entry, 2]]
    ,
    'elements'],
{ PARAMETER 3
    [[1, 0, clc$file_type],
    '$output'],
{ PARAMETER 4
    [[1, 0, clc$status_type]]];

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

    CONST
      p$name = 1,
      p$display_option = 2,
      p$output = 3,
      p$status = 4;

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

*copy clv$display_variables

    CONST
      c$comma = ',',
      c$dot = ' ..',
      c$quote = '''',
      c$unspecified = '"UNSPECIFIED"';

    VAR
      dd_p: ^oft$display_description,
      default_ring_attributes: amt$ring_attributes,
      display_control: clt$display_control,
      display_option_is_source: boolean,
      field_count: oft$field_count,
      status_p: ^ost$status,
      ud_p: ^oft$unit_stat_display_desc;

?? NEWTITLE := 'abort_handler', EJECT ??

    PROCEDURE abort_handler
      (    condition: pmt$condition;
           condition_information: ^pmt$condition_information;
           save_area: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      VAR
        ignore_status: ost$status;

      clp$close_display (display_control, ignore_status);

    PROCEND abort_handler;
?? OLDTITLE ??
*copy clp$new_page_procedure
?? OLDTITLE ??
?? NEWTITLE := '    put_subtitle', EJECT ??

    PROCEDURE put_subtitle
      (VAR display_control: clt$display_control;
       VAR status: ost$status);

{ The display_site_ved_names command has no subtitles, this
{ is merely a dummy routine used to keep the module consistent
{ with those that do produce subtitles.

    PROCEND put_subtitle;
?? OLDTITLE ??
?? NEWTITLE := 'p$display_dd_display', EJECT ??

    PROCEDURE p$display_dd_display
      (    dd_p: ^oft$display_description;
       VAR display_control: clt$display_control;
       VAR status: ost$status);

      VAR
        field_index: integer,
        name: ost$name,
        str: ost$string;

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

      PROCEDURE [INLINE] p$put_line
        (VAR str: ost$string);

        clp$put_display (display_control, str.value (1, str.size), clc$trim, status);
        IF NOT status.normal THEN
          EXIT p$display_dd_display; {----->
        IFEND;

      PROCEND p$put_line;
?? OLDTITLE ??
?? EJECT ??
      fip#addl_initialize (str, 'Display Type           : Initiated Job Display');
      p$put_line (str);
      IF dd_p = NIL THEN
        fip#addl_initialize (str, 'No Data defined');
        p$put_line (str);
        RETURN; {----->
      IFEND;

{Header
      fip#addl_initialize (str, 'Name                   : ');
      fip#addl_string (str, dd_p^.header.display_name);
      p$put_line (str);

      fip#addl_initialize (str, 'Abbreviation           : ');
      fip#addl_string (str, dd_p^.header.display_name_abbrev);
      p$put_line (str);

      fip#addl_initialize (str, 'Title                  : ');
      fip#addl_string (str, dd_p^.header.title);
      p$put_line (str);

      fip#addl_initialize (str, 'Jobs per Line          : ');
      fip#addl_integer (str, dd_p^.header.jobs_per_line, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;
      p$put_line (str);

      fip#addl_initialize (str, 'Column Width           : ');
      fip#addl_integer (str, dd_p^.header.column_width, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;
      p$put_line (str);

      fip#addl_initialize (str, 'Job Selection          : ');
      IF dd_p^.header.job_selection = ofc$js_active THEN
        fip#addl_string (str, 'Active');
      ELSEIF dd_p^.header.job_selection = ofc$js_initiated THEN
        fip#addl_string (str, 'Initiated');
      ELSE
        fip#addl_string (str, '<Improver Value>');
      IFEND;
      p$put_line (str);

      fip#addl_initialize (str, 'Display Blank Lines    : ');
      IF dd_p^.header.display_blank_lines THEN
        fip#addl_string (str, 'TRUE');
      ELSE
        fip#addl_string (str, 'FALSE');
      IFEND;
      p$put_line (str);

      fip#addl_initialize (str, 'Display System Line    : ');
      IF dd_p^.header.display_system_line THEN
        fip#addl_string (str, 'TRUE');
      ELSE
        fip#addl_string (str, 'FALSE');
      IFEND;
      p$put_line (str);

      fip#addl_initialize (str, 'Field Count            : ');
      fip#addl_integer (str, dd_p^.header.field_count, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;
      p$put_line (str);

      FOR field_index := 1 TO dd_p^.header.field_count DO
        fip#addl_initialize (str, '');
        p$put_line (str);
        fip#addl_integer (str, field_index, status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
        p$put_line (str);

        fip#addl_initialize (str, '  Field ID             : ');
        convert_field_id_to_name (dd_p^.fields [field_index].field_id, name);
        fip#addl_string (str, name);
        p$put_line (str);

        fip#addl_initialize (str, '  Field Title          : ');
        fip#addl_string (str, dd_p^.fields [field_index].field_title);
        p$put_line (str);

        fip#addl_initialize (str, '  Field Width          : ');
        fip#addl_integer (str, dd_p^.fields [field_index].width, status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
        p$put_line (str);

        fip#addl_initialize (str, '  Scale Divisor        : ');
        fip#addl_integer (str, dd_p^.fields [field_index].scale, status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
        p$put_line (str);

        fip#addl_initialize (str, '  Overflow Action      : ');
        CASE dd_p^.fields [field_index].field_overflow_action OF
        = ofc$foa_scale =
          fip#addl_string (str, 'Scale');
        = ofc$foa_maximum =
          fip#addl_string (str, 'Maximum');
        = ofc$foa_asterisk =
          fip#addl_string (str, 'Asterisk');
        ELSE
          fip#addl_string (str, '<Improver Value>');
        CASEND;
        p$put_line (str);

        fip#addl_initialize (str, '  Incremental          : ');
        IF dd_p^.fields [field_index].incremental THEN
          fip#addl_string (str, 'TRUE');
        ELSE
          fip#addl_string (str, 'FALSE');
        IFEND;
        p$put_line (str);

        fip#addl_initialize (str, '  Field Selection      : ');
        CASE dd_p^.fields [field_index].field_selection OF
        = ofc$fs_unconditional =
          fip#addl_string (str, 'Unconditional');
        = ofc$fs_active =
          fip#addl_string (str, 'Active');
        = ofc$fs_swapped =
          fip#addl_string (str, 'Swapped');
        ELSE
          fip#addl_string (str, '<Improver Value>');
        CASEND;
        p$put_line (str);

        fip#addl_initialize (str, '  Non Selection Action : ');
        CASE dd_p^.fields [field_index].non_selection_action OF
        = ofc$nsa_skip =
          fip#addl_string (str, 'Skip');
        = ofc$nsa_blank =
          fip#addl_string (str, 'Blank');
        ELSE
          fip#addl_string (str, '<Improver Value>');
        CASEND;
        p$put_line (str);

      FOREND;

    PROCEND p$display_dd_display;
?? OLDTITLE ??
?? NEWTITLE := 'p$display_dd_display_source', EJECT ??

    PROCEDURE p$display_dd_display_source
      (    dd_p: ^oft$display_description;
       VAR display_control: clt$display_control;
       VAR status: ost$status);

      VAR
        display_numeric_values: boolean,
        field_index: integer,
        name: ost$name,
        str: ost$string;

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

      PROCEDURE [INLINE] p$put_line
        (VAR str: ost$string);

        clp$put_display (display_control, str.value (1, str.size), clc$trim, status);
        IF NOT status.normal THEN
          EXIT p$display_dd_display_source; {----->
        IFEND;

      PROCEND p$put_line;
?? OLDTITLE ??
?? EJECT ??
      IF dd_p = NIL THEN
        RETURN; {----->
      IFEND;

{Header
      fip#addl_initialize (str, 'CREATE_INITITIATED_JOB_DISPLAY ..');
      p$put_line (str);

{N=
      fip#addl_initialize (str, 'NAME=');
      fip#addl_string (str, dd_p^.header.display_name);
      fip#addl_string (str, c$comma CAT c$dot);
      p$put_line (str);

{A= $optional
      IF dd_p^.header.display_name_abbrev <> '' THEN
        fip#addl_initialize (str, 'ALIAS=');
        fip#addl_string (str, dd_p^.header.display_name_abbrev);
        fip#addl_string (str, c$comma CAT c$dot);
        p$put_line (str);
      IFEND;

{T= $optional
      IF dd_p^.header.title <> '' THEN
        fip#addl_initialize (str, 'TITLE=' CAT c$quote);
        fip#addl_trimmed_string (str, dd_p^.header.title, fic#ato_trailing, ' ');
        fip#addl_string (str, c$quote CAT c$comma CAT c$dot);
        p$put_line (str);
      IFEND;

{JS=
      fip#addl_initialize (str, 'JOB_SELECTION=');
      IF dd_p^.header.job_selection = ofc$js_active THEN
        fip#addl_string (str, 'ACTIVE');
      ELSEIF dd_p^.header.job_selection = ofc$js_initiated THEN
        fip#addl_string (str, 'INITIATED');
      ELSE
        fip#addl_string (str, c$unspecified);
      IFEND;
      fip#addl_string (str, c$comma CAT c$dot);
      p$put_line (str);

{JPL=
      fip#addl_initialize (str, 'JOBS_PER_LINE=');
      fip#addl_integer (str, dd_p^.header.jobs_per_line, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;
      fip#addl_string (str, c$comma CAT c$dot);
      p$put_line (str);

{DSL=
      fip#addl_initialize (str, 'DISPLAY_SYSTEM_LINE=');
      IF dd_p^.header.display_system_line THEN
        fip#addl_string (str, 'TRUE');
      ELSE
        fip#addl_string (str, 'FALSE');
      IFEND;
      fip#addl_string (str, c$comma CAT c$dot);
      p$put_line (str);

{DBL=
      fip#addl_initialize (str, 'DISPLAY_BLANK_LINES=');
      IF dd_p^.header.display_blank_lines THEN
        fip#addl_string (str, 'TRUE');
      ELSE
        fip#addl_string (str, 'FALSE');
      IFEND;
      fip#addl_string (str, c$comma CAT c$dot);
      p$put_line (str);

{F=
      fip#addl_initialize (str, 'FIELDS=(' CAT c$dot);
      p$put_line (str);

      FOR field_index := 1 TO dd_p^.header.field_count DO
        display_numeric_values := dd_p^.fields [field_index].scale <> 0;

{  Field_Name
        fip#addl_initialize (str, ' (');
        convert_field_id_to_name (dd_p^.fields [field_index].field_id, name);
        fip#addl_string (str, name);
        fip#addl_string (str, c$comma CAT c$dot);
        p$put_line (str);

{  Field_Width
        fip#addl_initialize (str, '  ');
        fip#addl_integer (str, dd_p^.fields [field_index].width, status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
        fip#addl_string (str, c$comma CAT c$dot);
        p$put_line (str);

{  Field_Title
        fip#addl_initialize (str, '  ' CAT c$quote);
        fip#addl_trimmed_string (str, dd_p^.fields [field_index].field_title, fic#ato_trailing, ' ');
        fip#addl_string (str, c$quote CAT c$comma CAT c$dot);
        p$put_line (str);

{  Scale
        IF display_numeric_values THEN
          fip#addl_initialize (str, '  ' CAT c$comma CAT c$unspecified);
        ELSE
          fip#addl_initialize (str, '  ');
          fip#addl_integer (str, dd_p^.fields [field_index].scale, status);
          IF NOT status.normal THEN
            RETURN; {----->
          IFEND;
        IFEND;
        fip#addl_string (str, c$comma CAT c$dot);
        p$put_line (str);

{Overflow Action
        IF display_numeric_values THEN
          fip#addl_initialize (str, '  ' CAT c$comma CAT c$unspecified);
        ELSE
          fip#addl_initialize (str, '  ');
          CASE dd_p^.fields [field_index].field_overflow_action OF
          = ofc$foa_scale =
            fip#addl_string (str, 'SCALE');
          = ofc$foa_maximum =
            fip#addl_string (str, 'MAXIMUM');
          = ofc$foa_asterisk =
            fip#addl_string (str, 'ASTERISK');
          ELSE
            fip#addl_string (str, c$unspecified);
          CASEND;
        IFEND;
        fip#addl_string (str, c$comma CAT c$dot);
        p$put_line (str);

{  Incremental
        IF display_numeric_values THEN
          fip#addl_initialize (str, '  ' CAT c$comma CAT c$unspecified);
        ELSE
          fip#addl_initialize (str, '  ');
          IF dd_p^.fields [field_index].incremental THEN
            fip#addl_string (str, 'TRUE');
          ELSE
            fip#addl_string (str, 'FALSE');
          IFEND;
        IFEND;
        fip#addl_string (str, c$comma CAT c$dot);
        p$put_line (str);

{  Field Selection
        fip#addl_initialize (str, '  ');
        CASE dd_p^.fields [field_index].field_selection OF
        = ofc$fs_unconditional =
          fip#addl_string (str, 'UNCONDITIONAL');
        = ofc$fs_active =
          fip#addl_string (str, 'ACTIVE');
        = ofc$fs_swapped =
          fip#addl_string (str, 'SWAPPED');
        ELSE
          fip#addl_string (str, c$unspecified);
        CASEND;
        fip#addl_string (str, c$comma CAT c$dot);
        p$put_line (str);

{  Non Selection Action
        fip#addl_initialize (str, '  ');
        CASE dd_p^.fields [field_index].non_selection_action OF
        = ofc$nsa_skip =
          fip#addl_string (str, 'SKIP');
        = ofc$nsa_blank =
          fip#addl_string (str, 'BLANK');
        ELSE
          fip#addl_string (str, c$unspecified);
        CASEND;
        fip#addl_string (str, ') ' CAT c$comma CAT c$dot);
        p$put_line (str);
      FOREND;

      fip#addl_initialize (str, '  )');
      p$put_line (str);

    PROCEND p$display_dd_display_source;
?? OLDTITLE ??
?? NEWTITLE := 'p$display_ud_display', EJECT ??

    PROCEDURE p$display_ud_display
      (    ud_p: ^oft$unit_stat_display_desc;
       VAR display_control: clt$display_control;
       VAR status: ost$status);

      VAR
        field_index: integer,
        name: ost$name,
        str: ost$string;

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

      PROCEDURE [INLINE] p$put_line
        (VAR str: ost$string);

        clp$put_display (display_control, str.value (1, str.size), clc$trim, status);
        IF NOT status.normal THEN
          EXIT p$display_ud_display; {----->
        IFEND;

      PROCEND p$put_line;
?? OLDTITLE ??
?? EJECT ??

      fip#addl_initialize (str, 'Display Type           : Unit Statistic Display');
      p$put_line (str);

{Header
      fip#addl_initialize (str, 'Name                   : ');
      fip#addl_string (str, ud_p^.header.display_name);
      p$put_line (str);

      fip#addl_initialize (str, 'Abbreviation           : ');
      fip#addl_string (str, ud_p^.header.display_name_abbrev);
      p$put_line (str);

      fip#addl_initialize (str, 'Title                  : ');
      fip#addl_string (str, ud_p^.header.title);
      p$put_line (str);

      fip#addl_initialize (str, 'Units per Line         : ');
      fip#addl_integer (str, ud_p^.header.units_per_line, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;
      p$put_line (str);

      fip#addl_initialize (str, 'Column Width           : ');
      fip#addl_integer (str, ud_p^.header.column_width, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;
      p$put_line (str);

      fip#addl_initialize (str, 'Unit Selections        : ');
{ff
      p$put_line (str);

      fip#addl_initialize (str, 'Display Blank Lines    : ');
      IF ud_p^.header.display_blank_lines THEN
        fip#addl_string (str, 'TRUE');
      ELSE
        fip#addl_string (str, 'FALSE');
      IFEND;
      p$put_line (str);

      fip#addl_initialize (str, 'Display System Line    : ');
      IF ud_p^.header.display_system_line THEN
        fip#addl_string (str, 'TRUE');
      ELSE
        fip#addl_string (str, 'FALSE');
      IFEND;
      p$put_line (str);

      fip#addl_initialize (str, 'Incremental Reset Freq : ');
      fip#addl_integer (str, ud_p^.header.incremental_data_reset_freq, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;
      p$put_line (str);

      fip#addl_initialize (str, 'Incremental Data req   : ');
      IF ud_p^.header.incremental_data_required THEN
        fip#addl_string (str, 'TRUE');
      ELSE
        fip#addl_string (str, 'FALSE');
      IFEND;
      p$put_line (str);

      fip#addl_initialize (str, 'Field Count            : ');
      fip#addl_integer (str, ud_p^.header.field_count, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;
      p$put_line (str);

      FOR field_index := 1 TO ud_p^.header.field_count DO
        fip#addl_initialize (str, '');
        p$put_line (str);
        fip#addl_integer (str, field_index, status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
        p$put_line (str);

        fip#addl_initialize (str, '  Field ID               : ');
        convert_us_field_id_to_name (ud_p^.fields [field_index].field_id, name);
        fip#addl_string (str, name);
        p$put_line (str);

        fip#addl_initialize (str, '  Field Title            : ');
        fip#addl_string (str, ud_p^.fields [field_index].field_title);
        p$put_line (str);

        fip#addl_initialize (str, '  Field Width            : ');
        fip#addl_integer (str, ud_p^.fields [field_index].width, status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
        p$put_line (str);

        fip#addl_initialize (str, '  Fraction Width         : ');
        fip#addl_integer (str, ud_p^.fields [field_index].fraction_width, status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
        p$put_line (str);

        fip#addl_initialize (str, '  Scale Divisor          : ');
        fip#addl_integer (str, ud_p^.fields [field_index].scale, status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
        p$put_line (str);

        fip#addl_initialize (str, '  Overflow Action        : ');
        CASE ud_p^.fields [field_index].field_overflow_action OF
        = ofc$foa_scale =
          fip#addl_string (str, 'Scale');
        = ofc$foa_maximum =
          fip#addl_string (str, 'Maximum');
        = ofc$foa_asterisk =
          fip#addl_string (str, 'Asterisk');
        ELSE
          fip#addl_string (str, '<Improver Value>');
        CASEND;
        p$put_line (str);

        fip#addl_initialize (str, '  Numeric Selection Mode : ');
        CASE ud_p^.fields [field_index].numeric_selection_mode OF
        = ofc$nsm_total =
          fip#addl_string (str, 'Total');
        = ofc$nsm_incremental =
          fip#addl_string (str, 'Incremental');
        ELSE
          fip#addl_string (str, '<Improver Value>');
        CASEND;
        p$put_line (str);

        fip#addl_initialize (str, '  Numeric Display Mode   : ');
        CASE ud_p^.fields [field_index].numeric_display_mode.kind OF
        = ofc$ndm_total =
          fip#addl_string (str, 'Total');
        = ofc$ndm_interval =
          CASE ud_p^.fields [field_index].numeric_display_mode.interval OF
          = c$clock_second =
            fip#addl_string (str, 'Count_per_Second');
          = c$clock_minute =
            fip#addl_string (str, 'Count_per_Minute');
          = c$clock_hour =
            fip#addl_string (str, 'Count_per_Hour');
          = c$clock_day =
            fip#addl_string (str, 'Count_per_Day');
          ELSE
            fip#addl_integer (str, ud_p^.fields [field_index].numeric_display_mode.interval, status);
            IF NOT status.normal THEN
              RETURN; {----->
            IFEND;
          CASEND;
        ELSE
          fip#addl_string (str, '<Improver Value>');
        CASEND;
        p$put_line (str);

{Field Selections
        fip#addl_initialize (str, '  Field Selections');
        p$put_line (str);

        fip#addl_initialize (str, '    Parity Protec Enabled: ');
        IF ud_p^.fields [field_index].field_selections.parity_protect_enabled_selector =
              $oft$us_boolean_selector [] THEN
          fip#addl_string (str, '()');
        ELSEIF ud_p^.fields [field_index].field_selections.parity_protect_enabled_selector =
              $oft$us_boolean_selector [TRUE] THEN
          fip#addl_string (str, '(TRUE)');
        ELSEIF ud_p^.fields [field_index].field_selections.parity_protect_enabled_selector =
              $oft$us_boolean_selector [FALSE] THEN
          fip#addl_string (str, '(FALSE)');
        ELSE { [TRUE, FALSE]
          fip#addl_string (str, '(TRUE, FALSE)');
        IFEND;
        p$put_line (str);

        fip#addl_initialize (str, '    Parity Protect Device: ');
        IF ud_p^.fields [field_index].field_selections.parity_protected_device_select =
              $oft$us_boolean_selector [] THEN
          fip#addl_string (str, '()');
        ELSEIF ud_p^.fields [field_index].field_selections.parity_protected_device_select =
              $oft$us_boolean_selector [TRUE] THEN
          fip#addl_string (str, '(TRUE)');
        ELSEIF ud_p^.fields [field_index].field_selections.parity_protected_device_select =
              $oft$us_boolean_selector [FALSE] THEN
          fip#addl_string (str, '(FALSE)');
        ELSE { [TRUE, FALSE]
          fip#addl_string (str, '(TRUE, FALSE)');
        IFEND;
        p$put_line (str);

        fip#addl_initialize (str, '    Unit Disabled        : ');
        IF ud_p^.fields [field_index].field_selections.unit_disabled_selector = $oft$us_boolean_selector
              [] THEN
          fip#addl_string (str, '()');
        ELSEIF ud_p^.fields [field_index].field_selections.unit_disabled_selector =
              $oft$us_boolean_selector [TRUE] THEN
          fip#addl_string (str, '(TRUE)');
        ELSEIF ud_p^.fields [field_index].field_selections.unit_disabled_selector =
              $oft$us_boolean_selector [FALSE] THEN
          fip#addl_string (str, '(FALSE)');
        ELSE { [TRUE, FALSE]
          fip#addl_string (str, '(TRUE, FALSE)');
        IFEND;
        p$put_line (str);

        fip#addl_initialize (str, '  Non Selection Action   : ');
        CASE ud_p^.fields [field_index].non_selection_action OF
        = ofc$nsa_skip =
          fip#addl_string (str, 'Skip');
        = ofc$nsa_blank =
          fip#addl_string (str, 'Blank');
        ELSE
          fip#addl_string (str, '<Improver Value>');
        CASEND;
        p$put_line (str);

      FOREND;

    PROCEND p$display_ud_display;
?? OLDTITLE ??
?? NEWTITLE := 'p$display_ud_display_source', EJECT ??

    PROCEDURE p$display_ud_display_source
      (    ud_p: ^oft$unit_stat_display_desc;
       VAR display_control: clt$display_control;
       VAR status: ost$status);

      VAR
        display_numeric_values: boolean,
        field_index: integer,
        name: ost$name,
        str: ost$string;

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

      PROCEDURE [INLINE] p$put_line
        (VAR str: ost$string);

        clp$put_display (display_control, str.value (1, str.size), clc$trim, status);
        IF NOT status.normal THEN
          EXIT p$display_ud_display_source; {----->
        IFEND;

      PROCEND p$put_line;
?? OLDTITLE ??
?? EJECT ??
      IF ud_p = NIL THEN
        RETURN; {----->
      IFEND;

{Header
      fip#addl_initialize (str, 'CREATE_UNIT_STATISTIC_DISPLAY ..');
      p$put_line (str);

{N=
      fip#addl_initialize (str, 'NAME=');
      fip#addl_string (str, ud_p^.header.display_name);
      fip#addl_string (str, c$comma CAT c$dot);
      p$put_line (str);

{A= $optional
      IF ud_p^.header.display_name_abbrev <> '' THEN
        fip#addl_initialize (str, 'ALIAS=');
        fip#addl_string (str, ud_p^.header.display_name_abbrev);
        fip#addl_string (str, c$comma CAT c$dot);
        p$put_line (str);
      IFEND;

{T= $optional
      IF ud_p^.header.title <> '' THEN
        fip#addl_initialize (str, 'TITLE=' CAT c$quote);
        fip#addl_trimmed_string (str, ud_p^.header.title, fic#ato_trailing, ' ');
        fip#addl_string (str, c$quote CAT c$comma CAT c$dot);
        p$put_line (str);
      IFEND;

{UPL=
      fip#addl_initialize (str, 'UNITS_PER_LINE=');
      fip#addl_integer (str, ud_p^.header.units_per_line, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;
      fip#addl_string (str, c$comma CAT c$dot);
      p$put_line (str);

{DSL=
      fip#addl_initialize (str, 'DISPLAY_SYSTEM_LINE=');
      IF ud_p^.header.display_system_line THEN
        fip#addl_string (str, 'TRUE');
      ELSE
        fip#addl_string (str, 'FALSE');
      IFEND;
      fip#addl_string (str, c$comma CAT c$dot);
      p$put_line (str);

{DBL=
      fip#addl_initialize (str, 'DISPLAY_BLANK_LINES=');
      IF ud_p^.header.display_blank_lines THEN
        fip#addl_string (str, 'TRUE');
      ELSE
        fip#addl_string (str, 'FALSE');
      IFEND;
      fip#addl_string (str, c$comma CAT c$dot);
      p$put_line (str);

{IRF
      fip#addl_initialize (str, 'INCREMENTAL_RESET_FREQUENCY=');
      IF ud_p^.header.incremental_data_reset_freq = clc$max_integer THEN
        fip#addl_string (str, 'SESSION');
      ELSEIF ud_p^.header.incremental_data_reset_freq = 0 THEN
        fip#addl_string (str, 'COMMAND');
      ELSE
        fip#addl_integer (str, ud_p^.header.incremental_data_reset_freq, status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
      IFEND;
      fip#addl_string (str, c$comma CAT c$dot);
      p$put_line (str);

{F=
      fip#addl_initialize (str, 'FIELDS=(' CAT c$dot);
      p$put_line (str);

      FOR field_index := 1 TO ud_p^.header.field_count DO
        display_numeric_values := ud_p^.fields [field_index].scale <> 0;

{  Field_Name
        fip#addl_initialize (str, ' (');
        convert_us_field_id_to_name (ud_p^.fields [field_index].field_id, name);
        fip#addl_string (str, name);
        fip#addl_string (str, c$comma CAT c$dot);
        p$put_line (str);

{  Field_Width
        fip#addl_initialize (str, '  ');
        fip#addl_integer (str, ud_p^.fields [field_index].width, status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
        fip#addl_string (str, c$comma CAT c$dot);
        p$put_line (str);

{  Fraction Width
        IF display_numeric_values THEN
          fip#addl_initialize (str, '  ' CAT c$comma CAT c$unspecified);
        ELSE
          fip#addl_initialize (str, '  ');
          fip#addl_integer (str, ud_p^.fields [field_index].fraction_width, status);
          IF NOT status.normal THEN
            RETURN; {----->
          IFEND;
        IFEND;
        fip#addl_string (str, c$comma CAT c$dot);
        p$put_line (str);

{  Field_Title
        fip#addl_initialize (str, '  ' CAT c$quote);
        fip#addl_trimmed_string (str, ud_p^.fields [field_index].field_title, fic#ato_trailing, ' ');
        fip#addl_string (str, c$quote CAT c$comma CAT c$dot);
        p$put_line (str);

{  Scale
        IF display_numeric_values THEN
          fip#addl_initialize (str, '  ' CAT c$comma CAT c$unspecified);
        ELSE
          fip#addl_initialize (str, '  ');
          fip#addl_integer (str, ud_p^.fields [field_index].scale, status);
          IF NOT status.normal THEN
            RETURN; {----->
          IFEND;
        IFEND;
        fip#addl_string (str, c$comma CAT c$dot);
        p$put_line (str);

{  Field Overflow Action
        IF display_numeric_values THEN
          fip#addl_initialize (str, '  ' CAT c$comma CAT c$unspecified);
        ELSE
          fip#addl_initialize (str, '  ');
          CASE ud_p^.fields [field_index].field_overflow_action OF
          = ofc$foa_scale =
            fip#addl_string (str, 'SCALE');
          = ofc$foa_maximum =
            fip#addl_string (str, 'MAXIMUM');
          = ofc$foa_asterisk =
            fip#addl_string (str, 'ASTERISK');
          ELSE
            fip#addl_string (str, c$unspecified);
          CASEND;
        IFEND;
        fip#addl_string (str, c$comma CAT c$dot);
        p$put_line (str);

{  Numeric_Selection_Mode
        IF display_numeric_values THEN
          fip#addl_initialize (str, '  ' CAT c$comma CAT c$unspecified);
        ELSE
          fip#addl_initialize (str, '  ');
          CASE ud_p^.fields [field_index].numeric_selection_mode OF
          = ofc$nsm_total =
            fip#addl_string (str, 'TOTAL');
          = ofc$nsm_incremental =
            fip#addl_string (str, 'INCREMENTAL');
          ELSE
            fip#addl_string (str, c$unspecified);
          CASEND;
        IFEND;
        fip#addl_string (str, c$comma CAT c$dot);
        p$put_line (str);

{  Numeric_Display_Mode
        IF display_numeric_values THEN
          fip#addl_initialize (str, '  ' CAT c$comma CAT c$unspecified);
        ELSE
          fip#addl_initialize (str, '  ');
          CASE ud_p^.fields [field_index].numeric_display_mode.kind OF
          = ofc$ndm_total =
            fip#addl_string (str, 'TOTAL');
          = ofc$ndm_interval =

            CASE ud_p^.fields [field_index].numeric_display_mode.interval OF
            = c$clock_second =
              fip#addl_string (str, 'COUNT_PER_SECOND');

            = c$clock_minute =
              fip#addl_string (str, 'COUNT_PER_MINUTE');
            = c$clock_hour =
              fip#addl_string (str, 'COUNT_PER_HOUR');
            = c$clock_day =
              fip#addl_string (str, 'COUNT_PER_DAY');
            ELSE
              fip#addl_integer (str, ud_p^.fields [field_index].numeric_display_mode.interval, status);
              IF NOT status.normal THEN
                RETURN; {----->
              IFEND;
            CASEND;

          ELSE
            fip#addl_string (str, c$unspecified);
          CASEND;
        IFEND;
        fip#addl_string (str, c$comma CAT c$dot);
        p$put_line (str);

{  Field Selections
        fip#addl_initialize (str, '  (');
        IF ud_p^.fields [field_index].field_selections.parity_protect_enabled_selector =
              $oft$us_boolean_selector [] THEN
          fip#addl_string (str, '()');
        ELSEIF ud_p^.fields [field_index].field_selections.parity_protect_enabled_selector =
              $oft$us_boolean_selector [TRUE] THEN
          fip#addl_string (str, '(TRUE)');
        ELSEIF ud_p^.fields [field_index].field_selections.parity_protect_enabled_selector =
              $oft$us_boolean_selector [FALSE] THEN
          fip#addl_string (str, '(FALSE)');
        ELSE { [TRUE, FALSE]
          fip#addl_string (str, '(TRUE, FALSE)');
        IFEND;
        fip#addl_string (str, c$comma CAT c$dot);
        p$put_line (str);

        fip#addl_initialize (str, '    ');
        IF ud_p^.fields [field_index].field_selections.parity_protected_device_select =
              $oft$us_boolean_selector [] THEN
          fip#addl_string (str, '()');
        ELSEIF ud_p^.fields [field_index].field_selections.parity_protected_device_select =
              $oft$us_boolean_selector [TRUE] THEN
          fip#addl_string (str, '(TRUE)');
        ELSEIF ud_p^.fields [field_index].field_selections.parity_protected_device_select =
              $oft$us_boolean_selector [FALSE] THEN
          fip#addl_string (str, '(FALSE)');
        ELSE { [TRUE, FALSE]
          fip#addl_string (str, '(TRUE, FALSE)');
        IFEND;
        fip#addl_string (str, c$comma CAT c$dot);
        p$put_line (str);

        fip#addl_initialize (str, '    ');
        IF ud_p^.fields [field_index].field_selections.unit_disabled_selector = $oft$us_boolean_selector
              [] THEN
          fip#addl_string (str, '()');
        ELSEIF ud_p^.fields [field_index].field_selections.unit_disabled_selector =
              $oft$us_boolean_selector [TRUE] THEN
          fip#addl_string (str, '(TRUE)');
        ELSEIF ud_p^.fields [field_index].field_selections.unit_disabled_selector =
              $oft$us_boolean_selector [FALSE] THEN
          fip#addl_string (str, '(FALSE)');
        ELSE { [TRUE, FALSE]
          fip#addl_string (str, '(TRUE, FALSE)');
        IFEND;
        fip#addl_string (str, ')' CAT c$comma CAT c$dot);
        p$put_line (str);

{  Non Selection Action
        fip#addl_initialize (str, '  ');
        CASE ud_p^.fields [field_index].non_selection_action OF
        = ofc$nsa_skip =
          fip#addl_string (str, 'SKIP');
        = ofc$nsa_blank =
          fip#addl_string (str, 'BLANK');
        ELSE
          fip#addl_string (str, c$unspecified);
        CASEND;
        fip#addl_string (str, c$comma CAT c$dot);
        p$put_line (str);

        fip#addl_string (str, ')' CAT c$comma CAT c$dot);
      FOREND;

{US=
      fip#addl_initialize (str, 'UNIT_SELECTIONS=(' CAT c$dot);
      p$put_line (str);

{ff

    PROCEND p$display_ud_display_source;
?? OLDTITLE ??
?? EJECT ??
    status.normal := TRUE;

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

    display_option_is_source := pvt [p$display_option].value^.keyword_value = 'SOURCE';

  /display_ved_definition/
    BEGIN
      display_control := clv$nil_display_control;
      #SPOIL (display_control);
      osp$establish_block_exit_hndlr (^abort_handler);
      default_ring_attributes.r1 := #RING (^default_ring_attributes);
      default_ring_attributes.r2 := #RING (^default_ring_attributes);
      default_ring_attributes.r3 := #RING (^default_ring_attributes);

      IF display_option_is_source THEN
        clp$open_display_reference (pvt [p$output].value^.file_value^, NIL, fsc$legible_data,
              default_ring_attributes, display_control, status);
      ELSE
        clp$open_display_reference (pvt [p$output].value^.file_value^, ^clp$new_page_procedure, fsc$list,
              default_ring_attributes, display_control, status);
      IFEND;
      IF NOT status.normal THEN
        EXIT /display_ved_definition/; {----->
      IFEND;
      clv$titles_built := FALSE;
      clv$command_name := 'DISPLAY_VED_DEFINITION';

      IF display_control.page_width < clc$narrow_page_width THEN
        clv$page_width := clc$narrow_page_width;
      ELSEIF display_control.page_width > clc$wide_page_width THEN
        clv$page_width := clc$wide_page_width;
      ELSE
        clv$page_width := display_control.page_width;
      IFEND;


      PUSH dd_p: [1 .. ofc$max_display_fields];
      dd_p^.header.display_name := pvt [p$name].value^.name_value;
      field_count := 0;
      ofp$access_display_description (ofc$adrc_get, dd_p, field_count, status);

      IF status.normal THEN
        IF display_option_is_source THEN
          p$display_dd_display_source (dd_p, display_control, status);
        ELSE
          p$display_dd_display (dd_p, display_control, status);
        IFEND;
      ELSE
        status.normal := TRUE;
        PUSH ud_p: [1 .. ofc$max_display_fields];
        ud_p^.header.display_name := pvt [p$name].value^.name_value;
        field_count := 0;
        ofp$access_unit_stat_descript (ofc$adrc_get, ud_p, field_count, status);

        IF status.normal THEN
          IF display_option_is_source THEN
            p$display_ud_display_source (ud_p, display_control, status);
          ELSE
            p$display_ud_display (ud_p, display_control, status);
          IFEND;
        IFEND;
      IFEND;

    END /display_ved_definition/;

    IF status.normal THEN
      status_p := ^status;
    ELSE
      PUSH status_p;
    IFEND;

    clp$close_display (display_control, status_p^);
    osp$disestablish_cond_handler;

  PROCEND ofp$_display_ved_definition;
?? TITLE := 'OFP$_DISPLAY_VED_FIELD_DATA', EJECT ??

  PROCEDURE ofp$_display_ved_field_data
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

*copyc ofd$_display_ved_field_data

*copy clv$display_variables

    VAR
      default_ring_attributes: amt$ring_attributes,
      display_control: clt$display_control,
      display_option: oft$field_data_display_select,
      status_p: ^ost$status;

?? NEWTITLE := 'abort_handler', EJECT ??

    PROCEDURE abort_handler
      (    condition: pmt$condition;
           condition_information: ^pmt$condition_information;
           save_area: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      VAR
        ignore_status: ost$status;

      clp$close_display (display_control, ignore_status);

    PROCEND abort_handler;
?? OLDTITLE ??
*copy clp$new_page_procedure
?? OLDTITLE ??
?? NEWTITLE := '    put_subtitle', EJECT ??

    PROCEDURE put_subtitle
      (VAR display_control: clt$display_control;
       VAR status: ost$status);

{ The display_ved_field_data command has no subtitles, this
{ is merely a dummy routine used to keep the module consistent
{ with those that do produce subtitles.

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

    IF pvt [p$display_option].value^.keyword_value = 'SELECTED_FIELDS' THEN
      display_option := ofc$fdds_selected_fields;
    ELSEIF pvt [p$display_option].value^.keyword_value = 'DEFINED_FIELDS' THEN
      display_option := ofc$fdds_defined_fields;
    ELSEIF pvt [p$display_option].value^.keyword_value = 'INCREMENTAL_FIELDS' THEN
      display_option := ofc$fdds_incremental_fields;
    ELSEIF pvt [p$display_option].value^.keyword_value = 'ALL' THEN
      display_option := ofc$fdds_all_fields;
    ELSEIF pvt [p$display_option].value^.keyword_value = 'ALL_INCREMENTAL_FIELDS' THEN
      display_option := ofc$fdds_all_incremental_fields;
    ELSE {ALL_NON_INCREMENTAL_FIELDS
      display_option := ofc$fdds_all_non_inc_fields;
    IFEND;

  /display_ved_field_data/
    BEGIN
      display_control := clv$nil_display_control;
      #SPOIL (display_control);
      osp$establish_block_exit_hndlr (^abort_handler);
      default_ring_attributes.r1 := #RING (^default_ring_attributes);
      default_ring_attributes.r2 := #RING (^default_ring_attributes);
      default_ring_attributes.r3 := #RING (^default_ring_attributes);

      clp$open_display_reference (pvt [p$output].value^.file_value^, ^clp$new_page_procedure, fsc$list,
            default_ring_attributes, display_control, status);
      IF NOT status.normal THEN
        EXIT /display_ved_field_data/; {----->
      IFEND;
      clv$titles_built := FALSE;
      clv$command_name := 'DISPLAY_VED_FIELD_DATA';

      IF display_control.page_width < clc$narrow_page_width THEN
        clv$page_width := clc$narrow_page_width;
      ELSEIF display_control.page_width > clc$wide_page_width THEN
        clv$page_width := clc$wide_page_width;
      ELSE
        clv$page_width := display_control.page_width;
      IFEND;

      ofp$display_ved_field_data (pvt [p$name].value^.name_value, display_option,
            pvt [p$update_incremental_data].value^.boolean_value.value, display_control, status);

    END /display_ved_field_data/;

    IF status.normal THEN
      status_p := ^status;
    ELSE
      PUSH status_p;
    IFEND;

    clp$close_display (display_control, status_p^);
    osp$disestablish_cond_handler;

  PROCEND ofp$_display_ved_field_data;
?? TITLE := 'OFP$_PURGE_INCREMENTAL_DATA', EJECT ??

  PROCEDURE ofp$_purge_incremental_data
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

*copyc ofd$pdt_purge_incremental_data

    VAR
      display_kinds: oft$display_kinds;

    status.normal := TRUE;

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

    IF pvt [p$names].value^.keyword_value = 'ALL' THEN
      display_kinds := -$oft$display_kinds [];
    ELSEIF pvt [p$names].value^.keyword_value = 'UNIT_STATISTIC_DISPLAY' THEN
      display_kinds := $oft$display_kinds [ofc$dt_unit_statistic_display];
    ELSE
      display_kinds := $oft$display_kinds [ofc$dt_initiated_job_display];
    IFEND;

    ofp$purge_incremental_data (display_kinds, status);

  PROCEND ofp$_purge_incremental_data;
?? TITLE := 'ofp$_reset_ms_display', EJECT ??

  PROCEDURE ofp$_reset_ms_display
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

*copyc ofd$pdt_reset_ms_display

    VAR
      ignore_ms_display_infos: oft$mass_storage_display_infos,
      work_area_p: ^clt$work_area;

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

    work_area_p := NIL;
    ofp$access_ms_display_infos (ofc$adrc_reset, work_area_p, ignore_ms_display_infos, status);

  PROCEND ofp$_reset_ms_display;
?? TITLE := 'ofp$_quit ', EJECT ??

{ PURPOSE:
{   Processes the QUIT command which exits the utility.
{   No special processing is done by this procedure. It simply exits the VEDU utility.
{

  PROCEDURE ofp$_quit
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

*copyc ofd$pdt_quit

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

    clp$end_include (utility_name, status);

  PROCEND ofp$_quit;
?? TITLE := '[XDCL] ofp$ved_utility', EJECT ??

{ PURPOSE:
{   Processes the VEDU command which starts up a utility to define/modify
{   VED display definitions used by the VED command.
{
{ NOTE:
{    o The first time this utility is called, it will create the default (AJ, IJ, IJD)
{      displays.
{

  PROCEDURE [XDCL, #GATE] ofp$_ved_utility
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{  PROCEDURE virtual_enviro_display_utility, vedu (
{    status)

?? PUSH (LISTEXT := ON) ??

    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, [88, 10, 16, 21, 35, 0, 16], clc$command, 1, 1, 0, 0, 0, 0, 1, 'VEDU'],
            [['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]]];

?? POP ??

    CONST
      p$status = 1;

    VAR
      dummy_status: ost$status,
      pvt: array [1 .. 1] of clt$parameter_value;

    status.normal := TRUE;

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

    clp$begin_utility (utility_name, utility_attributes, status);
    IF NOT status.normal THEN
      RETURN {----->
    IFEND;

    IF NOT ofv$displays_initialized THEN
      create_default_displays (status);
    IFEND;

    IF status.normal THEN
      clp$include_file (command_file, '', utility_name, status);
    IFEND;

    clp$end_utility (utility_name, dummy_status);

  PROCEND ofp$_ved_utility;
?? TITLE := 'create_default_displays', EJECT ??
{
{  PURPOSE:
{    This procedure is called from the VEDU command processors to create
{    the default displays. This procedure is called only once - the first time
{    a VED or VEDU command is executed.
{
{  NOTE:
{    o Additional default displays can be created by adding a trivial amount
{ of code to this procedure.
{

  PROCEDURE create_default_displays
    (VAR status: ost$status);

    VAR
      aj: [STATIC, READ, oss$job_paged_literal] string (246) :=
            'creijd active_jobs a=aj js=a dsl=on dbl=no' CAT
            ' f=((ajlo,, '' '') (f,,''.'') (sjnl,,'' '') (ujn,8, '' '') (c' CAT 'tm,6,''CPM'')' CAT
            ' (ctj 8 ''CPJ'') (pr,,''PRC'') (pa,,''PAS' CAT ''') (pi 7 ''PIN'') (ss ,, ''  S'')' CAT
            ' (wss,,''WS'') (tf 1 '' '') (rtc 3 ''RT'') (pcu,,''PC'') f (dp))',

      ij: [STATIC, READ, oss$job_paged_literal] string (160) :=
            'creijd initiated_jobs a=ij js=i dsl=on jpl=2' CAT
            ' f=((sjn,, ''        SSN'') (ujn,8,''   UJN'') (jc 4 '' C'')' CAT
            '  (jes ,, ''  S'') (jp 4 ''PR'' 100) (f 2))',

      ijd: [STATIC, READ, oss$job_paged_literal] string (364) :=
            'creijd initiated_jobs_detailed a=ijd js=i dsl=on' CAT
            ' f=((ijlo 5 '' '') (f 1 ''.'') (ujn, 8,'' '' ) (ctm 7 ''CPM''' CAT ') (ctj 8 ''CPJ'')' CAT
            '  (js 5 ''  S/R'' ,,,,a s) (sr 5 '' ' CAT ''',,,, s s) (wss,, ''WS'') (tf 1 '' '')' CAT
            '  (rtc 3 ''RT'',,,,a s) (sss 10 ''SERVICE'',,,, a s)' CAT
            '  (siwt 7 '' '',,,,s s) (sss 6 '' '',,,,s s)' CAT
            '  (jp 10 ''PRIORITY'') f (dp 4) (ses 5 ''  SES'' ,,,,s b))';

    clp$include_line (aj, FALSE, osc$null_name, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    clp$include_line (ij, FALSE, osc$null_name, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    clp$include_line (ijd, FALSE, osc$null_name, status);

  PROCEND create_default_displays;
?? TITLE := '[XDCL] ofp$create_default_displays', EJECT ??
{
{  PURPOSE:
{    This procedure is called from the VED command processor. If the default displays have not
{    already been created, this procedure invokes the VEDU command to create the default
{    displays. (Entering and exiting VEDU will create the default displays.
{


  PROCEDURE [XDCL] ofp$create_default_displays
    (VAR status: ost$status);

    IF NOT ofv$displays_initialized THEN
      clp$include_line ('VEDU ;QUIT', FALSE, osc$null_name, status);
    IFEND;

  PROCEND ofp$create_default_displays;

MODEND ofm$designer_screens;
