?? RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE Job Management : Attribute Displays and Functions' ??
MODULE jmm$attribute_display_functions;
?? RIGHT := 110 ??

{ PURPOSE:
{   This module contains the procedures for managing the display and translation of job-associated
{ attributes.  The display interfaces are structured as the weakly typed program interface.  This
{ allows a significant amount of commonality and flexibility for the introduction of new attributes.
{ This allows a single display procedure to perform all of the display operations.
{
{ DESIGN:
{   The display procedure in this module is modeled after the "standard" display procedures generated
{ by the NOS/VE System Command Language (SCL) Project.
{
{   The display procedure will accept a sequence that contains a pointer to an adaptable array of
{ pointers to adaptable arrays of variant records.  Given this, it will display the contents of these
{ arrays in the order in which they are specified.  The display procedure also allows a list of names
{ to be displayed as "Name not found".

?? NEWTITLE := 'Global Declarations Referenced by this Module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc oss$job_paged_literal
*copyc osd$integer_limits
*copyc osd$virtual_address
*copyc cle$ecc_miscellaneous
*copyc jme$queued_file_conditions
*copyc jme$work_area_too_small
*copyc amt$term_option
*copyc clt$display_control
*copyc clt$file
*copyc clt$file_reference
*copyc clt$path_display_chunks
*copyc clt$processing_phase
*copyc jmt$attribute_keys
*copyc jmt$attribute_values
*copyc jmt$full_job_category_list
*copyc jmt$header_display_information
*copyc jmt$job_class_set
*copyc jmt$name_list
*copyc jmt$output_device
*copyc jmt$qfile_application_attrs
*copyc jmt$results_keys
*copyc jmt$work_area
*copyc ost$date
*copyc ost$name
*copyc ost$status
*copyc ost$string
*copyc ost$time
*copyc ost$user_identification
*copyc pmt$os_name
?? POP ??
*copyc clp$build_standard_title
*copyc clp$close_display
*copyc clp$convert_data_to_string
*copyc clp$convert_integer_to_rjstring
*copyc clp$convert_integer_to_string
*copyc clp$evaluate_parameters
*copyc clp$get_work_area
*copyc clp$horizontal_tab_display
*copyc clp$make_boolean_value
*copyc clp$make_date_time_value
*copyc clp$make_file_value
*copyc clp$make_integer_value
*copyc clp$make_list_value
*copyc clp$make_name_value
*copyc clp$make_status_value
*copyc clp$make_string_value
*copyc clp$make_time_increment_value
*copyc clp$new_display_line
*copyc clp$new_display_page
*copyc clp$open_display_reference
*copyc clp$put_display
*copyc clp$put_partial_display
*copyc clp$reset_for_next_display_page
*copyc clp$scan_argument_list
*copyc clp$trimmed_string_size
*copyc jmp$determine_job_class
*copyc jmp$determine_name_kind
*copyc jmp$get_attribute_defaults
*copyc jmp$get_input_attributes
*copyc jmp$get_job_attributes
*copyc jmp$get_job_counts
*copyc jmp$get_job_status
*copyc jmp$get_output_attributes
*copyc jmp$get_output_status
*copyc osp$disestablish_cond_handler
*copyc osp$establish_block_exit_hndlr
*copyc osp$format_message
*copyc osp$set_status_abnormal
*copyc osp$set_status_condition
*copyc pmp$compute_date_time_increment
*copyc pmp$format_compact_date
*copyc pmp$format_compact_time
*copyc pmp$get_compact_date_time
*copyc pmp$get_job_mode
*copyc clv$value_descriptors
*copyc jmv$null_date_time
*copyc osv$upper_to_lower
?? OLDTITLE ??
?? NEWTITLE := 'Global Variables and Constants Declared in this Module', EJECT ??

  CONST
    lowercase_required = 'required',
    lowercase_system_default = 'system_default',
    lowercase_unlimited = 'unlimited',
    lowercase_unspecified = 'unspecified',
    none = 'NONE',
    unknown_attribute_name = 'UNKNOWN',
    max_os_type_size = 6, {nos/be
    max_data_mode_size = 13, {rhf_structure
    max_device_type_size = 7, {printer
    max_job_abort_disposition_size = 9, {terminate
    max_job_recovery_disp_size = 9, {terminate
    max_job_state_size = 23, {waiting to be initiated
    max_terminate_job_action_size = 21, {operator kill enabled
    max_job_mode_size = 30, {interactive command disconnect
    max_output_disposition_size = 23, {discard_standard_output
    max_output_state_size = 21, {waiting to be printed
    max_processing_phase_size = 20, {member prolog phase
    max_qfile_state_size = 23, {waiting to be processed
    max_boolean_string_size = 3; {yes

  VAR
    boolean_string: [STATIC, READ, oss$job_paged_literal] array [boolean] of record
      size: 1 .. max_boolean_string_size,
      value: string (max_boolean_string_size),
    recend := [[2, 'no'], [3, 'yes']],
    c170_os_type: [STATIC, READ, oss$job_paged_literal] array [ost$170_os_type] of record
      size: 1 .. max_os_type_size,
      value: string (max_os_type_size),
    recend := [[4, 'none'], [3, 'NOS'], [6, 'NOS/BE']],
    data_mode: [STATIC, READ, oss$job_paged_literal] array [jmt$data_mode] of record
      size: 1 .. max_data_mode_size,
      value: string (max_data_mode_size),
    recend := [[5, 'coded'], [13, 'rhf_structure'], [11, 'transparent']],
    device_type: [STATIC, READ, oss$job_paged_literal] array [jmt$output_device_type] of record
      size: 1 .. max_device_type_size,
      value: string (max_device_type_size),
    recend := [[7, 'printer'], [7, 'plotter'], [5, 'punch']],
    input_file_location: [STATIC, READ, oss$job_paged_literal] array
          [jmc$ifl_no_input_file_exists .. jmc$ifl_login_family_queue] of record
      size: 1 .. 23,
      value: string (23),
    recend := [[20, 'no_input_file_exists'], [18, 'system_input_queue'], [23, 'store_and_forward_queue'], [18,
          'login_family_queue']],
    job_abort_disposition: [STATIC, READ, oss$job_paged_literal] array [jmt$job_abort_disposition] of record
      size: 1 .. max_job_abort_disposition_size,
      value: string (max_job_abort_disposition_size),
    recend := [[7, 'restart'], [9, 'terminate']],
    job_mode: [STATIC, READ, oss$job_paged_literal] array [jmt$job_mode] of record
      size: 1 .. max_job_mode_size,
      value: string (max_job_mode_size),
    recend := [[5, 'batch'], [22, 'interactive connected'], [30, 'interactive command disconnect'], [27,
          'interactive line disconnect'], [29, 'interactive system disconnect']],
    job_recovery_disposition: [STATIC, READ, oss$job_paged_literal] array [jmt$job_recovery_disposition] of
          record
      size: 1 .. max_job_recovery_disp_size,
      value: string (max_job_recovery_disp_size),
    recend := [[8, 'continue'], [7, 'restart'], [9, 'terminate']],
    job_state: [STATIC, READ, oss$job_paged_literal] array [jmt$job_state] of record
      size: 1 .. max_job_state_size,
      value: string (max_job_state_size),
    recend := [[8, 'deferred'], [23, 'waiting to be initiated'], [9, 'initiated'], [11, 'terminating'], [9,
          'completed']],
    output_disposition: [STATIC, READ, oss$job_paged_literal] array [jmt$output_disposition_keys] of record
      size: 1 .. max_output_disposition_size,
      value: string (max_output_disposition_size),
    recend := [[18, 'discard_all_output'], [23, 'discard_standard_output'], [5, 'local'], [7, 'printer'], [15,
          'standard_output'], [10, 'wait_queue']],
    output_state: [STATIC, READ, oss$job_paged_literal] array [jmt$output_state] of record
      size: 1 .. max_output_state_size,
      value: string (max_output_state_size),
    recend := [[8, 'deferred'], [21, 'waiting to be printed'], [8, 'printing'], [10, 'terminated'], [9,
          'completed']],
    processing_phase: [STATIC, READ, oss$job_paged_literal] array [clt$processing_phase] of record
      size: 1 .. max_processing_phase_size,
      value: string (max_processing_phase_size),
    recend := [[15, 'job begin phase'], [19, 'system prolog phase'], [18, 'class prolog phase'], [20,
          'account prolog phase'], [20, 'project prolog phase'], [20, 'member prolog phase'], [17,
          'user prolog phase'], [13, 'command phase'], [17, 'user epilog phase'], [20, 'member epilog phase'],
          [20, 'project epilog phase'], [20, 'account epilog phase'], [18, 'class epilog phase'], [19,
          'system epilog phase'], [13, 'job end phase']],
    terminate_job_action: [STATIC, READ, oss$job_paged_literal] array [jmt$terminate_job_action] of record
      size: 1 .. max_terminate_job_action_size,
      value: string (max_terminate_job_action_size),
    recend := [[13, 'kill_disabled'], [21, 'operator_kill_enabled'], [17, 'user_kill_enabled']],
    qfile_state: [STATIC, READ, oss$job_paged_literal] array [jmt$qfile_state] of record
      size: 1 .. max_qfile_state_size,
      value: string (max_qfile_state_size),
    recend := [[8, 'deferred'], [23, 'waiting to be processed'], [10, 'processing'], [10, 'terminated'], [9,
          'completed']];

?? EJECT ??

{ PURPOSE:
{   The alphabetical_attribute_list is used for searching for attributes based on name.  Not all
{ attributes are placed in this table.  Only the attributes that need to be searched by name for some
{ process are located in this table.  Attributes are searched by name by SCL function processors and
{ as display_options on various display commands.
{
{ NOTES:
{   Remember: In the ASCII collating sequence the underscore comes after and alpha/numeric characters.
{ Therefore, if a='ABC_XYZ' and b='ABCDXYZ', a > b.
{
{   Some attributes are not present in this table because of name or abbreviation conflicts.  For example,
{ the attributes job_state and job_size have the same abbreviation so only on abbreviation can appear in
{ the table.
{
{   This table MUST be in alphabetical order.

  CONST
    alphabetical_attribute_count = 121;

?? FMT (FORMAT := OFF) ??
  VAR
    alphabetical_attribute_list: [STATIC, READ, oss$job_paged_literal] array [1 ..
          alphabetical_attribute_count] of record
      attribute_name: ost$name,
      attribute_index: jmt$attribute_keys,
    recend := [
      ['ACCOUNT                        ', jmc$login_account],
      ['APPLICATION_NAME               ', jmc$application_name],
      ['APPLICATION_STATUS             ', jmc$application_status],
      ['C170_OS_TYPE                   ', jmc$c170_os_type],
      ['CLIENT_MAINFRAME_IDENTIFIER    ', jmc$client_mainframe_id],
      ['COMMENT_BANNER                 ', jmc$comment_banner],
      ['CONTROL_FAMILY                 ', jmc$control_family],
      ['CONTROL_USER                   ', jmc$control_user],
      ['COPIES                         ', jmc$copies],
      ['COPIES_PRINTED                 ', jmc$copies_printed],
      ['CPU_TIME_LIMIT                 ', jmc$cpu_time_limit],
      ['CPU_TIME_USED                  ', jmc$cpu_time_used],
      ['CYCLIC_AGING_INTERVAL          ', jmc$cyclic_aging_interval],
      ['DATA_DECLARATION               ', jmc$data_declaration],
      ['DATA_MODE                      ', jmc$data_mode],
      ['DEFERRED_BY_APPLICATION        ', jmc$deferred_by_application],
      ['DEFERRED_BY_OPERATOR           ', jmc$deferred_by_operator],
      ['DEFERRED_BY_USER               ', jmc$deferred_by_user],
      ['DESTINATION                    ', jmc$destination],
      ['DESTINATION_FAMILY             ', jmc$output_destination_family],
      ['DESTINATION_USAGE              ', jmc$output_destination_usage],
      ['DETACHED_JOB_WAIT_TIME         ', jmc$detached_job_wait_time],
      ['DEVICE                         ', jmc$device],
      ['DEVICE_TYPE                    ', jmc$device_type],
      ['DISPATCHING_PRIORITY           ', jmc$dispatching_priority],
      ['DISPLAY_MESSAGE                ', jmc$display_message],
      ['DUAL_STATE_ROUTE_PARAMETERS    ', jmc$remote_host_directive],
      ['EARLIEST_PRINT_TIME            ', jmc$earliest_print_time],
      ['EARLIEST_RUN_TIME              ', jmc$earliest_run_time],
      ['EXTERNAL_CHARACTERISTICS       ', jmc$external_characteristics],
      ['FAMILY_NAME                    ', jmc$login_family],
      ['FILE_POSITION                  ', jmc$file_position],
      ['FILE_SIZE                      ', jmc$file_size],
      ['FORMS_CODE                     ', jmc$forms_code],
      ['INPUT_FILE_LOCATION            ', jmc$input_file_location],
      ['JOB_ABORT_DISPOSITION          ', jmc$job_abort_disposition],
      ['JOB_CLASS                      ', jmc$job_class],
      ['JOB_CLASS_POSITION             ', jmc$job_class_position],
      ['JOB_DEFERRED_BY_OPERATOR       ', jmc$job_deferred_by_operator],
      ['JOB_DEFERRED_BY_USER           ', jmc$job_deferred_by_user],
      ['JOB_DESTINATION                ', jmc$job_destination_family],
      ['JOB_DESTINATION_USAGE          ', jmc$job_destination_usage],
      ['JOB_EXECUTION_RING             ', jmc$job_execution_ring],
      ['JOB_INITIATION_TIME            ', jmc$job_initiation_time],
      ['JOB_MODE                       ', jmc$job_mode],
      ['JOB_MODE_CPU_TIME              ', jmc$cpu_time_used],
      ['JOB_NAME                       ', jmc$user_job_name],
      ['JOB_PRIORITY                   ', jmc$job_priority],
      ['JOB_PROCESSING_PHASE           ', jmc$processing_phase],
      ['JOB_QUALIFIER                  ', jmc$job_qualifier_list],
      ['JOB_QUALIFIERS                 ', jmc$job_qualifier_list],
      ['JOB_RECOVERY_DISPOSITION       ', jmc$job_recovery_disposition],
      ['JOB_SIZE                       ', jmc$job_size],
      ['JOB_STATE                      ', jmc$job_state],
      ['JOB_SUBMISSION_TIME            ', jmc$job_submission_time],
      ['LATEST_PRINT_TIME              ', jmc$latest_print_time],
      ['LATEST_RUN_TIME                ', jmc$latest_run_time],
      ['LOGIN_ACCOUNT                  ', jmc$login_account],
      ['LOGIN_FAMILY                   ', jmc$login_family],
      ['LOGIN_PROJECT                  ', jmc$login_project],
      ['LOGIN_USER                     ', jmc$login_user],
      ['MAGNETIC_TAPE_LIMIT            ', jmc$magnetic_tape_limit],
      ['MAXIMUM_WORKING_SET            ', jmc$maximum_working_set],
      ['MINIMUM_WORKING_SET            ', jmc$minimum_working_set],
      ['MODE                           ', jmc$job_mode],
      ['MONITOR_MODE_CPU_TIME          ', jmc$cpu_time_used],
      ['NAME                           ', jmc$system_file_name],
      ['OPERATOR                       ', jmc$operator_job],
      ['OPERATOR_ACTION_POSTED         ', jmc$operator_action_posted],
      ['OPERATOR_FAMILY                ', jmc$output_destination_family],
      ['OPERATOR_JOB                   ', jmc$operator_job],
      ['OPERATOR_USER                  ', jmc$station_operator],
      ['ORIGINATING_APPLICATION_NAME   ', jmc$origin_application_name],
      ['OS_VERSION                     ', jmc$os_version],
      ['OUTPUT_CLASS                   ', jmc$output_class],
      ['OUTPUT_DEFERRED_BY_OPERATOR    ', jmc$output_deferred_by_operator],
      ['OUTPUT_DEFERRED_BY_USER        ', jmc$output_deferred_by_user],
      ['OUTPUT_DESTINATION             ', jmc$output_destination],
      ['OUTPUT_DESTINATION_USAGE       ', jmc$output_destination_usage],
      ['OUTPUT_DISPOSITION             ', jmc$output_disposition],
      ['OUTPUT_PRIORITY                ', jmc$output_priority],
      ['OUTPUT_STATE                   ', jmc$output_state],
      ['OUTPUT_SUBMISSION_TIME         ', jmc$output_submission_time],
      ['PAGES_ASSIGNED                 ', jmc$page_faults],
      ['PAGES_FROM_DISK                ', jmc$page_faults],
      ['PAGES_RECLAIMED                ', jmc$page_faults],
      ['PAGE_AGING_INTERVAL            ', jmc$page_aging_interval],
      ['PAGE_FAULTS                    ', jmc$page_faults],
      ['PROCESSING_PHASE               ', jmc$processing_phase],
      ['PROJECT                        ', jmc$login_project],
      ['PURGE_DELAY                    ', jmc$purge_delay],
      ['QUEUE_FILE_DEFERRED_BY_OPERATOR', jmc$deferred_by_operator],
      ['REMOTE_HOST_DIRECTIVE          ', jmc$remote_host_directive],
      ['ROUTING_BANNER                 ', jmc$routing_banner],
      ['SENSE_SWITCHES                 ', jmc$sense_switches],
      ['SERVER_MAINFRAME_IDENTIFIER    ', jmc$server_mainframe_id],
      ['SERVICE_CLASS                  ', jmc$service_class],
      ['SITE_INFORMATION               ', jmc$site_information],
      ['SOURCE_LOGICAL_ID              ', jmc$source_logical_id],
      ['SRU_LIMIT                      ', jmc$sru_limit],
      ['STATE                          ', jmc$qfile_state],
      ['STATION                        ', jmc$station],
      ['STATION_OPERATOR               ', jmc$station_operator],
      ['SWITCH1                        ', jmc$sense_switches],
      ['SWITCH2                        ', jmc$sense_switches],
      ['SWITCH3                        ', jmc$sense_switches],
      ['SWITCH4                        ', jmc$sense_switches],
      ['SWITCH5                        ', jmc$sense_switches],
      ['SWITCH6                        ', jmc$sense_switches],
      ['SWITCH7                        ', jmc$sense_switches],
      ['SWITCH8                        ', jmc$sense_switches],
      ['SYSTEM                         ', jmc$system_job],
      ['SYSTEM_FILE_NAME               ', jmc$system_file_name],
      ['SYSTEM_JOB                     ', jmc$system_job],
      ['SYSTEM_JOB_NAME                ', jmc$system_job_name],
      ['USER                           ', jmc$login_user],
      ['USER_FILE_NAME                 ', jmc$user_file_name ],
      ['USER_INFORMATION               ', jmc$user_information],
      ['USER_JOB_NAME                  ', jmc$user_job_name],
      ['VERTICAL_PRINT_DENSITY         ', jmc$vertical_print_density],
      ['VFU_LOAD_PROCEDURE             ', jmc$vfu_load_procedure]];
?? FMT (FORMAT := ON) ??
?? EJECT ??

{ PURPOSE:
{   The indexed_attribute_list is used for searching for attributes based on their attribute index.
{ All attributes are placed in this table.
{
{ NOTES:
{   This table MUST be in numerical order.

  CONST
    indexed_attribute_count = 141;

?? FMT (FORMAT := OFF) ??
  VAR
    indexed_attribute_list: [STATIC, READ, oss$job_paged_literal] array [1 ..
          indexed_attribute_count] of record
      attribute_index: jmt$attribute_keys,
      attribute_name: ost$name,
    recend := [
      [jmc$unknown_attribute          , unknown_attribute_name],
      [jmc$application_attributes_1   , 'APPLICATION_ATTRIBUTES_1'],
      [jmc$application_attributes_2   , 'APPLICATION_ATTRIBUTES_2'],
      [jmc$application_attributes_3   , 'APPLICATION_ATTRIBUTES_3'],
      [jmc$application_attributes_4   , 'APPLICATION_ATTRIBUTES_4'],
      [jmc$application_attributes_5   , 'APPLICATION_ATTRIBUTES_5'],
      [jmc$application_attributes_6   , 'APPLICATION_ATTRIBUTES_6'],
      [jmc$application_attributes_7   , 'APPLICATION_ATTRIBUTES_7'],
      [jmc$application_attributes_8   , 'APPLICATION_ATTRIBUTES_8'],
      [jmc$application_attributes_9   , 'APPLICATION_ATTRIBUTES_9'],
      [jmc$application_attributes_10  , 'APPLICATION_ATTRIBUTES_10'],
      [jmc$application_name           , 'APPLICATION_NAME'],
      [jmc$application_status         , 'APPLICATION_STATUS'],
      [jmc$c170_os_type               , 'C170_OS_TYPE'],
      [jmc$client_mainframe_id        , 'CLIENT_MAINFRAME_IDENTIFIER'],
      [jmc$comment_banner             , 'COMMENT_BANNER'],
      [jmc$continue_request_to_servers, 'CONTINUE_REQUEST_TO_SERVERS'],
      [jmc$control_family             , 'CONTROL_FAMILY'],
      [jmc$control_user               , 'CONTROL_USER'],
      [jmc$copies                     , 'COPIES'],
      [jmc$copies_printed             , 'COPIES_PRINTED'],
      [jmc$cpu_time_limit             , 'CPU_TIME_LIMIT'],
      [jmc$cpu_time_used              , 'CPU_TIME_USED'],
      [jmc$cyclic_aging_interval      , 'CYCLIC_AGING_INTERVAL'],
      [jmc$data_declaration           , 'DATA_DECLARATION'],
      [jmc$data_mode                  , 'DATA_MODE'],
      [jmc$default_login_account      , 'DEFAULT_LOGIN_ACCOUNT'],
      [jmc$default_login_family       , 'DEFAULT_LOGIN_FAMILY'],
      [jmc$default_login_password     , 'DEFAULT_LOGIN_PASSWORD'],
      [jmc$default_login_project      , 'DEFAULT_LOGIN_PROJECT'],
      [jmc$default_login_user         , 'DEFAULT_LOGIN_USER'],
      [jmc$deferred_by_operator       , 'DEFERRED_BY_OPERATOR'],
      [jmc$deferred_by_application    , 'DEFERRED_BY_APPLICATION'],
      [jmc$deferred_by_user           , 'DEFERRED_BY_USER'],
      [jmc$destination                , 'DESTINATION'],
      [jmc$detached_job_wait_time     , 'DETACHED_JOB_WAIT_TIME'],
      [jmc$device                     , 'DEVICE'],
      [jmc$device_type                , 'DEVICE_TYPE'],
      [jmc$dispatching_priority       , 'DISPATCHING_PRIORITY'],
      [jmc$display_message            , 'DISPLAY_MESSAGE'],
      [jmc$disposition_code           , 'DISPOSITION_CODE'],
      [jmc$earliest_print_time        , 'EARLIEST_PRINT_TIME'],
      [jmc$earliest_run_time          , 'EARLIEST_RUN_TIME'],
      [jmc$encrypted_password         , 'ENCRYPTED_PASSWORD'],
      [jmc$external_characteristics   , 'EXTERNAL_CHARACTERISTICS'],
      [jmc$file_position              , 'FILE_POSITION'],
      [jmc$file_size                  , 'FILE_SIZE'],
      [jmc$forms_code                 , 'FORMS_CODE'],
      [jmc$immediate_init_candidate   , 'IMMEDIATE_INITIATION_CANDIDATE'],
      [jmc$implicit_routing_text      , 'IMPLICIT_ROUTING_TEXT'],
      [jmc$input_file_location        , 'INPUT_FILE_LOCATION'],
      [jmc$internal_index             , 'INTERNAL_INDEX'],
      [jmc$job_abort_disposition      , 'JOB_ABORT_DISPOSITION'],
      [jmc$job_category_list          , 'JOB_CATEGORY_LIST'],
      [jmc$job_class                  , 'JOB_CLASS'],
      [jmc$job_class_list             , 'JOB_CLASS_LIST'],
      [jmc$job_class_position         , 'JOB_CLASS_POSITION'],
      [jmc$job_deferred_by_operator   , 'JOB_DEFERRED_BY_OPERATOR'],
      [jmc$job_deferred_by_user       , 'JOB_DEFERRED_BY_USER'],
      [jmc$job_destination_family     , 'JOB_DESTINATION_FAMILY'],
      [jmc$job_destination_usage      , 'JOB_DESTINATION_USAGE'],
      [jmc$job_execution_ring         , 'JOB_EXECUTION_RING'],
      [jmc$job_initiation_time        , 'JOB_INITIATION_TIME'],
      [jmc$job_input_device           , 'JOB_INPUT_DEVICE'],
      [jmc$job_mode                   , 'JOB_MODE'],
      [jmc$job_mode_set               , 'JOB_MODE_SET'],
      [jmc$job_priority               , 'JOB_PRIORITY'],
      [jmc$job_qualifier_list         , 'JOB_QUALIFIER_LIST'],
      [jmc$job_recovery_disposition   , 'JOB_RECOVERY_DISPOSITION'],
      [jmc$job_size                   , 'JOB_SIZE'],
      [jmc$job_state                  , 'JOB_STATE'],
      [jmc$job_state_set              , 'JOB_STATE_SET'],
      [jmc$job_submission_time        , 'JOB_SUBMISSION_TIME'],
      [jmc$latest_print_time          , 'LATEST_PRINT_TIME'],
      [jmc$latest_run_time            , 'LATEST_RUN_TIME'],
      [jmc$login_account              , 'LOGIN_ACCOUNT'],
      [jmc$login_command              , 'LOGIN_COMMAND'],
      [jmc$login_command_supplied     , 'LOGIN_COMMAND_SUPPLIED'],
      [jmc$login_family               , 'LOGIN_FAMILY'],
      [jmc$login_password             , 'LOGIN_PASSWORD'],
      [jmc$login_project              , 'LOGIN_PROJECT'],
      [jmc$login_user                 , 'LOGIN_USER'],
      [jmc$magnetic_tape_limit        , 'MAGNETIC_TAPE_LIMIT'],
      [jmc$maximum_working_set        , 'MAXIMUM_WORKING_SET'],
      [jmc$minimum_working_set        , 'MINIMUM_WORKING_SET'],
      [jmc$name_list                  , 'NAME_LIST'],
      [jmc$notify_on_terminate        , 'NOTIFY_ON_TERMINATE'],
      [jmc$null_attribute             , 'NULL_ATTRIBUTE'],
      [jmc$omit_class_validation      , 'OMIT_CLASS_VALIDATION'],
      [jmc$omit_user_prolog_and_epilog, 'OMIT_USER_PROLOG_AND_EPILOG'],
      [jmc$operator_action_posted     , 'OPERATOR_ACTION_POSTED'],
      [jmc$operator_job               , 'OPERATOR_JOB'],
      [jmc$optional_user_capability   , 'OPTIONAL_USER_CAPABILITY'],
      [jmc$origin_application_name    , 'ORIGINATING_APPLICATION_NAME'],
      [jmc$os_version                 , 'OS_VERSION'],
      [jmc$output_class               , 'OUTPUT_CLASS'],
      [jmc$output_deferred_by_operator, 'OUTPUT_DEFERRED_BY_OPERATOR'],
      [jmc$output_deferred_by_user    , 'OUTPUT_DEFERRED_BY_USER'],
      [jmc$output_destination         , 'OUTPUT_DESTINATION'],
      [jmc$output_destination_family  , 'OUTPUT_DESTINATION_FAMILY'],
      [jmc$output_destination_usage   , 'OUTPUT_DESTINATION_USAGE'],
      [jmc$output_disposition         , 'OUTPUT_DISPOSITION'],
      [jmc$output_priority            , 'OUTPUT_PRIORITY'],
      [jmc$output_state               , 'OUTPUT_STATE'],
      [jmc$output_state_set           , 'OUTPUT_STATE_SET'],
      [jmc$output_submission_time     , 'OUTPUT_SUBMISSION_TIME'],
      [jmc$page_aging_interval        , 'PAGE_AGING_INTERVAL'],
      [jmc$page_faults                , 'PAGE_FAULTS'],
      [jmc$processing_phase           , 'PROCESSING_PHASE'],
      [jmc$purge_delay                , 'PURGE_DELAY'],
      [jmc$qfile_state                , 'STATE'],
      [jmc$qfile_state_set            , 'QFILE_STATE_SET'],
      [jmc$recovery_disposition       , 'RECOVERY_DISPOSITION'],
      [jmc$remote_host_directive      , 'REMOTE_HOST_DIRECTIVE'],
      [jmc$reprint_disposition        , 'REPRINT_DISPOSITION'],
      [jmc$required_user_capability   , 'REQUIRED_USER_CAPABILITY'],
      [jmc$rerun_disposition          , 'RERUN_DISPOSITION'],
      [jmc$routing_banner             , 'ROUTING_BANNER'],
      [jmc$sense_switches             , 'SENSE_SWITCHES'],
      [jmc$server_mainframe_id        , 'SERVER_MAINFRAME_IDENTIFIER'],
      [jmc$service_class              , 'SERVICE_CLASS'],
      [jmc$site_information           , 'SITE_INFORMATION'],
      [jmc$source_logical_id          , 'SOURCE_LOGICAL_ID'],
      [jmc$sru_limit                  , 'SRU_LIMIT'],
      [jmc$station                    , 'STATION'],
      [jmc$station_operator           , 'STATION_OPERATOR'],
      [jmc$system_job                 , 'SYSTEM_JOB'],
      [jmc$system_job_parameters      , 'SYSTEM_JOB_PARAMETERS'],
      [jmc$system_file_name           , 'SYSTEM_FILE_NAME'],
      [jmc$system_job_name            , 'SYSTEM_JOB_NAME'],
      [jmc$system_routing_text        , 'SYSTEM_ROUTING_TEXT'],
      [jmc$system_supplied_name_list  , 'SYSTEM_SUPPLIED_NAME_LIST'],
      [jmc$terminate_job_action_set   , 'TERMINATE_JOB_ACTION_SET'],
      [jmc$termination_reason         , 'TERMINATION_REASON'],
      [jmc$user_file_name             , 'USER_FILE_NAME'],
      [jmc$user_identification        , 'USER_IDENTIFICATION'],
      [jmc$user_information           , 'USER_INFORMATION'],
      [jmc$user_job_name              , 'USER_JOB_NAME'],
      [jmc$validation_ring            , 'VALIDATION_RING'],
      [jmc$vertical_print_density     , 'VERTICAL_PRINT_DENSITY'],
      [jmc$vfu_load_procedure         , 'VFU_LOAD_PROCEDURE']];
?? FMT (FORMAT := ON) ??
?? OLDTITLE ??
?? NEWTITLE := 'assign_function_value', EJECT ??

{ PURPOSE:
{   The purpose of this request is to assign a function value to a job management
{ SCL function.
{
{ DESIGN:
{   The interface accepts a pointer to one of the job management attribute types and
{ uses the jmt$attribute_value type (which is a superset of all of the job management
{ attribute types) to convert the value into the SCL function value.  This allows
{ a single procedure to assign all function values and only one copy of the value
{ assignment for each job management attribute is therefore required.

  PROCEDURE assign_function_value
    (    generic_attribute_value_p: ^cell;
         attribute_name: string ( * <= osc$max_name_size);
     VAR work_area {input, output} : ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);

    VAR
      attribute_value_p: ^jmt$attribute_value,
      index: ost$non_negative_integers,
      job_qualifier_exists: boolean,
      node: ^clt$data_value,
      scl_name: ost$name,
      string_size: ost$string_size;

    VAR
      c170_os_types: [STATIC, READ, oss$job_paged_literal] array [ost$170_os_type] of string (6) := ['NONE',
            'NOS', 'NOS/BE'],
      data_mode: [STATIC, READ, oss$job_paged_literal] array [jmt$data_mode] of string (13) := ['CODED',
            'RHF_STRUCTURE', 'TRANSPARENT'],
      device_type: [STATIC, READ, oss$job_paged_literal] array [jmt$output_device_type] of string (7) :=
            ['PRINTER', 'PLOTTER', 'PUNCH'],
      input_file_location: [STATIC, READ, oss$job_paged_literal] array
            [jmc$ifl_no_input_file_exists .. jmc$ifl_login_family_queue] of string (23) :=
            ['NO_INPUT_FILE_EXISTS', 'SYSTEM_INPUT_QUEUE', 'STORE_AND_FORWARD_QUEUE', 'LOGIN_FAMILY_QUEUE'],
      job_abort_disposition: [STATIC, READ, oss$job_paged_literal] array [jmt$job_abort_disposition] of
            string (9) := ['RESTART', 'TERMINATE'],
      job_modes: [STATIC, READ, oss$job_paged_literal] array [jmt$job_mode] of string (30) := ['BATCH',
            'INTERACTIVE', 'INTERACTIVE_COMMAND_DISCONNECT', 'INTERACTIVE_LINE_DISCONNECT',
            'INTERACTIVE_SYSTEM_DISCONNECT'],
      job_recovery_disposition: [STATIC, READ, oss$job_paged_literal] array [jmt$job_recovery_disposition] of
            string (9) := ['CONTINUE', 'RESTART', 'TERMINATE'],
      job_state: [STATIC, READ, oss$job_paged_literal] array [jmt$job_state] of string (10) := ['DEFERRED',
            'QUEUED', 'INITIATED', 'TERMINATED', 'COMPLETED'],
      output_disposition: [STATIC, READ, oss$job_paged_literal] array [jmt$output_disposition_keys] of
            string (23) := ['DISCARD_ALL_OUTPUT', 'DISCARD_STANDARD_OUTPUT', 'LOCAL', 'PRINTER',
            'STANDARD_OUTPUT', 'WAIT_QUEUE'],
      output_state: [STATIC, READ, oss$job_paged_literal] array [jmt$output_state] of string (10) :=
            ['DEFERRED', 'QUEUED', 'INITIATED', 'TERMINATED', 'COMPLETED'],
      phases: [STATIC, READ, oss$job_paged_literal] array [clt$processing_phase] of string (20) :=
            ['JOB_BEGIN_PHASE', 'SYSTEM_PROLOG_PHASE', 'CLASS_PROLOG_PHASE', 'ACCOUNT_PROLOG_PHASE',
            'PROJECT_PROLOG_PHASE', 'MEMBER_PROLOG_PHASE', 'USER_PROLOG_PHASE', 'COMMAND_PHASE',
            'USER_EPILOG_PHASE', 'MEMBER_EPILOG_PHASE', 'PROJECT_EPILOG_PHASE', 'ACCOUNT_EPILOG_PHASE',
            'CLASS_EPILOG_PHASE', 'SYSTEM_EPILOG_PHASE', 'JOB_END_PHASE'],
      qfile_state: [STATIC, READ, oss$job_paged_literal] array [jmt$qfile_state] of string (10) :=
            ['DEFERRED', 'QUEUED', 'INITIATED', 'TERMINATED', 'COMPLETED'],
      vertical_print_density: [STATIC, READ, oss$job_paged_literal] array [jmt$vertical_print_density] of
            string (6) := ['FILE', 'NONE', 'SIX', 'SEVEN', 'EIGHT', 'NINE', 'TEN', 'ELEVEN', 'TWELVE'];

?? NEWTITLE := 'make_date_time_value', EJECT ??

    PROCEDURE [INLINE] make_date_time_value
      (    date_time: ost$date_time;
       VAR work_area { input, output } : ^clt$work_area;
       VAR result: ^clt$data_value);

      VAR
        scl_date_time: clt$date_time;

      scl_date_time.value := date_time;
      scl_date_time.date_specified := TRUE;
      scl_date_time.time_specified := TRUE;
      clp$make_date_time_value (scl_date_time, work_area, result);
    PROCEND make_date_time_value;
?? OLDTITLE ??
?? NEWTITLE := 'make_trimmed_string_value', EJECT ??

    PROCEDURE [INLINE] make_trimmed_string_value
      (    string_value: string ( * );
       VAR work_area { input, output } : ^clt$work_area;
       VAR result: ^clt$data_value);

      clp$make_string_value (string_value (1, clp$trimmed_string_size (string_value)), work_area, result);
    PROCEND make_trimmed_string_value;
?? OLDTITLE ??
?? EJECT ??

    status.normal := TRUE;
    attribute_value_p := generic_attribute_value_p;
    CASE attribute_value_p^.key OF
    = jmc$application_name =
      clp$make_name_value (attribute_value_p^.application_name, work_area, result);

    = jmc$application_status =
      clp$make_status_value (attribute_value_p^.application_status^, work_area, result);

    = jmc$c170_os_type =
      make_trimmed_string_value (c170_os_types [attribute_value_p^.c170_os_type], work_area, result);

    = jmc$client_mainframe_id =
      IF attribute_value_p^.client_mainframe_id = '' THEN
        clp$make_name_value (none, work_area, result);
      ELSE
        clp$make_name_value (attribute_value_p^.client_mainframe_id, work_area, result);
      IFEND;

    = jmc$comment_banner =
      make_trimmed_string_value (attribute_value_p^.comment_banner, work_area, result);

    = jmc$control_family =
      clp$make_name_value (attribute_value_p^.control_family, work_area, result);

    = jmc$control_user =
      clp$make_name_value (attribute_value_p^.control_user, work_area, result);

    = jmc$copies =
      clp$make_integer_value (attribute_value_p^.copies, { radix } 10, { radix_specified } FALSE, work_area,
            result);

    = jmc$copies_printed =
      clp$make_integer_value (attribute_value_p^.copies_printed, { radix } 10, { radix_specified } FALSE,
            work_area, result);

    = jmc$cpu_time_limit =
      IF attribute_value_p^.cpu_time_limit <= jmc$highest_cpu_time_limit THEN
        clp$make_integer_value (attribute_value_p^.cpu_time_limit, { radix } 10, { radix_specified } FALSE,
              work_area, result);
      ELSE
        IF attribute_value_p^.cpu_time_limit = jmc$unlimited_cpu_time_limit THEN
          scl_name := 'UNLIMITED';
        ELSE { IF attribute_value_p^.cpu_time_limit = jmc$required_cpu_time_limit THEN
          scl_name := 'REQUIRED';
        IFEND;
        clp$make_name_value (scl_name, work_area, result);
      IFEND;

    = jmc$cpu_time_used =
      IF attribute_name = 'JOB_MODE_CPU_TIME' THEN
        clp$make_integer_value (attribute_value_p^.cpu_time_used.job_mode_time, { radix } 10,
              { radix_specified } FALSE, work_area, result);
      ELSE { IF attribute_name = 'MONITOR_MODE_CPU_TIME' THEN
        clp$make_integer_value (attribute_value_p^.cpu_time_used.monitor_mode_time, { radix } 10,
              { radix_specified } FALSE, work_area, result);
      IFEND;

    = jmc$cyclic_aging_interval =
      clp$make_integer_value (attribute_value_p^.cyclic_aging_interval, { radix } 10,
            { radix_specified } FALSE, work_area, result);

    = jmc$data_declaration =
      make_trimmed_string_value (attribute_value_p^.data_declaration, work_area, result);

    = jmc$data_mode =
      clp$make_name_value (data_mode [attribute_value_p^.data_mode], work_area, result);

    = jmc$deferred_by_application =
      clp$make_boolean_value (attribute_value_p^.deferred_by_application, clc$yes_no_boolean, work_area,
            result);

    = jmc$deferred_by_operator =
      clp$make_boolean_value (attribute_value_p^.deferred_by_operator, clc$yes_no_boolean, work_area, result);

    = jmc$deferred_by_user =
      clp$make_boolean_value (attribute_value_p^.deferred_by_user, clc$yes_no_boolean, work_area, result);

    = jmc$detached_job_wait_time =
      IF attribute_value_p^.detached_job_wait_time <= jmc$highest_det_job_wait_time THEN
        clp$make_integer_value (attribute_value_p^.detached_job_wait_time, { radix } 10,
              { radix_specified } FALSE, work_area, result);
      ELSE
        clp$make_name_value ('UNLIMITED', work_area, result);
      IFEND;

    = jmc$device =
      clp$make_name_value (attribute_value_p^.device, work_area, result);

    = jmc$device_type =
      clp$make_name_value (device_type [attribute_value_p^.device_type], work_area, result);

    = jmc$display_message =
      clp$make_string_value (attribute_value_p^.display_message^.
            value (1, attribute_value_p^.display_message^.size), work_area, result);

    = jmc$dispatching_priority =
      clp$make_name_value (attribute_value_p^.dispatching_priority, work_area, result);

    = jmc$earliest_print_time =
      IF attribute_value_p^.earliest_print_time.specified THEN
        make_date_time_value (attribute_value_p^.earliest_print_time.date_time, work_area, result);
      ELSE
        clp$make_name_value (none, work_area, result);
      IFEND;

    = jmc$earliest_run_time =
      IF attribute_value_p^.earliest_run_time.specified THEN
        make_date_time_value (attribute_value_p^.earliest_run_time.date_time, work_area, result);
      ELSE
        clp$make_name_value (none, work_area, result);
      IFEND;

    = jmc$external_characteristics =
      make_trimmed_string_value (attribute_value_p^.external_characteristics, work_area, result);

    = jmc$file_position =
      clp$make_integer_value (attribute_value_p^.file_position, { radix } 10, { radix_specified } FALSE,
            work_area, result);

    = jmc$file_size =
      clp$make_integer_value (attribute_value_p^.file_size, { radix } 10, { radix_specified } FALSE,
            work_area, result);

    = jmc$forms_code =
      make_trimmed_string_value (attribute_value_p^.forms_code, work_area, result);

    = jmc$input_file_location =
      clp$make_name_value (input_file_location [attribute_value_p^.input_file_location], work_area, result);

    = jmc$job_abort_disposition =
      clp$make_name_value (job_abort_disposition [attribute_value_p^.job_abort_disposition], work_area,
            result);

    = jmc$job_class =
      IF attribute_value_p^.job_class = osc$null_name THEN
        clp$make_name_value ('NONE', work_area, result);
      ELSE
        clp$make_name_value (attribute_value_p^.job_class, work_area, result);
      IFEND;

    = jmc$job_class_position =
      IF attribute_value_p^.job_class_position = 0 THEN
        clp$make_name_value (none, work_area, result);
      ELSE
        clp$make_integer_value (attribute_value_p^.job_class_position, { radix } 10,
              { radix_specified } FALSE, work_area, result);
      IFEND;

    = jmc$job_deferred_by_operator =
      clp$make_boolean_value (attribute_value_p^.job_deferred_by_operator, clc$yes_no_boolean, work_area,
            result);

    = jmc$job_deferred_by_user =
      clp$make_boolean_value (attribute_value_p^.job_deferred_by_user, clc$yes_no_boolean, work_area, result);

    = jmc$job_destination_family =
      make_trimmed_string_value (attribute_value_p^.job_destination_family, work_area, result);

    = jmc$job_destination_usage =
      clp$make_name_value (attribute_value_p^.job_destination_usage, work_area, result);

    = jmc$job_execution_ring =
      IF attribute_value_p^.job_execution_ring = osc$invalid_ring THEN
        clp$make_name_value ('NOMINAL', work_area, result);
      ELSE
        clp$make_integer_value (attribute_value_p^.job_execution_ring, { radix } 10,
              { radix_specified } FALSE, work_area, result);
      IFEND;

    = jmc$job_initiation_time =
      IF attribute_value_p^.job_initiation_time.specified THEN
        make_date_time_value (attribute_value_p^.job_initiation_time.date_time, work_area, result);
      ELSE
        clp$make_name_value (none, work_area, result);
      IFEND;

    = jmc$job_mode =
      IF attribute_name = 'MODE' THEN
        make_trimmed_string_value (job_modes [attribute_value_p^.job_mode], work_area, result);
      ELSE
        clp$make_name_value (job_modes [attribute_value_p^.job_mode], work_area, result);
      IFEND;

    = jmc$job_qualifier_list =

    /generate_job_qualifier_list/
      BEGIN
        clp$make_list_value (work_area, result);
        IF result = NIL THEN
          EXIT /generate_job_qualifier_list/; {----->
        IFEND;
        job_qualifier_exists := FALSE;
        node := result;
        FOR index := 1 TO UPPERBOUND (attribute_value_p^.job_qualifier_list^) DO
          IF attribute_value_p^.job_qualifier_list^ [index] <> osc$null_name THEN
            IF job_qualifier_exists THEN
              clp$make_list_value (work_area, node^.link);
              IF node^.link = NIL THEN
                result := NIL;
                EXIT /generate_job_qualifier_list/; {----->
              ELSE
                node := node^.link;
              IFEND;
            ELSE
              job_qualifier_exists := TRUE;
            IFEND;
            clp$make_name_value (attribute_value_p^.job_qualifier_list^ [index], work_area,
                  node^.element_value);
            IF node^.element_value = NIL THEN
              result := NIL;
              EXIT /generate_job_qualifier_list/; {----->
            IFEND;
          IFEND;
        FOREND;
        IF NOT job_qualifier_exists THEN
          clp$make_name_value (none, work_area, result^.element_value);
          IF result^.element_value = NIL THEN
            result := NIL;
          IFEND;
        IFEND;
      END /generate_job_qualifier_list/;

    = jmc$job_recovery_disposition =
      clp$make_name_value (job_recovery_disposition [attribute_value_p^.job_recovery_disposition], work_area,
            result);

    = jmc$job_size =
      clp$make_integer_value (attribute_value_p^.job_size, { radix } 10, { radix_specified } FALSE, work_area,
            result);

    = jmc$job_state =
      clp$make_name_value (job_state [attribute_value_p^.job_state], work_area, result);

    = jmc$job_submission_time =
      make_date_time_value (attribute_value_p^.job_submission_time, work_area, result);

    = jmc$latest_print_time =
      IF attribute_value_p^.latest_print_time.specified THEN
        make_date_time_value (attribute_value_p^.latest_print_time.date_time, work_area, result);
      ELSE
        clp$make_name_value (none, work_area, result);
      IFEND;

    = jmc$latest_run_time =
      IF attribute_value_p^.latest_run_time.specified THEN
        make_date_time_value (attribute_value_p^.latest_run_time.date_time, work_area, result);
      ELSE
        clp$make_name_value (none, work_area, result);
      IFEND;

    = jmc$login_account =
      IF attribute_name = 'ACCOUNT' THEN
        make_trimmed_string_value (attribute_value_p^.login_account, work_area, result);
      ELSE
        IF attribute_value_p^.login_account = osc$null_name THEN
          clp$make_name_value ('NONE', work_area, result);
        ELSE
          clp$make_name_value (attribute_value_p^.login_account, work_area, result);
        IFEND;
      IFEND;

    = jmc$login_family =
      IF attribute_name = 'FAMILY_NAME' THEN
        make_trimmed_string_value (attribute_value_p^.login_family, work_area, result);
      ELSE
        IF attribute_value_p^.login_family = osc$null_name THEN
          clp$make_name_value ('NONE', work_area, result);
        ELSE
          clp$make_name_value (attribute_value_p^.login_family, work_area, result);
        IFEND;
      IFEND;

    = jmc$login_project =
      IF attribute_name = 'PROJECT' THEN
        make_trimmed_string_value (attribute_value_p^.login_project, work_area, result);
      ELSE
        IF attribute_value_p^.login_project = osc$null_name THEN
          clp$make_name_value ('NONE', work_area, result);
        ELSE
          clp$make_name_value (attribute_value_p^.login_project, work_area, result);
        IFEND;
      IFEND;

    = jmc$login_user =
      IF attribute_name = 'USER' THEN
        make_trimmed_string_value (attribute_value_p^.login_user, work_area, result);
      ELSE
        IF attribute_value_p^.login_user = osc$null_name THEN
          clp$make_name_value ('NONE', work_area, result);
        ELSE
          clp$make_name_value (attribute_value_p^.login_user, work_area, result);
        IFEND;
      IFEND;

    = jmc$magnetic_tape_limit =
      IF attribute_value_p^.magnetic_tape_limit <= jmc$highest_magnetic_tape_limit THEN
        clp$make_integer_value (attribute_value_p^.magnetic_tape_limit, { radix } 10,
              { radix_specified } FALSE, work_area, result);
      ELSE
        IF attribute_value_p^.magnetic_tape_limit = jmc$unlimited_mag_tape_limit THEN
          scl_name := 'UNLIMITED';
        ELSEIF attribute_value_p^.magnetic_tape_limit = jmc$unspecified_mag_tape_limit THEN
          scl_name := 'UNSPECIFIED';
        ELSE { IF attribute_value_p^ .magnetic_tape_limit = jmc$required_mag_tape_limit THEN
          scl_name := 'REQUIRED';
        IFEND;
        clp$make_name_value (scl_name, work_area, result);
      IFEND;

    = jmc$maximum_working_set =
      IF attribute_value_p^.maximum_working_set <= jmc$highest_working_set_size THEN
        clp$make_integer_value (attribute_value_p^.maximum_working_set, { radix } 10,
              { radix_specified } FALSE, work_area, result);
      ELSE
        IF attribute_value_p^.maximum_working_set = jmc$unlimited_working_set_size THEN
          scl_name := 'UNLIMITED';
        ELSE { IF attribute_value_p^ .maximum_working_set = jmc$required_working_set_size THEN
          scl_name := 'REQUIRED';
        IFEND;
        clp$make_name_value (scl_name, work_area, result);
      IFEND;

    = jmc$minimum_working_set =
      clp$make_integer_value (attribute_value_p^.minimum_working_set, { radix } 10, { radix_specified } FALSE,
            work_area, result);

    = jmc$operator_action_posted =
      clp$make_boolean_value (attribute_value_p^.operator_action_posted, clc$yes_no_boolean, work_area,
            result);

    = jmc$operator_job =
      clp$make_boolean_value (attribute_value_p^.operator_job, clc$yes_no_boolean, work_area, result);

    = jmc$origin_application_name =
      clp$make_name_value (attribute_value_p^.origin_application_name, work_area, result);

    = jmc$os_version =
      make_trimmed_string_value (attribute_value_p^.os_version, work_area, result);

    = jmc$output_class =
      string_size := clp$trimmed_string_size (attribute_value_p^.output_class);
      IF string_size > 0 THEN
        scl_name := attribute_value_p^.output_class;
      ELSE
        scl_name := none;
      IFEND;
      clp$make_name_value (scl_name, work_area, result);

    = jmc$output_deferred_by_operator =
      clp$make_boolean_value (attribute_value_p^.output_deferred_by_operator, clc$yes_no_boolean, work_area,
            result);

    = jmc$output_deferred_by_user =
      clp$make_boolean_value (attribute_value_p^.output_deferred_by_user, clc$yes_no_boolean, work_area,
            result);

    = jmc$output_destination =
      make_trimmed_string_value (attribute_value_p^.output_destination, work_area, result);

    = jmc$output_destination_family =
      clp$make_name_value (attribute_value_p^.output_destination_family, work_area, result);

    = jmc$output_destination_usage =
      clp$make_name_value (attribute_value_p^.output_destination_usage, work_area, result);

    = jmc$output_disposition =
      IF attribute_value_p^.output_disposition.key = jmc$standard_output_path THEN

        clp$make_file_value (attribute_value_p^.output_disposition.standard_output_path^, work_area, result);
      ELSE
        clp$make_name_value (output_disposition [attribute_value_p^.output_disposition.key], work_area,
              result);
      IFEND;

    = jmc$output_priority =
      string_size := clp$trimmed_string_size (attribute_value_p^.output_priority);
      IF string_size > 0 THEN
        scl_name := attribute_value_p^.output_priority;
      ELSE
        scl_name := none;
      IFEND;
      clp$make_name_value (scl_name, work_area, result);

    = jmc$output_state =
      clp$make_name_value (output_state [attribute_value_p^.output_state], work_area, result);

    = jmc$output_submission_time =
      make_date_time_value (attribute_value_p^.output_submission_time, work_area, result);

    = jmc$page_aging_interval =
      clp$make_integer_value (attribute_value_p^.page_aging_interval, { radix } 10, { radix_specified } FALSE,
            work_area, result);

    = jmc$page_faults =
      IF attribute_name = 'PAGES_ASSIGNED' THEN
        clp$make_integer_value (attribute_value_p^.page_faults.new_pages_assigned, { radix } 10,
              { radix_specified } FALSE, work_area, result);
      ELSEIF attribute_name = 'PAGES_FROM_DISK' THEN
        clp$make_integer_value (attribute_value_p^.page_faults.pages_read_from_disk, { radix } 10,
              { radix_specified } FALSE, work_area, result);
      ELSE { IF attribute_name = 'PAGES_RECLAIMED' THEN
        clp$make_integer_value (attribute_value_p^.page_faults.pages_reclaimed_from_memory, { radix } 10,
              { radix_specified } FALSE, work_area, result);
      IFEND;

    = jmc$processing_phase =
      IF attribute_name = 'PROCESSING_PHASE' THEN
        make_trimmed_string_value (phases [translated_processing_phase (attribute_value_p^.processing_phase)],
              work_area, result);
      ELSE
        clp$make_name_value (phases [translated_processing_phase (attribute_value_p^.processing_phase)],
              work_area, result);
      IFEND;

    = jmc$purge_delay =
      IF attribute_value_p^.purge_delay^.specified THEN
        clp$make_time_increment_value (^attribute_value_p^.purge_delay^.time_increment, work_area, result);
      ELSE
        clp$make_name_value (none, work_area, result);
      IFEND;

    = jmc$remote_host_directive =
      clp$make_string_value (attribute_value_p^.remote_host_directive^.
            parameters (1, attribute_value_p^.remote_host_directive^.size), work_area, result);

    = jmc$routing_banner =
      make_trimmed_string_value (attribute_value_p^.routing_banner, work_area, result);

    = jmc$sense_switches =
      clp$make_boolean_value (($INTEGER (attribute_name (7)) - $INTEGER ('0')) IN
            attribute_value_p^.sense_switches, clc$on_off_boolean, work_area, result);

    = jmc$server_mainframe_id =
      IF attribute_value_p^.server_mainframe_id = '' THEN
        clp$make_name_value (none, work_area, result);
      ELSE
        clp$make_name_value (attribute_value_p^.server_mainframe_id, work_area, result);
      IFEND;

    = jmc$service_class =
      clp$make_name_value (attribute_value_p^.service_class, work_area, result);

    = jmc$site_information =
      make_trimmed_string_value (attribute_value_p^.site_information^, work_area, result);

    = jmc$source_logical_id =
      make_trimmed_string_value (attribute_value_p^.source_logical_id, work_area, result);

    = jmc$sru_limit =
      IF attribute_value_p^.sru_limit <= jmc$highest_sru_limit THEN
        clp$make_integer_value (attribute_value_p^.sru_limit, { radix } 10, { radix_specified } FALSE,
              work_area, result);
      ELSE
        IF attribute_value_p^.sru_limit = jmc$unlimited_sru_limit THEN
          scl_name := 'UNLIMITED';
        ELSE { IF attribute_value_p^ .sru_limit = jmc$required_sru_limit THEN
          scl_name := 'REQUIRED';
        IFEND;
        clp$make_name_value (scl_name, work_area, result);
      IFEND;

    = jmc$station =
      clp$make_name_value (attribute_value_p^.station, work_area, result);

    = jmc$station_operator =
      clp$make_name_value (attribute_value_p^.station_operator, work_area, result);

    = jmc$system_file_name =
      clp$make_name_value (attribute_value_p^.system_file_name, work_area, result);

    = jmc$system_job =
      clp$make_boolean_value (attribute_value_p^.system_job, clc$yes_no_boolean, work_area, result);

    = jmc$system_job_name =
      clp$make_name_value (attribute_value_p^.system_job_name, work_area, result);

    = jmc$user_file_name =
      clp$make_name_value (attribute_value_p^.user_file_name, work_area, result);

    = jmc$user_information =
      make_trimmed_string_value (attribute_value_p^.user_information^, work_area, result);

    = jmc$user_job_name =
      IF attribute_name = 'JOB_NAME' THEN
        make_trimmed_string_value (attribute_value_p^.user_job_name, work_area, result);
      ELSE { USER_JOB_NAME
        IF attribute_value_p^.user_job_name = osc$null_name THEN
          clp$make_name_value (none, work_area, result);
        ELSE
          clp$make_name_value (attribute_value_p^.user_job_name, work_area, result);
        IFEND;
      IFEND;

    = jmc$vertical_print_density =
      clp$make_name_value (vertical_print_density [attribute_value_p^.vertical_print_density], work_area,
            result);

    = jmc$vfu_load_procedure =
      string_size := clp$trimmed_string_size (attribute_value_p^.vfu_load_procedure);
      IF string_size > 0 THEN
        scl_name := attribute_value_p^.vfu_load_procedure;
      ELSE
        scl_name := none;
      IFEND;
      clp$make_name_value (scl_name, work_area, result);

    ELSE
      ;
    CASEND;

    IF result = NIL THEN
      osp$set_status_condition (cle$work_area_overflow, status);
    IFEND;
  PROCEND assign_function_value;
?? OLDTITLE ??
?? NEWTITLE := 'translated_processing_phase', EJECT ??

  FUNCTION translated_processing_phase
    (    job_processing_phase: jmt$job_processing_phase): clt$processing_phase;

    VAR
      processing_phase: [STATIC, READ, oss$job_paged_literal] array [clt$processing_phase] of
            jmt$job_processing_phase := [jmc$jpp_job_begin_phase, jmc$jpp_system_prolog_phase,
            jmc$jpp_class_prolog_phase, jmc$jpp_account_prolog_phase, jmc$jpp_project_prolog_phase,
            jmc$jpp_member_prolog_phase, jmc$jpp_user_prolog_phase, jmc$jpp_command_phase,
            jmc$jpp_user_epilog_phase, jmc$jpp_member_epilog_phase, jmc$jpp_project_epilog_phase,
            jmc$jpp_account_epilog_phase, jmc$jpp_class_epilog_phase, jmc$jpp_system_epilog_phase,
            jmc$jpp_job_end_phase];

    VAR
      processing_phase_index: clt$processing_phase;

    FOR processing_phase_index := LOWERVALUE (processing_phase_index)
          TO UPPERVALUE (processing_phase_index) DO
      IF processing_phase [processing_phase_index] = job_processing_phase THEN
        translated_processing_phase := processing_phase_index;
        RETURN; {----->
      IFEND;
    FOREND;
  FUNCEND translated_processing_phase;
?? OLDTITLE ??
?? NEWTITLE := 'jmp$$job', EJECT ??

  PROCEDURE [XDCL] jmp$$job
    (    parameter_list: clt$parameter_list;
     VAR work_area { input, output } : ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);


{ FUNCTION (osm$$job) $job (
{   attribute: key
{       (comment_banner, cb)
{       (control_family, cf)
{       (control_user, cu)
{       (copies, c)
{       (cyclic_aging_interval, cai)
{       (detached_job_wait_time, djwt)
{       (device, d)
{       (dispatching_priority, dp)
{       (earliest_print_time, ept)
{       (earliest_run_time, ert)
{       (external_characteristics, ec)
{       (forms_code, fc)
{       (job_abort_disposition, jad)
{       (job_class, jc)
{       (job_mode, jm)
{       (job_processing_phase, jpp)
{       (job_qualifier, job_qualifiers, jq)
{       (job_recovery_disposition, jrd)
{       (job_size, js)
{       (job_submission_time, jst)
{       (latest_print_time, lpt)
{       (latest_run_time, lrt)
{       (login_account, la)
{       (login_family, lf)
{       (login_project, lp)
{       (login_user, lu)
{       (maximum_working_set, maxws)
{       (minimum_working_set, minws)
{       (operator_family, of)
{       (operator_user, ou)
{       (originating_application_name, oan)
{       (output_class, oc)
{       (output_deferred_by_user, odbu)
{       (output_destination, ode)
{       (output_destination_usage, odu)
{       (output_disposition, odi)
{       (output_priority, op)
{       (page_aging_interval, pai)
{       (purge_delay, pd)
{       (remote_host_directive, rhd)
{       (routing_banner, rb)
{       (service_class, sc)
{       (site_information, si)
{       (station, s)
{       switch1, switch2, switch3, switch4, switch5, switch6, switch7, switch8, system
{       (system_job_name, sjn)
{       (user_information, ui)
{       (user_job_name, ujn)
{       (vertical_print_density, vpd)
{       (vfu_load_procedure, vlp)
{     hidden_key
{       c170_os_type
{       (mode, m)
{       job_name, account, family_name, project, user
{       (destination_family, df)
{       (station_operator, so)
{       os_version
{       (destination_usage, du)
{       (operator, o)
{       processing_phase
{       (dual_state_route_parameters, dsrp)
{     keyend = $required
{   )

?? 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,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 128] of clt$keyword_specification,
        recend,
      recend := [[1, [88, 6, 20, 21, 56, 3, 425], clc$function, 1, 1, 1, 0, 0, 0, 0, 'OSM$$JOB'],
            [['ATTRIBUTE                      ', clc$nominal_entry, 1]], [

{ PARAMETER 1

      [1, clc$normal_usage_entry, clc$non_secure_parameter,
            $clt$parameter_spec_methods [clc$specify_positionally], clc$pass_by_value,
            clc$immediate_evaluation, clc$standard_parameter_checking, 4743, clc$required_parameter, 0, 0]],

{ PARAMETER 1

      [[1, 0, clc$keyword_type], [128], [['ACCOUNT                        ', clc$nominal_entry,
            clc$hidden_entry, 62], ['C                              ', clc$abbreviation_entry,
            clc$normal_usage_entry, 4], ['C170_OS_TYPE                   ', clc$nominal_entry,
            clc$hidden_entry, 59], ['CAI                            ', clc$abbreviation_entry,
            clc$normal_usage_entry, 5], ['CB                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 1], ['CF                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 2], ['COMMENT_BANNER                 ', clc$nominal_entry,
            clc$normal_usage_entry, 1], ['CONTROL_FAMILY                 ', clc$nominal_entry,
            clc$normal_usage_entry, 2], ['CONTROL_USER                   ', clc$nominal_entry,
            clc$normal_usage_entry, 3], ['COPIES                         ', clc$nominal_entry,
            clc$normal_usage_entry, 4], ['CU                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 3], ['CYCLIC_AGING_INTERVAL          ', clc$nominal_entry,
            clc$normal_usage_entry, 5], ['D                              ', clc$abbreviation_entry,
            clc$normal_usage_entry, 7], ['DESTINATION_FAMILY             ', clc$nominal_entry,
            clc$hidden_entry, 66], ['DESTINATION_USAGE              ', clc$nominal_entry, clc$hidden_entry,
            69], ['DETACHED_JOB_WAIT_TIME         ', clc$nominal_entry, clc$normal_usage_entry, 6],
            ['DEVICE                         ', clc$nominal_entry, clc$normal_usage_entry, 7],
            ['DF                             ', clc$abbreviation_entry, clc$hidden_entry, 66],
            ['DISPATCHING_PRIORITY           ', clc$nominal_entry, clc$normal_usage_entry, 8],
            ['DJWT                           ', clc$abbreviation_entry, clc$normal_usage_entry, 6],
            ['DP                             ', clc$abbreviation_entry, clc$normal_usage_entry, 8],
            ['DSRP                           ', clc$abbreviation_entry, clc$hidden_entry, 72],
            ['DU                             ', clc$abbreviation_entry, clc$hidden_entry, 69],
            ['DUAL_STATE_ROUTE_PARAMETERS    ', clc$nominal_entry, clc$hidden_entry, 72],
            ['EARLIEST_PRINT_TIME            ', clc$nominal_entry, clc$normal_usage_entry, 9],
            ['EARLIEST_RUN_TIME              ', clc$nominal_entry, clc$normal_usage_entry, 10],
            ['EC                             ', clc$abbreviation_entry, clc$normal_usage_entry, 11],
            ['EPT                            ', clc$abbreviation_entry, clc$normal_usage_entry, 9],
            ['ERT                            ', clc$abbreviation_entry, clc$normal_usage_entry, 10],
            ['EXTERNAL_CHARACTERISTICS       ', clc$nominal_entry, clc$normal_usage_entry, 11],
            ['FAMILY_NAME                    ', clc$nominal_entry, clc$hidden_entry, 63],
            ['FC                             ', clc$abbreviation_entry, clc$normal_usage_entry, 12],
            ['FORMS_CODE                     ', clc$nominal_entry, clc$normal_usage_entry, 12],
            ['JAD                            ', clc$abbreviation_entry, clc$normal_usage_entry, 13],
            ['JC                             ', clc$abbreviation_entry, clc$normal_usage_entry, 14],
            ['JM                             ', clc$abbreviation_entry, clc$normal_usage_entry, 15],
            ['JOB_ABORT_DISPOSITION          ', clc$nominal_entry, clc$normal_usage_entry, 13],
            ['JOB_CLASS                      ', clc$nominal_entry, clc$normal_usage_entry, 14],
            ['JOB_MODE                       ', clc$nominal_entry, clc$normal_usage_entry, 15],
            ['JOB_NAME                       ', clc$nominal_entry, clc$hidden_entry, 61],
            ['JOB_PROCESSING_PHASE           ', clc$nominal_entry, clc$normal_usage_entry, 16],
            ['JOB_QUALIFIER                  ', clc$nominal_entry, clc$normal_usage_entry, 17],
            ['JOB_QUALIFIERS                 ', clc$alias_entry, clc$normal_usage_entry, 17],
            ['JOB_RECOVERY_DISPOSITION       ', clc$nominal_entry, clc$normal_usage_entry, 18],
            ['JOB_SIZE                       ', clc$nominal_entry, clc$normal_usage_entry, 19],
            ['JOB_SUBMISSION_TIME            ', clc$nominal_entry, clc$normal_usage_entry, 20],
            ['JPP                            ', clc$abbreviation_entry, clc$normal_usage_entry, 16],
            ['JQ                             ', clc$abbreviation_entry, clc$normal_usage_entry, 17],
            ['JRD                            ', clc$abbreviation_entry, clc$normal_usage_entry, 18],
            ['JS                             ', clc$abbreviation_entry, clc$normal_usage_entry, 19],
            ['JST                            ', clc$abbreviation_entry, clc$normal_usage_entry, 20],
            ['LA                             ', clc$abbreviation_entry, clc$normal_usage_entry, 23],
            ['LATEST_PRINT_TIME              ', clc$nominal_entry, clc$normal_usage_entry, 21],
            ['LATEST_RUN_TIME                ', clc$nominal_entry, clc$normal_usage_entry, 22],
            ['LF                             ', clc$abbreviation_entry, clc$normal_usage_entry, 24],
            ['LOGIN_ACCOUNT                  ', clc$nominal_entry, clc$normal_usage_entry, 23],
            ['LOGIN_FAMILY                   ', clc$nominal_entry, clc$normal_usage_entry, 24],
            ['LOGIN_PROJECT                  ', clc$nominal_entry, clc$normal_usage_entry, 25],
            ['LOGIN_USER                     ', clc$nominal_entry, clc$normal_usage_entry, 26],
            ['LP                             ', clc$abbreviation_entry, clc$normal_usage_entry, 25],
            ['LPT                            ', clc$abbreviation_entry, clc$normal_usage_entry, 21],
            ['LRT                            ', clc$abbreviation_entry, clc$normal_usage_entry, 22],
            ['LU                             ', clc$abbreviation_entry, clc$normal_usage_entry, 26],
            ['M                              ', clc$abbreviation_entry, clc$hidden_entry, 60],
            ['MAXIMUM_WORKING_SET            ', clc$nominal_entry, clc$normal_usage_entry, 27],
            ['MAXWS                          ', clc$abbreviation_entry, clc$normal_usage_entry, 27],
            ['MINIMUM_WORKING_SET            ', clc$nominal_entry, clc$normal_usage_entry, 28],
            ['MINWS                          ', clc$abbreviation_entry, clc$normal_usage_entry, 28],
            ['MODE                           ', clc$nominal_entry, clc$hidden_entry, 60],
            ['O                              ', clc$abbreviation_entry, clc$hidden_entry, 70],
            ['OAN                            ', clc$abbreviation_entry, clc$normal_usage_entry, 31],
            ['OC                             ', clc$abbreviation_entry, clc$normal_usage_entry, 32],
            ['ODBU                           ', clc$abbreviation_entry, clc$normal_usage_entry, 33],
            ['ODE                            ', clc$abbreviation_entry, clc$normal_usage_entry, 34],
            ['ODI                            ', clc$abbreviation_entry, clc$normal_usage_entry, 36],
            ['ODU                            ', clc$abbreviation_entry, clc$normal_usage_entry, 35],
            ['OF                             ', clc$abbreviation_entry, clc$normal_usage_entry, 29],
            ['OP                             ', clc$abbreviation_entry, clc$normal_usage_entry, 37],
            ['OPERATOR                       ', clc$nominal_entry, clc$hidden_entry, 70],
            ['OPERATOR_FAMILY                ', clc$nominal_entry, clc$normal_usage_entry, 29],
            ['OPERATOR_USER                  ', clc$nominal_entry, clc$normal_usage_entry, 30],
            ['ORIGINATING_APPLICATION_NAME   ', clc$nominal_entry, clc$normal_usage_entry, 31],
            ['OS_VERSION                     ', clc$nominal_entry, clc$hidden_entry, 68],
            ['OU                             ', clc$abbreviation_entry, clc$normal_usage_entry, 30],
            ['OUTPUT_CLASS                   ', clc$nominal_entry, clc$normal_usage_entry, 32],
            ['OUTPUT_DEFERRED_BY_USER        ', clc$nominal_entry, clc$normal_usage_entry, 33],
            ['OUTPUT_DESTINATION             ', clc$nominal_entry, clc$normal_usage_entry, 34],
            ['OUTPUT_DESTINATION_USAGE       ', clc$nominal_entry, clc$normal_usage_entry, 35],
            ['OUTPUT_DISPOSITION             ', clc$nominal_entry, clc$normal_usage_entry, 36],
            ['OUTPUT_PRIORITY                ', clc$nominal_entry, clc$normal_usage_entry, 37],
            ['PAGE_AGING_INTERVAL            ', clc$nominal_entry, clc$normal_usage_entry, 38],
            ['PAI                            ', clc$abbreviation_entry, clc$normal_usage_entry, 38],
            ['PD                             ', clc$abbreviation_entry, clc$normal_usage_entry, 39],
            ['PROCESSING_PHASE               ', clc$nominal_entry, clc$hidden_entry, 71],
            ['PROJECT                        ', clc$nominal_entry, clc$hidden_entry, 64],
            ['PURGE_DELAY                    ', clc$nominal_entry, clc$normal_usage_entry, 39],
            ['RB                             ', clc$abbreviation_entry, clc$normal_usage_entry, 41],
            ['REMOTE_HOST_DIRECTIVE          ', clc$nominal_entry, clc$normal_usage_entry, 40],
            ['RHD                            ', clc$abbreviation_entry, clc$normal_usage_entry, 40],
            ['ROUTING_BANNER                 ', clc$nominal_entry, clc$normal_usage_entry, 41],
            ['S                              ', clc$abbreviation_entry, clc$normal_usage_entry, 44],
            ['SC                             ', clc$abbreviation_entry, clc$normal_usage_entry, 42],
            ['SERVICE_CLASS                  ', clc$nominal_entry, clc$normal_usage_entry, 42],
            ['SI                             ', clc$abbreviation_entry, clc$normal_usage_entry, 43],
            ['SITE_INFORMATION               ', clc$nominal_entry, clc$normal_usage_entry, 43],
            ['SJN                            ', clc$abbreviation_entry, clc$normal_usage_entry, 54],
            ['SO                             ', clc$abbreviation_entry, clc$hidden_entry, 67],
            ['STATION                        ', clc$nominal_entry, clc$normal_usage_entry, 44],
            ['STATION_OPERATOR               ', clc$nominal_entry, clc$hidden_entry, 67],
            ['SWITCH1                        ', clc$nominal_entry, clc$normal_usage_entry, 45],
            ['SWITCH2                        ', clc$nominal_entry, clc$normal_usage_entry, 46],
            ['SWITCH3                        ', clc$nominal_entry, clc$normal_usage_entry, 47],
            ['SWITCH4                        ', clc$nominal_entry, clc$normal_usage_entry, 48],
            ['SWITCH5                        ', clc$nominal_entry, clc$normal_usage_entry, 49],
            ['SWITCH6                        ', clc$nominal_entry, clc$normal_usage_entry, 50],
            ['SWITCH7                        ', clc$nominal_entry, clc$normal_usage_entry, 51],
            ['SWITCH8                        ', clc$nominal_entry, clc$normal_usage_entry, 52],
            ['SYSTEM                         ', clc$nominal_entry, clc$normal_usage_entry, 53],
            ['SYSTEM_JOB_NAME                ', clc$nominal_entry, clc$normal_usage_entry, 54],
            ['UI                             ', clc$abbreviation_entry, clc$normal_usage_entry, 55],
            ['UJN                            ', clc$abbreviation_entry, clc$normal_usage_entry, 56],
            ['USER                           ', clc$nominal_entry, clc$hidden_entry, 65],
            ['USER_INFORMATION               ', clc$nominal_entry, clc$normal_usage_entry, 55],
            ['USER_JOB_NAME                  ', clc$nominal_entry, clc$normal_usage_entry, 56],
            ['VERTICAL_PRINT_DENSITY         ', clc$nominal_entry, clc$normal_usage_entry, 57],
            ['VFU_LOAD_PROCEDURE             ', clc$nominal_entry, clc$normal_usage_entry, 58],
            ['VLP                            ', clc$abbreviation_entry, clc$normal_usage_entry, 58],
            ['VPD                            ', clc$abbreviation_entry, clc$normal_usage_entry, 57]]]];

?? POP ??

    CONST
      p$attribute = 1;

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

    VAR
      get_attribute_p: ^jmt$job_attribute_results;

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

    PUSH get_attribute_p: [1 .. 1];
    jmp$get_attribute_index (pvt [p$attribute].value^.keyword_value, get_attribute_p^ [1].key);

    CASE get_attribute_p^ [1].key OF
    = jmc$job_qualifier_list =
      PUSH get_attribute_p^ [1].job_qualifier_list: [1 .. jmc$maximum_job_qualifiers];

    = jmc$output_disposition =
      PUSH get_attribute_p^ [1].output_disposition.standard_output_path;

    = jmc$purge_delay =
      PUSH get_attribute_p^ [1].purge_delay;

    = jmc$remote_host_directive =
      PUSH get_attribute_p^ [1].remote_host_directive;

    = jmc$site_information =
      PUSH get_attribute_p^ [1].site_information;

    = jmc$user_information =
      PUSH get_attribute_p^ [1].user_information;
    ELSE
    CASEND;

    jmp$get_job_attributes (get_attribute_p, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    assign_function_value (get_attribute_p, pvt [p$attribute].value^.keyword_value, work_area, result,
          status);
  PROCEND jmp$$job;
?? OLDTITLE ??
?? NEWTITLE := 'jmp$$job_counts', EJECT ??

  PROCEDURE [XDCL] jmp$$job_counts
    (    function_name: clt$name;
         argument_list: string ( * );
     VAR value: clt$value;
     VAR status: ost$status);

    VAR
      job_counts_adt: [STATIC, READ, cls$adt] array [1 .. 2] of clt$argument_descriptor := [
            {1} [[clc$optional_with_default, ^state_default], [^valid_states, clc$keyword_value]],
            {2} [[clc$optional_with_default, ^class_default], [NIL, clc$name_value, 1, osc$max_name_size]]],
      state_default: [STATIC, READ, cls$adt_names_and_defaults] string (9) := 'INITIATED',
      valid_states: [STATIC, READ, cls$adt_names_and_defaults] array [1 .. 3] of ost$name := ['ALL', 'QUEUED',
            'INITIATED'],
      class_default: [STATIC, READ, cls$adt_names_and_defaults] string (3) := 'ALL';

    VAR
      avt: array [1 .. 2] of clt$value,
      selected_states: jmt$job_state_set,
      selected_classes: jmt$job_class_set,
      job_class: jmt$job_class,
      job_state: jmt$job_state,
      job_counts: jmt$job_counts,
      total_jobs: integer;

    clp$scan_argument_list (function_name, argument_list, ^job_counts_adt, ^avt, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF avt [1].name.value = 'ALL' THEN
      selected_states := -$jmt$job_state_set [];
    ELSEIF avt [1].name.value = 'INITIATED' THEN
      selected_states := $jmt$job_state_set [jmc$initiated_job];
    ELSE
      selected_states := $jmt$job_state_set [jmc$queued_job];
    IFEND;

    IF avt [2].name.value = 'ALL' THEN
      selected_classes := -$jmt$job_class_set [];
    ELSE
      jmp$determine_job_class (avt [2].name.value, job_class, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;
      selected_classes := $jmt$job_class_set [job_class];
    IFEND;

    jmp$get_job_counts (job_counts, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    total_jobs := 0;
    FOR job_state := LOWERVALUE (jmt$job_state) TO UPPERVALUE (jmt$job_state) DO
      IF job_state IN selected_states THEN

        FOR job_class := LOWERVALUE (jmt$job_class) TO UPPERVALUE (jmt$job_class) DO
          IF job_class IN selected_classes THEN

            CASE job_state OF
            = jmc$queued_job =
              total_jobs := total_jobs + job_counts.job_class_counts [job_class].queued_jobs;

            = jmc$initiated_job =
              total_jobs := total_jobs + job_counts.job_class_counts [job_class].initiated_jobs;

            ELSE
            CASEND;
          IFEND;
        FOREND;
      IFEND;
    FOREND;

    value.descriptor := clv$value_descriptors [clc$integer_value];
    value.kind := clc$integer_value;
    value.int.radix := 10;
    value.int.radix_specified := FALSE;
    value.int.value := total_jobs;

  PROCEND jmp$$job_counts;
?? OLDTITLE ??
?? NEWTITLE := 'jmp$$job_default', EJECT ??

  PROCEDURE [XDCL] jmp$$job_default
    (    parameter_list: clt$parameter_list;
     VAR work_area: ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);

{ FUNCTION (osm$$job_default) $job_default (
{   attribute: key
{       (cpu_time_limit, ctl)
{       (job_abort_disposition, jad)
{       (job_class, jc)
{       (job_deferred_by_operator, jdbo)
{       (job_destination_usage, jdu)
{       (job_qualifier, job_qualifiers, jq)
{       (job_recovery_disposition, jrd)
{       (login_family, lf)
{       (magnetic_tape_limit, mtl)
{       (maximum_working_set, maxws)
{       (output_class, oc)
{       (output_deferred_by_operator, odbo)
{       (output_destination_usage, odu)
{       (purge_delay, pd)
{       (queue_file_deferred_by_operator, qfdbo)
{       (site_information, si)
{       (sru_limit, sl)
{       (station, s)
{       (vertical_print_density, vpd)
{     keyend = $required
{   job_mode: key
{       (batch, b)
{       (interactive, i)
{     keyend = $optional
{   )

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

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 2] of clt$pdt_parameter_name,
      parameters: array [1 .. 2] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 39] of clt$keyword_specification,
      recend,
      type2: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 4] of clt$keyword_specification,
      recend,
    recend := [
    [1,
    [102, 12, 19, 13, 24, 40, 808],
    clc$function, 2, 2, 1, 0, 0, 0, 0, 'OSM$$JOB_DEFAULT'], [
    ['ATTRIBUTE                      ',clc$nominal_entry, 1],
    ['JOB_MODE                       ',clc$nominal_entry, 2]],
    [
{ PARAMETER 1
    [1, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 1450,
  clc$required_parameter, 0, 0],
{ PARAMETER 2
    [2, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 155,
  clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$keyword_type], [39], [
    ['CPU_TIME_LIMIT                 ', clc$nominal_entry, clc$normal_usage_entry, 1],
    ['CTL                            ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
    ['JAD                            ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
    ['JC                             ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
    ['JDBO                           ', clc$abbreviation_entry, clc$normal_usage_entry, 4],
    ['JDU                            ', clc$abbreviation_entry, clc$normal_usage_entry, 5],
    ['JOB_ABORT_DISPOSITION          ', clc$nominal_entry, clc$normal_usage_entry, 2],
    ['JOB_CLASS                      ', clc$nominal_entry, clc$normal_usage_entry, 3],
    ['JOB_DEFERRED_BY_OPERATOR       ', clc$nominal_entry, clc$normal_usage_entry, 4],
    ['JOB_DESTINATION_USAGE          ', clc$nominal_entry, clc$normal_usage_entry, 5],
    ['JOB_QUALIFIER                  ', clc$nominal_entry, clc$normal_usage_entry, 6],
    ['JOB_QUALIFIERS                 ', clc$alias_entry, clc$normal_usage_entry, 6],
    ['JOB_RECOVERY_DISPOSITION       ', clc$nominal_entry, clc$normal_usage_entry, 7],
    ['JQ                             ', clc$abbreviation_entry, clc$normal_usage_entry, 6],
    ['JRD                            ', clc$abbreviation_entry, clc$normal_usage_entry, 7],
    ['LF                             ', clc$abbreviation_entry, clc$normal_usage_entry, 8],
    ['LOGIN_FAMILY                   ', clc$nominal_entry, clc$normal_usage_entry, 8],
    ['MAGNETIC_TAPE_LIMIT            ', clc$nominal_entry, clc$normal_usage_entry, 9],
    ['MAXIMUM_WORKING_SET            ', clc$nominal_entry, clc$normal_usage_entry, 10],
    ['MAXWS                          ', clc$abbreviation_entry, clc$normal_usage_entry, 10],
    ['MTL                            ', clc$abbreviation_entry, clc$normal_usage_entry, 9],
    ['OC                             ', clc$abbreviation_entry, clc$normal_usage_entry, 11],
    ['ODBO                           ', clc$abbreviation_entry, clc$normal_usage_entry, 12],
    ['ODU                            ', clc$abbreviation_entry, clc$normal_usage_entry, 13],
    ['OUTPUT_CLASS                   ', clc$nominal_entry, clc$normal_usage_entry, 11],
    ['OUTPUT_DEFERRED_BY_OPERATOR    ', clc$nominal_entry, clc$normal_usage_entry, 12],
    ['OUTPUT_DESTINATION_USAGE       ', clc$nominal_entry, clc$normal_usage_entry, 13],
    ['PD                             ', clc$abbreviation_entry, clc$normal_usage_entry, 14],
    ['PURGE_DELAY                    ', clc$nominal_entry, clc$normal_usage_entry, 14],
    ['QFDBO                          ', clc$abbreviation_entry, clc$normal_usage_entry, 15],
    ['QUEUE_FILE_DEFERRED_BY_OPERATOR', clc$nominal_entry, clc$normal_usage_entry, 15],
    ['S                              ', clc$abbreviation_entry, clc$normal_usage_entry, 18],
    ['SI                             ', clc$abbreviation_entry, clc$normal_usage_entry, 16],
    ['SITE_INFORMATION               ', clc$nominal_entry, clc$normal_usage_entry, 16],
    ['SL                             ', clc$abbreviation_entry, clc$normal_usage_entry, 17],
    ['SRU_LIMIT                      ', clc$nominal_entry, clc$normal_usage_entry, 17],
    ['STATION                        ', clc$nominal_entry, clc$normal_usage_entry, 18],
    ['VERTICAL_PRINT_DENSITY         ', clc$nominal_entry, clc$normal_usage_entry, 19],
    ['VPD                            ', clc$abbreviation_entry, clc$normal_usage_entry, 19]]
    ],
{ PARAMETER 2
    [[1, 0, clc$keyword_type], [4], [
    ['B                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
    ['BATCH                          ', clc$nominal_entry, clc$normal_usage_entry, 1],
    ['I                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
    ['INTERACTIVE                    ', clc$nominal_entry, clc$normal_usage_entry, 2]]
    ]];

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

    CONST
      p$attribute = 1,
      p$job_mode = 2;

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

    VAR
      default_attribute_p: ^jmt$default_attribute_results,
      job_mode: jmt$job_mode;


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

    PUSH default_attribute_p: [1 .. 1];
    jmp$get_attribute_index (pvt [p$attribute].value^.keyword_value, default_attribute_p^ [1].key);

    CASE default_attribute_p^ [1].key OF
    = jmc$job_qualifier_list =
      PUSH default_attribute_p^ [1].job_qualifier_list: [1 .. jmc$maximum_job_qualifiers];

    = jmc$purge_delay =
      PUSH default_attribute_p^ [1].purge_delay;

    = jmc$site_information =
      PUSH default_attribute_p^ [1].site_information;

    ELSE
    CASEND;

    IF pvt [p$job_mode].specified THEN
      IF pvt [p$job_mode].value^.keyword_value = 'BATCH' THEN
        job_mode := jmc$batch;
      ELSE
        job_mode := jmc$interactive_connected;
      IFEND;
    ELSE
      pmp$get_job_mode (job_mode, { ignore} status);
    IFEND;
    jmp$get_attribute_defaults (job_mode, default_attribute_p, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    assign_function_value (default_attribute_p, pvt [p$attribute].value^.keyword_value, work_area, result,
          status);
  PROCEND jmp$$job_default;
?? OLDTITLE ??
?? NEWTITLE := 'jmp$$job_status', EJECT ??

  PROCEDURE [XDCL] jmp$$job_status
    (    parameter_list: clt$parameter_list;
     VAR work_area { input, output } : ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);

{ FUNCTION (osm$$job_status) $job_status (
{   name: name = $required
{   attribute: key
{       (control_family, cf)
{       (control_user, cu)
{       (display_message, dm)
{       (job_class, jc)
{       (job_class_position, jcp)
{       (job_destination_usage, jdu)
{       (job_initiation_time, jit)
{       (job_mode, jm)
{       (job_mode_cpu_time, jmct)
{       (job_state, js)
{       (login_family, lf)
{       (login_user, lu)
{       (monitor_mode_cpu_time, mmct)
{       (operator_action_posted, oap)
{       (pages_assigned, pa)
{       (pages_from_disk, pfd)
{       (pages_reclaimed, pr)
{       (system_job_name, sjn)
{       (user_job_name, ujn)
{     hidden_key
{       (client_mainframe_identifier, cmi)
{       (input_file_location, ifl)
{       (server_mainframe_identifier, smi)
{       (state, s)
{     keyend = $required
{   )

?? PUSH (LISTEXT := ON) ??

    VAR
      pdt: [STATIC, READ, cls$declaration_section] record
        header: clt$pdt_header,
        names: array [1 .. 2] of clt$pdt_parameter_name,
        parameters: array [1 .. 2] 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 .. 46] of clt$keyword_specification,
        recend,
      recend := [[1, [88, 5, 5, 11, 9, 8, 976], clc$function, 2, 2, 2, 0, 0, 0, 0, 'OSM$$JOB_STATUS'],
            [['ATTRIBUTE                      ', clc$nominal_entry, 2],
            ['NAME                           ', clc$nominal_entry, 1]], [

{ PARAMETER 1

      [2, clc$normal_usage_entry, clc$non_secure_parameter,
            $clt$parameter_spec_methods [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_positionally], clc$pass_by_value,
            clc$immediate_evaluation, clc$standard_parameter_checking, 1709, clc$required_parameter, 0, 0]],

{ PARAMETER 1

      [[1, 0, clc$name_type], [1, osc$max_name_size]],

{ PARAMETER 2

      [[1, 0, clc$keyword_type], [46], [['CF                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 1], ['CLIENT_MAINFRAME_IDENTIFIER    ', clc$nominal_entry,
            clc$hidden_entry, 20], ['CMI                            ', clc$abbreviation_entry,
            clc$hidden_entry, 20], ['CONTROL_FAMILY                 ', clc$nominal_entry,
            clc$normal_usage_entry, 1], ['CONTROL_USER                   ', clc$nominal_entry,
            clc$normal_usage_entry, 2], ['CU                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 2], ['DISPLAY_MESSAGE                ', clc$nominal_entry,
            clc$normal_usage_entry, 3], ['DM                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 3], ['IFL                            ', clc$abbreviation_entry,
            clc$hidden_entry, 21], ['INPUT_FILE_LOCATION            ', clc$nominal_entry, clc$hidden_entry,
            21], ['JC                             ', clc$abbreviation_entry, clc$normal_usage_entry, 4],
            ['JCP                            ', clc$abbreviation_entry, clc$normal_usage_entry, 5],
            ['JDU                            ', clc$abbreviation_entry, clc$normal_usage_entry, 6],
            ['JIT                            ', clc$abbreviation_entry, clc$normal_usage_entry, 7],
            ['JM                             ', clc$abbreviation_entry, clc$normal_usage_entry, 8],
            ['JMCT                           ', clc$abbreviation_entry, clc$normal_usage_entry, 9],
            ['JOB_CLASS                      ', clc$nominal_entry, clc$normal_usage_entry, 4],
            ['JOB_CLASS_POSITION             ', clc$nominal_entry, clc$normal_usage_entry, 5],
            ['JOB_DESTINATION_USAGE          ', clc$nominal_entry, clc$normal_usage_entry, 6],
            ['JOB_INITIATION_TIME            ', clc$nominal_entry, clc$normal_usage_entry, 7],
            ['JOB_MODE                       ', clc$nominal_entry, clc$normal_usage_entry, 8],
            ['JOB_MODE_CPU_TIME              ', clc$nominal_entry, clc$normal_usage_entry, 9],
            ['JOB_STATE                      ', clc$nominal_entry, clc$normal_usage_entry, 10],
            ['JS                             ', clc$abbreviation_entry, clc$normal_usage_entry, 10],
            ['LF                             ', clc$abbreviation_entry, clc$normal_usage_entry, 11],
            ['LOGIN_FAMILY                   ', clc$nominal_entry, clc$normal_usage_entry, 11],
            ['LOGIN_USER                     ', clc$nominal_entry, clc$normal_usage_entry, 12],
            ['LU                             ', clc$abbreviation_entry, clc$normal_usage_entry, 12],
            ['MMCT                           ', clc$abbreviation_entry, clc$normal_usage_entry, 13],
            ['MONITOR_MODE_CPU_TIME          ', clc$nominal_entry, clc$normal_usage_entry, 13],
            ['OAP                            ', clc$abbreviation_entry, clc$normal_usage_entry, 14],
            ['OPERATOR_ACTION_POSTED         ', clc$nominal_entry, clc$normal_usage_entry, 14],
            ['PA                             ', clc$abbreviation_entry, clc$normal_usage_entry, 15],
            ['PAGES_ASSIGNED                 ', clc$nominal_entry, clc$normal_usage_entry, 15],
            ['PAGES_FROM_DISK                ', clc$nominal_entry, clc$normal_usage_entry, 16],
            ['PAGES_RECLAIMED                ', clc$nominal_entry, clc$normal_usage_entry, 17],
            ['PFD                            ', clc$abbreviation_entry, clc$normal_usage_entry, 16],
            ['PR                             ', clc$abbreviation_entry, clc$normal_usage_entry, 17],
            ['S                              ', clc$abbreviation_entry, clc$hidden_entry, 23],
            ['SERVER_MAINFRAME_IDENTIFIER    ', clc$nominal_entry, clc$hidden_entry, 22],
            ['SJN                            ', clc$abbreviation_entry, clc$normal_usage_entry, 18],
            ['SMI                            ', clc$abbreviation_entry, clc$hidden_entry, 22],
            ['STATE                          ', clc$nominal_entry, clc$hidden_entry, 23],
            ['SYSTEM_JOB_NAME                ', clc$nominal_entry, clc$normal_usage_entry, 18],
            ['UJN                            ', clc$abbreviation_entry, clc$normal_usage_entry, 19],
            ['USER_JOB_NAME                  ', clc$nominal_entry, clc$normal_usage_entry, 19]]]];

?? POP ??

    CONST
      p$name = 1,
      p$attribute = 2;

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

    VAR
      job_name: jmt$name,
      job_status_options_p: ^jmt$job_status_options,
      job_status_results_keys_p: ^jmt$results_keys,
      job_status_results_p: ^jmt$job_status_results,
      job_status_results_seq_p: ^jmt$work_area,
      number_of_jobs_found: jmt$job_status_count,
      size_of_sequence: ost$segment_length;

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

    jmp$determine_name_kind (pvt [p$name].value^.name_value, job_name, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    PUSH job_status_options_p: [1 .. 2];
    job_status_options_p^ [1].key := jmc$name_list;
    PUSH job_status_options_p^ [1].name_list: [1 .. 1];
    job_status_options_p^ [1].name_list^ [1] := job_name;
    job_status_options_p^ [2].key := jmc$continue_request_to_servers;
    job_status_options_p^ [2].continue_request_to_servers := TRUE;
    PUSH job_status_results_keys_p: [1 .. 1];
    IF pvt [p$attribute].value^.keyword_value = 'STATE' THEN
      job_status_results_keys_p^ [1] := jmc$job_state;
    ELSE
      jmp$get_attribute_index (pvt [p$attribute].value^.keyword_value, job_status_results_keys_p^ [1]);
    IFEND;

    jmp$get_result_size ({number_of_jobs} 1, #SEQ (job_status_results_keys_p^), size_of_sequence);
    PUSH job_status_results_seq_p: [[REP size_of_sequence OF cell]];

    jmp$get_job_status (job_status_options_p, job_status_results_keys_p, job_status_results_seq_p,
          job_status_results_p, number_of_jobs_found, status);
    IF NOT status.normal THEN
      IF status.condition = jme$no_jobs_were_found THEN
        IF (job_status_results_keys_p^ [1] <> jmc$job_state) THEN
          osp$set_status_abnormal ('JM', jme$name_not_found, pvt [p$name].value^.name_value, status);
        ELSE
          clp$make_name_value ('UNKNOWN', work_area, result);
          IF result = NIL THEN
            osp$set_status_condition (cle$work_area_overflow, status);
          ELSE
            status.normal := TRUE;
          IFEND;
        IFEND;
      ELSE
        IF status.condition = jme$work_area_too_small THEN
          osp$set_status_abnormal ('JM', jme$duplicate_name, pvt [p$name].value^.name_value, status);
        IFEND;
      IFEND;
    ELSE
      assign_function_value (job_status_results_p^ [1], pvt [p$attribute].value^.keyword_value, work_area,
            result, status);
    IFEND;
  PROCEND jmp$$job_status;
?? OLDTITLE ??
?? NEWTITLE := 'jmp$$input', EJECT ??

  PROCEDURE [XDCL] jmp$$input
    (    parameter_list: clt$parameter_list;
     VAR work_area { input, input } : ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);

{ FUNCTION (osm$$job_input) $job_input (
{   name: name = $required
{   attribute: key
{       (comment_banner, cb)
{       (control_family, cf)
{       (control_user, cu)
{       (copies, c)
{       (cpu_time_limit, ctl)
{       (data_mode, dm)
{       (device, d)
{       (display_message, message, m)
{       (earliest_print_time, ept)
{       (earliest_run_time, ert)
{       (external_characteristics, ec)
{       (forms_code, fc)
{       (job_abort_disposition, jad)
{       (job_class, jc)
{       (job_deferred_by_operator, jdbo)
{       (job_deferred_by_user, jdbu)
{       (job_destination, jd)
{       (job_destination_usage, jdu)
{       (job_execution_ring, jer)
{       (job_mode, jm)
{       (job_qualifier, job_qualifiers, jq)
{       (job_recovery_disposition, jrd)
{       (job_size, js)
{       (job_submission_time, jst)
{       (latest_print_time, lpt)
{       (latest_run_time, lrt)
{       (login_account, la)
{       (login_family, lf)
{       (login_project, lp)
{       (login_user, lu)
{       (magnetic_tape_limit, mtl)
{       (maximum_working_set, maxws)
{       (operator_family, of)
{       (operator_user, ou)
{       (originating_application_name, oan)
{       (output_class, oc)
{       (output_deferred_by_user, odbu)
{       (output_destination, ode)
{       (output_destination_usage, odu)
{       (output_disposition, odi)
{       (output_priority, op)
{       (purge_delay, pd)
{       (remote_host_directive, rhd)
{       (routing_banner, rb)
{       (site_information, si)
{       (sru_limit, sl)
{       (station, s)
{       (system_job_name, sjn)
{       (user_information, ui)
{       (user_job_name, ujn)
{       (vertical_print_density, vpd)
{       (vfu_load_procedure, vlp)
{     keyend = $required
{   )

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

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 2] of clt$pdt_parameter_name,
      parameters: array [1 .. 2] 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 .. 106] of clt$keyword_specification,
      recend,
    recend := [
    [1,
    [104, 9, 27, 14, 48, 48, 486],
    clc$function, 2, 2, 2, 0, 0, 0, 0, 'OSM$$JOB_INPUT'], [
    ['ATTRIBUTE                      ',clc$nominal_entry, 2],
    ['NAME                           ',clc$nominal_entry, 1]],
    [
{ PARAMETER 1
    [2, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[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_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3929,
  clc$required_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$name_type], [1, osc$max_name_size]],
{ PARAMETER 2
    [[1, 0, clc$keyword_type], [106], [
    ['C                              ', clc$abbreviation_entry, clc$normal_usage_entry, 4],
    ['CB                             ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
    ['CF                             ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
    ['COMMENT_BANNER                 ', clc$nominal_entry, clc$normal_usage_entry, 1],
    ['CONTROL_FAMILY                 ', clc$nominal_entry, clc$normal_usage_entry, 2],
    ['CONTROL_USER                   ', clc$nominal_entry, clc$normal_usage_entry, 3],
    ['COPIES                         ', clc$nominal_entry, clc$normal_usage_entry, 4],
    ['CPU_TIME_LIMIT                 ', clc$nominal_entry, clc$normal_usage_entry, 5],
    ['CTL                            ', clc$abbreviation_entry, clc$normal_usage_entry, 5],
    ['CU                             ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
    ['D                              ', clc$abbreviation_entry, clc$normal_usage_entry, 7],
    ['DATA_MODE                      ', clc$nominal_entry, clc$normal_usage_entry, 6],
    ['DEVICE                         ', clc$nominal_entry, clc$normal_usage_entry, 7],
    ['DISPLAY_MESSAGE                ', clc$nominal_entry, clc$normal_usage_entry, 8],
    ['DM                             ', clc$abbreviation_entry, clc$normal_usage_entry, 6],
    ['EARLIEST_PRINT_TIME            ', clc$nominal_entry, clc$normal_usage_entry, 9],
    ['EARLIEST_RUN_TIME              ', clc$nominal_entry, clc$normal_usage_entry, 10],
    ['EC                             ', clc$abbreviation_entry, clc$normal_usage_entry, 11],
    ['EPT                            ', clc$abbreviation_entry, clc$normal_usage_entry, 9],
    ['ERT                            ', clc$abbreviation_entry, clc$normal_usage_entry, 10],
    ['EXTERNAL_CHARACTERISTICS       ', clc$nominal_entry, clc$normal_usage_entry, 11],
    ['FC                             ', clc$abbreviation_entry, clc$normal_usage_entry, 12],
    ['FORMS_CODE                     ', clc$nominal_entry, clc$normal_usage_entry, 12],
    ['JAD                            ', clc$abbreviation_entry, clc$normal_usage_entry, 13],
    ['JC                             ', clc$abbreviation_entry, clc$normal_usage_entry, 14],
    ['JD                             ', clc$abbreviation_entry, clc$normal_usage_entry, 17],
    ['JDBO                           ', clc$abbreviation_entry, clc$normal_usage_entry, 15],
    ['JDBU                           ', clc$abbreviation_entry, clc$normal_usage_entry, 16],
    ['JDU                            ', clc$abbreviation_entry, clc$normal_usage_entry, 18],
    ['JER                            ', clc$abbreviation_entry, clc$normal_usage_entry, 19],
    ['JM                             ', clc$abbreviation_entry, clc$normal_usage_entry, 20],
    ['JOB_ABORT_DISPOSITION          ', clc$nominal_entry, clc$normal_usage_entry, 13],
    ['JOB_CLASS                      ', clc$nominal_entry, clc$normal_usage_entry, 14],
    ['JOB_DEFERRED_BY_OPERATOR       ', clc$nominal_entry, clc$normal_usage_entry, 15],
    ['JOB_DEFERRED_BY_USER           ', clc$nominal_entry, clc$normal_usage_entry, 16],
    ['JOB_DESTINATION                ', clc$nominal_entry, clc$normal_usage_entry, 17],
    ['JOB_DESTINATION_USAGE          ', clc$nominal_entry, clc$normal_usage_entry, 18],
    ['JOB_EXECUTION_RING             ', clc$nominal_entry, clc$normal_usage_entry, 19],
    ['JOB_MODE                       ', clc$nominal_entry, clc$normal_usage_entry, 20],
    ['JOB_QUALIFIER                  ', clc$nominal_entry, clc$normal_usage_entry, 21],
    ['JOB_QUALIFIERS                 ', clc$alias_entry, clc$normal_usage_entry, 21],
    ['JOB_RECOVERY_DISPOSITION       ', clc$nominal_entry, clc$normal_usage_entry, 22],
    ['JOB_SIZE                       ', clc$nominal_entry, clc$normal_usage_entry, 23],
    ['JOB_SUBMISSION_TIME            ', clc$nominal_entry, clc$normal_usage_entry, 24],
    ['JQ                             ', clc$abbreviation_entry, clc$normal_usage_entry, 21],
    ['JRD                            ', clc$abbreviation_entry, clc$normal_usage_entry, 22],
    ['JS                             ', clc$abbreviation_entry, clc$normal_usage_entry, 23],
    ['JST                            ', clc$abbreviation_entry, clc$normal_usage_entry, 24],
    ['LA                             ', clc$abbreviation_entry, clc$normal_usage_entry, 27],
    ['LATEST_PRINT_TIME              ', clc$nominal_entry, clc$normal_usage_entry, 25],
    ['LATEST_RUN_TIME                ', clc$nominal_entry, clc$normal_usage_entry, 26],
    ['LF                             ', clc$abbreviation_entry, clc$normal_usage_entry, 28],
    ['LOGIN_ACCOUNT                  ', clc$nominal_entry, clc$normal_usage_entry, 27],
    ['LOGIN_FAMILY                   ', clc$nominal_entry, clc$normal_usage_entry, 28],
    ['LOGIN_PROJECT                  ', clc$nominal_entry, clc$normal_usage_entry, 29],
    ['LOGIN_USER                     ', clc$nominal_entry, clc$normal_usage_entry, 30],
    ['LP                             ', clc$abbreviation_entry, clc$normal_usage_entry, 29],
    ['LPT                            ', clc$abbreviation_entry, clc$normal_usage_entry, 25],
    ['LRT                            ', clc$abbreviation_entry, clc$normal_usage_entry, 26],
    ['LU                             ', clc$abbreviation_entry, clc$normal_usage_entry, 30],
    ['M                              ', clc$abbreviation_entry, clc$normal_usage_entry, 8],
    ['MAGNETIC_TAPE_LIMIT            ', clc$nominal_entry, clc$normal_usage_entry, 31],
    ['MAXIMUM_WORKING_SET            ', clc$nominal_entry, clc$normal_usage_entry, 32],
    ['MAXWS                          ', clc$abbreviation_entry, clc$normal_usage_entry, 32],
    ['MESSAGE                        ', clc$alias_entry, clc$normal_usage_entry, 8],
    ['MTL                            ', clc$abbreviation_entry, clc$normal_usage_entry, 31],
    ['OAN                            ', clc$abbreviation_entry, clc$normal_usage_entry, 35],
    ['OC                             ', clc$abbreviation_entry, clc$normal_usage_entry, 36],
    ['ODBU                           ', clc$abbreviation_entry, clc$normal_usage_entry, 37],
    ['ODE                            ', clc$abbreviation_entry, clc$normal_usage_entry, 38],
    ['ODI                            ', clc$abbreviation_entry, clc$normal_usage_entry, 40],
    ['ODU                            ', clc$abbreviation_entry, clc$normal_usage_entry, 39],
    ['OF                             ', clc$abbreviation_entry, clc$normal_usage_entry, 33],
    ['OP                             ', clc$abbreviation_entry, clc$normal_usage_entry, 41],
    ['OPERATOR_FAMILY                ', clc$nominal_entry, clc$normal_usage_entry, 33],
    ['OPERATOR_USER                  ', clc$nominal_entry, clc$normal_usage_entry, 34],
    ['ORIGINATING_APPLICATION_NAME   ', clc$nominal_entry, clc$normal_usage_entry, 35],
    ['OU                             ', clc$abbreviation_entry, clc$normal_usage_entry, 34],
    ['OUTPUT_CLASS                   ', clc$nominal_entry, clc$normal_usage_entry, 36],
    ['OUTPUT_DEFERRED_BY_USER        ', clc$nominal_entry, clc$normal_usage_entry, 37],
    ['OUTPUT_DESTINATION             ', clc$nominal_entry, clc$normal_usage_entry, 38],
    ['OUTPUT_DESTINATION_USAGE       ', clc$nominal_entry, clc$normal_usage_entry, 39],
    ['OUTPUT_DISPOSITION             ', clc$nominal_entry, clc$normal_usage_entry, 40],
    ['OUTPUT_PRIORITY                ', clc$nominal_entry, clc$normal_usage_entry, 41],
    ['PD                             ', clc$abbreviation_entry, clc$normal_usage_entry, 42],
    ['PURGE_DELAY                    ', clc$nominal_entry, clc$normal_usage_entry, 42],
    ['RB                             ', clc$abbreviation_entry, clc$normal_usage_entry, 44],
    ['REMOTE_HOST_DIRECTIVE          ', clc$nominal_entry, clc$normal_usage_entry, 43],
    ['RHD                            ', clc$abbreviation_entry, clc$normal_usage_entry, 43],
    ['ROUTING_BANNER                 ', clc$nominal_entry, clc$normal_usage_entry, 44],
    ['S                              ', clc$abbreviation_entry, clc$normal_usage_entry, 47],
    ['SI                             ', clc$abbreviation_entry, clc$normal_usage_entry, 45],
    ['SITE_INFORMATION               ', clc$nominal_entry, clc$normal_usage_entry, 45],
    ['SJN                            ', clc$abbreviation_entry, clc$normal_usage_entry, 48],
    ['SL                             ', clc$abbreviation_entry, clc$normal_usage_entry, 46],
    ['SRU_LIMIT                      ', clc$nominal_entry, clc$normal_usage_entry, 46],
    ['STATION                        ', clc$nominal_entry, clc$normal_usage_entry, 47],
    ['SYSTEM_JOB_NAME                ', clc$nominal_entry, clc$normal_usage_entry, 48],
    ['UI                             ', clc$abbreviation_entry, clc$normal_usage_entry, 49],
    ['UJN                            ', clc$abbreviation_entry, clc$normal_usage_entry, 50],
    ['USER_INFORMATION               ', clc$nominal_entry, clc$normal_usage_entry, 49],
    ['USER_JOB_NAME                  ', clc$nominal_entry, clc$normal_usage_entry, 50],
    ['VERTICAL_PRINT_DENSITY         ', clc$nominal_entry, clc$normal_usage_entry, 51],
    ['VFU_LOAD_PROCEDURE             ', clc$nominal_entry, clc$normal_usage_entry, 52],
    ['VLP                            ', clc$abbreviation_entry, clc$normal_usage_entry, 52],
    ['VPD                            ', clc$abbreviation_entry, clc$normal_usage_entry, 51]]
    ]];

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

    CONST
      p$name = 1,
      p$attribute = 2;

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

    VAR
      number_of_inputs_found: jmt$job_status_count,
      input_name: jmt$name,
      input_options_p: ^jmt$input_attribute_options,
      input_results_keys_p: ^jmt$results_keys,
      input_results_p: ^jmt$input_attribute_results,
      result_size: ost$segment_length,
      work_area_p: ^jmt$work_area;

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

    jmp$determine_name_kind (pvt [p$name].value^.name_value, input_name, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    PUSH input_options_p: [1 .. 2];
    input_options_p^ [1].key := jmc$name_list;
    PUSH input_options_p^ [1].name_list: [1 .. 1];
    input_options_p^ [1].name_list^ [1] := input_name;
    input_options_p^ [2].key := jmc$continue_request_to_servers;
    input_options_p^ [2].continue_request_to_servers := TRUE;

    PUSH input_results_keys_p: [1 .. 1];
    jmp$get_attribute_index (pvt [p$attribute].value^.keyword_value, input_results_keys_p^ [1]);
    jmp$get_result_size ({number_of_items} 1, #SEQ (input_results_keys_p^), result_size);
    PUSH work_area_p: [[REP result_size OF cell]];
    RESET work_area_p;

    jmp$get_input_attributes (input_options_p, input_results_keys_p, work_area_p, input_results_p,
          number_of_inputs_found, status);
    IF NOT status.normal THEN
      IF status.condition = jme$no_jobs_were_found THEN
        IF (input_results_keys_p^ [1] <> jmc$job_state) THEN
          osp$set_status_abnormal ('JM', jme$name_not_found, pvt [p$name].value^.name_value, status);
        ELSE
          clp$make_name_value ('UNKNOWN', work_area, result);
          IF result = NIL THEN
            osp$set_status_condition (cle$work_area_overflow, status);
          ELSE
            status.normal := TRUE;
          IFEND;
        IFEND;
      ELSE
        IF status.condition = jme$work_area_too_small THEN
          osp$set_status_abnormal ('JM', jme$duplicate_name, pvt [p$name].value^.name_value, status);
        IFEND;
      IFEND;
    ELSE
      assign_function_value (input_results_p^ [1], pvt [p$attribute].value^.keyword_value, work_area, result,
            status);
    IFEND;
  PROCEND jmp$$input;
?? OLDTITLE ??
?? NEWTITLE := 'jmp$$output', EJECT ??

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

{ FUNCTION (osm$$job_output) $job_output (
{   name: name = $required
{   attribute: key
{       (comment_banner, cb)
{       (control_family, cf)
{       (control_user, cu)
{       (copies, c)
{       (copies_printed, cp)
{       (data_mode, dm)
{       (device, d)
{       (device_type, dt)
{       (earliest_print_time, ept)
{       (external_characteristics, ec)
{       (file_position, fp)
{       (file_size, fs)
{       (forms_code, fc)
{       (latest_print_time, lpt)
{       (login_account, la)
{       (login_family, lf)
{       (login_project, lp)
{       (login_user, lu)
{       (operator_family, of)
{       (operator_user, ou)
{       (originating_application_name, oan)
{       (output_class, oc)
{       (output_deferred_by_operator, odbo)
{       (output_deferred_by_user, odbu)
{       (output_destination, ode)
{       (output_destination_usage, odu)
{       (output_priority, op)
{       (output_submission_time, ost)
{       (purge_delay, pd)
{       (remote_host_directive, rhd)
{       (routing_banner, rb)
{       (site_information, si)
{       (station, s)
{       (system_file_name, sfn)
{       (system_job_name, sjn)
{       (user_file_name, ufn)
{       (user_information, ui)
{       (user_job_name, ujn)
{       (vertical_print_density, vpd)
{       (vfu_load_procedure, vlp)
{     hidden_key
{       (destination_family, df)
{       (station_operator, so)
{       (destination_usage, du)
{       (dual_state_route_parameters, dsrp)
{     keyend = $required
{   )

?? PUSH (LISTEXT := ON) ??

    VAR
      pdt: [STATIC, READ, cls$declaration_section] record
        header: clt$pdt_header,
        names: array [1 .. 2] of clt$pdt_parameter_name,
        parameters: array [1 .. 2] 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 .. 88] of clt$keyword_specification,
        recend,
      recend := [[1, [88, 2, 18, 14, 59, 18, 957], clc$function, 2, 2, 2, 0, 0, 0, 0, 'OSM$$JOB_OUTPUT'],
            [['ATTRIBUTE                      ', clc$nominal_entry, 2],
            ['NAME                           ', clc$nominal_entry, 1]], [

{ PARAMETER 1

      [2, clc$normal_usage_entry, clc$non_secure_parameter,
            $clt$parameter_spec_methods [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_positionally], clc$pass_by_value,
            clc$immediate_evaluation, clc$standard_parameter_checking, 3263, clc$required_parameter, 0, 0]],

{ PARAMETER 1

      [[1, 0, clc$name_type], [1, osc$max_name_size]],

{ PARAMETER 2

      [[1, 0, clc$keyword_type], [88], [['C                              ', clc$abbreviation_entry,
            clc$normal_usage_entry, 4], ['CB                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 1], ['CF                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 2], ['COMMENT_BANNER                 ', clc$nominal_entry,
            clc$normal_usage_entry, 1], ['CONTROL_FAMILY                 ', clc$nominal_entry,
            clc$normal_usage_entry, 2], ['CONTROL_USER                   ', clc$nominal_entry,
            clc$normal_usage_entry, 3], ['COPIES                         ', clc$nominal_entry,
            clc$normal_usage_entry, 4], ['COPIES_PRINTED                 ', clc$nominal_entry,
            clc$normal_usage_entry, 5], ['CP                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 5], ['CU                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 3], ['D                              ', clc$abbreviation_entry,
            clc$normal_usage_entry, 7], ['DATA_MODE                      ', clc$nominal_entry,
            clc$normal_usage_entry, 6], ['DESTINATION_FAMILY             ', clc$nominal_entry,
            clc$hidden_entry, 41], ['DESTINATION_USAGE              ', clc$nominal_entry, clc$hidden_entry,
            43], ['DEVICE                         ', clc$nominal_entry, clc$normal_usage_entry, 7],
            ['DEVICE_TYPE                    ', clc$nominal_entry, clc$normal_usage_entry, 8],
            ['DF                             ', clc$abbreviation_entry, clc$hidden_entry, 41],
            ['DM                             ', clc$abbreviation_entry, clc$normal_usage_entry, 6],
            ['DSRP                           ', clc$abbreviation_entry, clc$hidden_entry, 44],
            ['DT                             ', clc$abbreviation_entry, clc$normal_usage_entry, 8],
            ['DU                             ', clc$abbreviation_entry, clc$hidden_entry, 43],
            ['DUAL_STATE_ROUTE_PARAMETERS    ', clc$nominal_entry, clc$hidden_entry, 44],
            ['EARLIEST_PRINT_TIME            ', clc$nominal_entry, clc$normal_usage_entry, 9],
            ['EC                             ', clc$abbreviation_entry, clc$normal_usage_entry, 10],
            ['EPT                            ', clc$abbreviation_entry, clc$normal_usage_entry, 9],
            ['EXTERNAL_CHARACTERISTICS       ', clc$nominal_entry, clc$normal_usage_entry, 10],
            ['FC                             ', clc$abbreviation_entry, clc$normal_usage_entry, 13],
            ['FILE_POSITION                  ', clc$nominal_entry, clc$normal_usage_entry, 11],
            ['FILE_SIZE                      ', clc$nominal_entry, clc$normal_usage_entry, 12],
            ['FORMS_CODE                     ', clc$nominal_entry, clc$normal_usage_entry, 13],
            ['FP                             ', clc$abbreviation_entry, clc$normal_usage_entry, 11],
            ['FS                             ', clc$abbreviation_entry, clc$normal_usage_entry, 12],
            ['LA                             ', clc$abbreviation_entry, clc$normal_usage_entry, 15],
            ['LATEST_PRINT_TIME              ', clc$nominal_entry, clc$normal_usage_entry, 14],
            ['LF                             ', clc$abbreviation_entry, clc$normal_usage_entry, 16],
            ['LOGIN_ACCOUNT                  ', clc$nominal_entry, clc$normal_usage_entry, 15],
            ['LOGIN_FAMILY                   ', clc$nominal_entry, clc$normal_usage_entry, 16],
            ['LOGIN_PROJECT                  ', clc$nominal_entry, clc$normal_usage_entry, 17],
            ['LOGIN_USER                     ', clc$nominal_entry, clc$normal_usage_entry, 18],
            ['LP                             ', clc$abbreviation_entry, clc$normal_usage_entry, 17],
            ['LPT                            ', clc$abbreviation_entry, clc$normal_usage_entry, 14],
            ['LU                             ', clc$abbreviation_entry, clc$normal_usage_entry, 18],
            ['OAN                            ', clc$abbreviation_entry, clc$normal_usage_entry, 21],
            ['OC                             ', clc$abbreviation_entry, clc$normal_usage_entry, 22],
            ['ODBO                           ', clc$abbreviation_entry, clc$normal_usage_entry, 23],
            ['ODBU                           ', clc$abbreviation_entry, clc$normal_usage_entry, 24],
            ['ODE                            ', clc$abbreviation_entry, clc$normal_usage_entry, 25],
            ['ODU                            ', clc$abbreviation_entry, clc$normal_usage_entry, 26],
            ['OF                             ', clc$abbreviation_entry, clc$normal_usage_entry, 19],
            ['OP                             ', clc$abbreviation_entry, clc$normal_usage_entry, 27],
            ['OPERATOR_FAMILY                ', clc$nominal_entry, clc$normal_usage_entry, 19],
            ['OPERATOR_USER                  ', clc$nominal_entry, clc$normal_usage_entry, 20],
            ['ORIGINATING_APPLICATION_NAME   ', clc$nominal_entry, clc$normal_usage_entry, 21],
            ['OST                            ', clc$abbreviation_entry, clc$normal_usage_entry, 28],
            ['OU                             ', clc$abbreviation_entry, clc$normal_usage_entry, 20],
            ['OUTPUT_CLASS                   ', clc$nominal_entry, clc$normal_usage_entry, 22],
            ['OUTPUT_DEFERRED_BY_OPERATOR    ', clc$nominal_entry, clc$normal_usage_entry, 23],
            ['OUTPUT_DEFERRED_BY_USER        ', clc$nominal_entry, clc$normal_usage_entry, 24],
            ['OUTPUT_DESTINATION             ', clc$nominal_entry, clc$normal_usage_entry, 25],
            ['OUTPUT_DESTINATION_USAGE       ', clc$nominal_entry, clc$normal_usage_entry, 26],
            ['OUTPUT_PRIORITY                ', clc$nominal_entry, clc$normal_usage_entry, 27],
            ['OUTPUT_SUBMISSION_TIME         ', clc$nominal_entry, clc$normal_usage_entry, 28],
            ['PD                             ', clc$abbreviation_entry, clc$normal_usage_entry, 29],
            ['PURGE_DELAY                    ', clc$nominal_entry, clc$normal_usage_entry, 29],
            ['RB                             ', clc$abbreviation_entry, clc$normal_usage_entry, 31],
            ['REMOTE_HOST_DIRECTIVE          ', clc$nominal_entry, clc$normal_usage_entry, 30],
            ['RHD                            ', clc$abbreviation_entry, clc$normal_usage_entry, 30],
            ['ROUTING_BANNER                 ', clc$nominal_entry, clc$normal_usage_entry, 31],
            ['S                              ', clc$abbreviation_entry, clc$normal_usage_entry, 33],
            ['SFN                            ', clc$abbreviation_entry, clc$normal_usage_entry, 34],
            ['SI                             ', clc$abbreviation_entry, clc$normal_usage_entry, 32],
            ['SITE_INFORMATION               ', clc$nominal_entry, clc$normal_usage_entry, 32],
            ['SJN                            ', clc$abbreviation_entry, clc$normal_usage_entry, 35],
            ['SO                             ', clc$abbreviation_entry, clc$hidden_entry, 42],
            ['STATION                        ', clc$nominal_entry, clc$normal_usage_entry, 33],
            ['STATION_OPERATOR               ', clc$nominal_entry, clc$hidden_entry, 42],
            ['SYSTEM_FILE_NAME               ', clc$nominal_entry, clc$normal_usage_entry, 34],
            ['SYSTEM_JOB_NAME                ', clc$nominal_entry, clc$normal_usage_entry, 35],
            ['UFN                            ', clc$abbreviation_entry, clc$normal_usage_entry, 36],
            ['UI                             ', clc$abbreviation_entry, clc$normal_usage_entry, 37],
            ['UJN                            ', clc$abbreviation_entry, clc$normal_usage_entry, 38],
            ['USER_FILE_NAME                 ', clc$nominal_entry, clc$normal_usage_entry, 36],
            ['USER_INFORMATION               ', clc$nominal_entry, clc$normal_usage_entry, 37],
            ['USER_JOB_NAME                  ', clc$nominal_entry, clc$normal_usage_entry, 38],
            ['VERTICAL_PRINT_DENSITY         ', clc$nominal_entry, clc$normal_usage_entry, 39],
            ['VFU_LOAD_PROCEDURE             ', clc$nominal_entry, clc$normal_usage_entry, 40],
            ['VLP                            ', clc$abbreviation_entry, clc$normal_usage_entry, 40],
            ['VPD                            ', clc$abbreviation_entry, clc$normal_usage_entry, 39]]]];

?? POP ??

    CONST
      p$name = 1,
      p$attribute = 2;

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


    VAR
      number_of_outputs_found: jmt$output_status_count,
      output_name: jmt$name,
      output_options_p: ^jmt$output_attribute_options,
      output_results_keys_p: ^jmt$results_keys,
      output_results_p: ^jmt$output_attribute_results,
      result_size: ost$segment_length,
      work_area_p: ^jmt$work_area;

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

    jmp$determine_name_kind (pvt [p$name].value^.name_value, output_name, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    PUSH output_options_p: [1 .. 2];
    output_options_p^ [1].key := jmc$name_list;
    PUSH output_options_p^ [1].name_list: [1 .. 1];
    output_options_p^ [1].name_list^ [1] := output_name;
    output_options_p^ [2].key := jmc$continue_request_to_servers;
    output_options_p^ [2].continue_request_to_servers := TRUE;

    PUSH output_results_keys_p: [1 .. 1];
    jmp$get_attribute_index (pvt [p$attribute].value^.keyword_value, output_results_keys_p^ [1]);
    jmp$get_result_size ({number_of_items} 1, #SEQ (output_results_keys_p^), result_size);
    PUSH work_area_p: [[REP result_size OF cell]];
    RESET work_area_p;

    jmp$get_output_attributes (output_options_p, output_results_keys_p, work_area_p, output_results_p,
          number_of_outputs_found, status);
    IF NOT status.normal THEN
      IF status.condition = jme$no_outputs_were_found THEN
        IF (output_results_keys_p^ [1] <> jmc$output_state) THEN
          osp$set_status_abnormal ('JM', jme$name_not_found, pvt [p$name].value^.name_value, status);
        ELSE
          clp$make_name_value ('UNKNOWN', work_area, result);
          IF result = NIL THEN
            osp$set_status_condition (cle$work_area_overflow, status);
          ELSE
            status.normal := TRUE;
          IFEND;
        IFEND;
      ELSE
        IF status.condition = jme$work_area_too_small THEN
          osp$set_status_abnormal ('JM', jme$duplicate_name, pvt [p$name].value^.name_value, status);
        IFEND;
      IFEND;
    ELSE
      assign_function_value (output_results_p^ [1], pvt [p$attribute].value^.keyword_value, work_area, result,
            status);
    IFEND;
  PROCEND jmp$$output;
?? OLDTITLE ??
?? NEWTITLE := 'jmp$$output_status', EJECT ??

  PROCEDURE [XDCL] jmp$$output_status
    (    parameter_list: clt$parameter_list;
     VAR work_area { input, output } : ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);

{ FUNCTION (osm$$output_status) $output_status (
{   name: name = $required
{   attribute: key
{       (control_family, cf)
{       (control_user, cu)
{       (login_family, lf)
{       (login_user, lu)
{       (output_destination_usage, odu)
{       (output_state, os)
{       (system_file_name, sfn)
{       (system_job_name, sjn)
{       (user_file_name, ufn)
{     hidden_key
{       (state, s)
{     keyend = $required
{   )

?? PUSH (LISTEXT := ON) ??

    VAR
      pdt: [STATIC, READ, cls$declaration_section] record
        header: clt$pdt_header,
        names: array [1 .. 2] of clt$pdt_parameter_name,
        parameters: array [1 .. 2] 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 .. 20] of clt$keyword_specification,
        recend,
      recend := [[1, [88, 2, 18, 16, 50, 28, 515], clc$function, 2, 2, 2, 0, 0, 0, 0, 'OSM$$OUTPUT_STATUS'],
            [['ATTRIBUTE                      ', clc$nominal_entry, 2],
            ['NAME                           ', clc$nominal_entry, 1]], [

{ PARAMETER 1

      [2, clc$normal_usage_entry, clc$non_secure_parameter,
            $clt$parameter_spec_methods [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_positionally], clc$pass_by_value,
            clc$immediate_evaluation, clc$standard_parameter_checking, 747, clc$required_parameter, 0, 0]],

{ PARAMETER 1

      [[1, 0, clc$name_type], [1, osc$max_name_size]],

{ PARAMETER 2

      [[1, 0, clc$keyword_type], [20], [['CF                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 1], ['CONTROL_FAMILY                 ', clc$nominal_entry,
            clc$normal_usage_entry, 1], ['CONTROL_USER                   ', clc$nominal_entry,
            clc$normal_usage_entry, 2], ['CU                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 2], ['LF                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 3], ['LOGIN_FAMILY                   ', clc$nominal_entry,
            clc$normal_usage_entry, 3], ['LOGIN_USER                     ', clc$nominal_entry,
            clc$normal_usage_entry, 4], ['LU                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 4], ['ODU                            ', clc$abbreviation_entry,
            clc$normal_usage_entry, 5], ['OS                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 6], ['OUTPUT_DESTINATION_USAGE       ', clc$nominal_entry,
            clc$normal_usage_entry, 5], ['OUTPUT_STATE                   ', clc$nominal_entry,
            clc$normal_usage_entry, 6], ['S                              ', clc$abbreviation_entry,
            clc$hidden_entry, 10], ['SFN                            ', clc$abbreviation_entry,
            clc$normal_usage_entry, 7], ['SJN                            ', clc$abbreviation_entry,
            clc$normal_usage_entry, 8], ['STATE                          ', clc$nominal_entry,
            clc$hidden_entry, 10], ['SYSTEM_FILE_NAME               ', clc$nominal_entry,
            clc$normal_usage_entry, 7], ['SYSTEM_JOB_NAME                ', clc$nominal_entry,
            clc$normal_usage_entry, 8], ['UFN                            ', clc$abbreviation_entry,
            clc$normal_usage_entry, 9], ['USER_FILE_NAME                 ', clc$nominal_entry,
            clc$normal_usage_entry, 9]]]];

?? POP ??

    CONST
      p$name = 1,
      p$attribute = 2;

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

    VAR
      number_of_outputs_found: jmt$output_status_count,
      output_name: jmt$name,
      output_status_options: ^jmt$output_status_options,
      output_status_results: ^jmt$output_status_results,
      result_size: ost$segment_length,
      status_results_keys_p: ^jmt$results_keys,
      status_work_area_p: ^jmt$work_area;

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

    jmp$determine_name_kind (pvt [p$name].value^.name_value, output_name, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    PUSH output_status_options: [1 .. 2];
    output_status_options^ [1].key := jmc$name_list;
    PUSH output_status_options^ [1].name_list: [1 .. 1];
    output_status_options^ [1].name_list^ [1] := output_name;
    output_status_options^ [2].key := jmc$continue_request_to_servers;
    output_status_options^ [2].continue_request_to_servers := TRUE;
    PUSH status_results_keys_p: [1 .. 1];
    IF pvt [p$attribute].value^.keyword_value = 'STATE' THEN
      status_results_keys_p^ [1] := jmc$output_state;
    ELSE
      jmp$get_attribute_index (pvt [p$attribute].value^.keyword_value, status_results_keys_p^ [1]);
    IFEND;
    jmp$get_result_size ({number_of_items} 1, #SEQ (status_results_keys_p^), result_size);
    PUSH status_work_area_p: [[REP result_size OF cell]];
    RESET status_work_area_p;
    jmp$get_output_status (output_status_options, status_results_keys_p, status_work_area_p,
          output_status_results, number_of_outputs_found, status);
    IF NOT status.normal THEN
      IF status.condition = jme$no_outputs_were_found THEN
        IF (status_results_keys_p^ [1] <> jmc$output_state) THEN
          osp$set_status_abnormal ('JM', jme$name_not_found, pvt [p$name].value^.name_value, status);
        ELSE
          clp$make_name_value ('UNKNOWN', work_area, result);
          IF result = NIL THEN
            osp$set_status_condition (cle$work_area_overflow, status);
          ELSE
            status.normal := TRUE;
          IFEND;
        IFEND;
      ELSE
        IF status.condition = jme$work_area_too_small THEN
          osp$set_status_abnormal ('JM', jme$duplicate_name, pvt [p$name].value^.name_value, status);
        IFEND;
      IFEND;
    ELSE
      assign_function_value (output_status_results^ [1], pvt [p$name].value^.keyword_value, work_area, result,
            status);
    IFEND;
  PROCEND jmp$$output_status;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL] jmp$display_attributes', EJECT ??
*copy jmh$display_attributes

  PROCEDURE [XDCL, #GATE] jmp$display_attributes
    (    file_reference: fst$file_reference;
     VAR attribute_values_seq: ^SEQ ( * );
         number_to_display: integer;
         header_display_list_p: ^jmt$header_display_information,
         not_found_name_list_p: ^jmt$name_list;
         not_found_name_list_count: integer;
         command_title: string ( * );
     VAR status: ost$status);

    CONST
      clc$maximum_display_string_size = osc$max_string_size + 2,
      clc$max_display_string_chunk = clc$maximum_display_string_size DIV 2,
      maximum_attribute_name_size = 28, { Originating_Application_Name
      tab_over = maximum_attribute_name_size + 4;

    VAR
      current_date_time: ost$date_time;

*copy clv$display_variables
?? NEWTITLE := 'abort_handler', EJECT ??

{ PURPOSE:
{   Attempt to cleanup on block exit if something doesn't work.

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

      IF output_open THEN
        clp$close_display (display_control, ignore_status);
        output_open := FALSE;
        #SPOIL (output_open);
      IFEND;

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

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

{ These displays do not have subtitles.  This is merely a dummy routine to keep the module consistant
{ with those that do produce subtitles.

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

{ PURPOSE:
{   This procedure will display a header and a value that are passed as strings.  These values will be
{ displayed to the file requested on the call to jmp$display_attributes.

    PROCEDURE put_attribute
      (    header: string ( * );
           value: string ( * ));

      VAR
        start_option: amt$term_option,
        edited_header: string (tab_over);

      start_option := amc$start;
      edited_header := header;

      IF value <> ' ' THEN
        edited_header (tab_over - 2) := ':';
      IFEND;
      clp$put_partial_display (display_control, edited_header, clc$no_trim, start_option, status);
      IF NOT status.normal THEN
        EXIT jmp$display_attributes; {----->
      IFEND;
      clp$put_partial_display (display_control, value, clc$trim, amc$terminate, status);
      IF NOT status.normal THEN
        EXIT jmp$display_attributes; {----->
      IFEND;

    PROCEND put_attribute;
?? OLDTITLE ??
?? NEWTITLE := 'put_header', EJECT ??

{ PURPOSE:
{   The purpose of this request is to display a line containing a header that
{ describes a set of attributes to be displayed.

    PROCEDURE put_header
      (    header: string ( * ));

      VAR
        start_option: amt$term_option,
        edited_header: string (tab_over);

      clp$put_partial_display (display_control, header, clc$trim, amc$terminate, status);
      IF NOT status.normal THEN
        EXIT jmp$display_attributes; {----->
      IFEND;
      clp$new_display_line (display_control, 1, status);
      IF NOT status.normal THEN
        EXIT jmp$display_attributes; {----->
      IFEND;
    PROCEND put_header;
?? OLDTITLE ??
?? NEWTITLE := 'display_attribute', EJECT ??

{ PURPOSE:
{   The purpose of this procedure is to display a single attribute value.

    PROCEDURE display_attribute
      (    attribute: jmt$attribute_value;
       VAR status: ost$status);

      VAR
        temp_string: string (osc$max_string_size),
        result_length: integer,
        os_string: ost$string;

?? NEWTITLE := 'put_cpu_time_limit', EJECT ??

{ PURPOSE:
{   This procedure will display the CPU_TIME_LIMIT attribute.

      PROCEDURE put_cpu_time_limit
        (    title: string ( * );
             cpu_time_limit: jmt$cpu_time_limit);

        IF cpu_time_limit = jmc$required_cpu_time_limit THEN
          put_name (title, lowercase_required);
        ELSEIF cpu_time_limit = jmc$system_default_cpu_time_lim THEN
          put_name (title, lowercase_system_default);
        ELSEIF cpu_time_limit = jmc$unlimited_cpu_time_limit THEN
          put_name (title, lowercase_unlimited);
        ELSEIF cpu_time_limit = jmc$unspecified_cpu_time_limit THEN
          put_name (title, lowercase_unspecified);
        ELSE
          put_integer (title, cpu_time_limit);
        IFEND;
      PROCEND put_cpu_time_limit;
?? OLDTITLE ??
?? NEWTITLE := 'put_cpu_time_used', EJECT ??

{ PURPOSE:
{   This procedure will display the CPU_TIME_USED attribute.

      PROCEDURE put_cpu_time_used
        (    title: string ( * );
             cpu_time_used: jmt$cpu_time_used);

        CONST
          maximum_cpu_time_string_size = 100;

        VAR
          ignore_status: ost$status,
          millisecond_string: string (3),
          cpu_time_string: string (maximum_cpu_time_string_size),
          second_string: ost$string,
          string_index: 0 .. maximum_cpu_time_string_size;

        string_index := 1;
        cpu_time_string := 'Job Mode- ';
        string_index := string_index + 10;
        clp$convert_integer_to_string (cpu_time_used.job_mode_time DIV 1000, 10, FALSE, second_string,
              ignore_status);
        cpu_time_string (string_index, second_string.size) := second_string.value (1, second_string.size);
        string_index := string_index + second_string.size;
        cpu_time_string (string_index) := '.';
        string_index := string_index + 1;
        clp$convert_integer_to_rjstring (cpu_time_used.job_mode_time MOD 1000, 10, FALSE, '0',
              millisecond_string, ignore_status);
        cpu_time_string (string_index, 3) := millisecond_string;
        string_index := string_index + 5;
        cpu_time_string (string_index, 14) := 'Monitor Mode- ';
        string_index := string_index + 14;
        clp$convert_integer_to_string (cpu_time_used.monitor_mode_time DIV 1000, 10, FALSE, second_string,
              ignore_status);
        cpu_time_string (string_index, second_string.size) := second_string.value (1, second_string.size);
        string_index := string_index + second_string.size;
        cpu_time_string (string_index) := '.';
        string_index := string_index + 1;
        clp$convert_integer_to_rjstring (cpu_time_used.monitor_mode_time MOD 1000, 10, FALSE, '0',
              millisecond_string, ignore_status);
        cpu_time_string (string_index, 3) := millisecond_string;
        string_index := string_index + 3;

        put_large_string (title, cpu_time_string (1, string_index));
      PROCEND put_cpu_time_used;
?? OLDTITLE ??
?? NEWTITLE := 'put_date_time', EJECT ??

{ PURPOSE:
{   The purpose of this request is to format and display a date/time value.

      PROCEDURE put_date_time
        (    title: string ( * );
             date_time: ost$date_time);

        VAR
          date: ost$date,
          representation_p: ^clt$data_representation,
          scl_time_increment_value_p: ^clt$data_value,
          string_count_p: ^clt$data_representation_count,
          string_p: ^clt$string_value,
          string_size_p: ^clt$string_size,
          time: ost$time,
          work_area_pp: ^^clt$work_area;


        IF date_time = jmv$null_date_time THEN
          put_attribute (title, 'none');
        ELSE
          pmp$format_compact_date (date_time, osc$iso_date, date, status);
          IF NOT status.normal THEN
            EXIT jmp$display_attributes; {----->
          IFEND;

          pmp$format_compact_time (date_time, osc$hms_time, time, status);
          IF NOT status.normal THEN
            EXIT jmp$display_attributes; {----->
          IFEND;

          PUSH scl_time_increment_value_p;
          scl_time_increment_value_p^.kind := clc$time_increment;
          PUSH scl_time_increment_value_p^.time_increment_value;
          pmp$compute_date_time_increment (date_time, current_date_time,
                scl_time_increment_value_p^.time_increment_value^, status);
          IF NOT status.normal THEN
            EXIT jmp$display_attributes; {----->
          IFEND;
          clp$get_work_area (#RING (^work_area_pp), work_area_pp, status);
          IF NOT status.normal THEN
            EXIT jmp$display_attributes; {----->
          IFEND;
          clp$convert_data_to_string (scl_time_increment_value_p, clc$data_source_representation,
                clc$max_string_size, work_area_pp^, representation_p, status);
          IF NOT status.normal THEN
            EXIT jmp$display_attributes; {----->
          IFEND;
          NEXT string_count_p IN representation_p;
          NEXT string_size_p IN representation_p;
          NEXT string_p: [string_size_p^] IN representation_p;
          STRINGREP (temp_string, result_length, date.iso, '.', time.hms, '   (', string_p^, ')');
          put_large_string (title, temp_string (1, result_length));
        IFEND;
      PROCEND put_date_time;
?? OLDTITLE ??
?? NEWTITLE := 'put_date_time_conditional', EJECT ??

{ PURPOSE:
{   The purpose of this request is to display a date time value if one is specified or "none" if the
{ date time value is unspecified.

      PROCEDURE put_date_time_conditional
        (    title: string ( * );
             date_time: jmt$date_time);

        IF date_time.specified THEN
          put_date_time (title, date_time.date_time);
        ELSE
          put_attribute (title, 'none');
        IFEND;
      PROCEND put_date_time_conditional;
?? OLDTITLE ??
?? NEWTITLE := 'put_detached_job_wait_time', EJECT ??

{ PURPOSE:
{   This procedure will display the detached_job_wait_time attribute.

      PROCEDURE put_detached_job_wait_time
        (    title: string ( * );
             detached_job_wait_time: jmt$detached_job_wait_time);

        IF detached_job_wait_time = jmc$unlimited_det_job_wait_time THEN
          put_name (title, lowercase_unlimited);
        ELSE
          put_integer (title, detached_job_wait_time);
        IFEND;
      PROCEND put_detached_job_wait_time;
?? OLDTITLE ??
?? NEWTITLE := 'put_integer', EJECT ??

{ PURPOSE:
{   The purpose of this request is to convert and display an integer value.
{
{ NOTES:
{   All values are displayed in base 10 (ten) notation.

      PROCEDURE put_integer
        (    title: string ( * );
             integer_value: integer);

        VAR
          number_string: ost$string;

        clp$convert_integer_to_string (integer_value, 10, FALSE, number_string, ignore_status);
        put_attribute (title, number_string.value (1, number_string.size));
      PROCEND put_integer;
?? OLDTITLE ??
?? NEWTITLE := 'put_job_qualifiers', EJECT ??

{ PURPOSE:
{   This procedure displays the names that represent the job qualifiers of a job.

      PROCEDURE put_job_qualifiers
        (    header: string ( * );
             job_qualifier_list: jmt$job_qualifier_list);

{ The "33" originates from a 31 character name plus a comma plus a space.

        CONST
          max_job_qualifier_string_size = 33 * jmc$maximum_job_qualifiers;

        VAR
          qualifier_index: 1 .. jmc$maximum_job_qualifiers,
          qualifier_string: string (max_job_qualifier_string_size),
          string_index: 1 .. max_job_qualifier_string_size + 2,
          string_size: 0 .. osc$max_name_size;

        qualifier_string (1) := '[';
        string_index := 2;

        FOR qualifier_index := 1 TO UPPERBOUND (job_qualifier_list) DO
          string_size := clp$trimmed_string_size (job_qualifier_list [qualifier_index]);
          IF string_size > 0 THEN
            qualifier_string (string_index, string_size) := job_qualifier_list [qualifier_index] (1,
                  string_size);
            string_index := string_index + string_size;
            qualifier_string (string_index, 2) := ', ';
            string_index := string_index + 2;
          IFEND;
        FOREND;
        IF string_index > 2 THEN
          string_index := string_index - 2;
        IFEND;
        qualifier_string (string_index) := ']';

        put_large_string (header, qualifier_string (1, string_index));
      PROCEND put_job_qualifiers;
?? OLDTITLE ??
?? NEWTITLE := 'put_large_string', EJECT ??

{ PURPOSE:
{   This procedure will display a large string value (> 31 characters).  This is done in such a fashion
{ that if the display requires it, the line will be split into continuation lines so as not to overflow
{ the lines on the display file.

      PROCEDURE put_large_string
        (    header: string ( * );
             large_string: string ( * <= clc$maximum_display_string_size));

        TYPE
          display_string_chunk = record
            position: integer,
            length: integer,
          recend;

        VAR
          start_option: amt$term_option,
          edited_header: string (tab_over),
          terminate_string: string (2),
          display_string_length: 0 .. clc$maximum_display_string_size,
          display_string: string (clc$maximum_display_string_size),
          display_string_chunk_count: 0 .. clc$max_display_string_chunk,
          display_string_chunk_array: array [1 .. clc$max_display_string_chunk] of display_string_chunk,
          index: integer;

?? NEWTITLE := 'build_display_string', EJECT ??

{ PURPOSE:
{   This procedure takes the string to be displayed and breaks it into "chunks" that will correspond to the
{ values to be displayed for each partial line.

        PROCEDURE build_display_string
          (    display_string: string ( * );
               length: 0 .. clc$maximum_display_string_size;
               width: amt$page_width;
           VAR count: 0 .. clc$max_display_string_chunk;
           VAR display_string_array: array [1 .. clc$max_display_string_chunk] of display_string_chunk);

          VAR
            current_character_position: 0 .. clc$maximum_display_string_size,
            break_position: 0 .. clc$maximum_display_string_size,
            current_length: 0 .. clc$maximum_display_string_size,
            remaining_text: 0 .. clc$maximum_display_string_size,
            starting_position: 1 .. clc$maximum_display_string_size;

          current_character_position := 0;
          remaining_text := length;
          count := 0;
          starting_position := 1;

          WHILE remaining_text > 0 DO
            count := count + 1;
            IF remaining_text <= width THEN
              display_string_array [count].position := starting_position;
              display_string_array [count].length := remaining_text;
              RETURN; {----->
            IFEND;

            break_position := 0;
            REPEAT
              current_character_position := current_character_position + 1;
              IF (display_string (current_character_position) = ',') OR
                    (display_string (current_character_position) = ' ') THEN
                break_position := current_character_position;
              IFEND;
            UNTIL (current_character_position - starting_position) >= (width - 2);

            IF break_position > 0 THEN
              current_character_position := break_position;
            IFEND;

            current_length := current_character_position - starting_position;
            display_string_array [count].position := starting_position;
            display_string_array [count].length := current_length;
            starting_position := current_character_position;
            remaining_text := length - starting_position + 1;
          WHILEND;

        PROCEND build_display_string;
?? OLDTITLE ??
?? EJECT ??
        status.normal := TRUE;
        start_option := amc$start;
        edited_header := header;
        edited_header (tab_over - 2) := ':';
        terminate_string := '..';
        display_string_length := STRLENGTH (large_string);
        display_string := large_string (1, display_string_length);

        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;

        clp$put_partial_display (display_control, edited_header, clc$no_trim, start_option, status);
        IF NOT status.normal THEN
          EXIT jmp$display_attributes; {----->
        IFEND;

        build_display_string (display_string, display_string_length, clv$page_width - tab_over,
              display_string_chunk_count, display_string_chunk_array);

        FOR index := 1 TO display_string_chunk_count DO
          IF index = display_string_chunk_count THEN
            terminate_string := ' ';
          IFEND;
          clp$put_partial_display (display_control, display_string
                (display_string_chunk_array [index].position, display_string_chunk_array [index].length),
                clc$no_trim, amc$continue, status);
          IF NOT status.normal THEN
            EXIT jmp$display_attributes; {----->
          IFEND;
          clp$put_partial_display (display_control, terminate_string, clc$trim, amc$terminate, status);
          IF NOT status.normal THEN
            EXIT jmp$display_attributes; {----->
          IFEND;
          IF index <> display_string_chunk_count THEN
            clp$new_display_line (display_control, clc$next_display_line, status);
            IF NOT status.normal THEN
              EXIT jmp$display_attributes; {----->
            IFEND;
            clp$horizontal_tab_display (display_control, (tab_over + 1), status);
            IF NOT status.normal THEN
              EXIT jmp$display_attributes; {----->
            IFEND;
          IFEND;
        FOREND;

      PROCEND put_large_string;
?? OLDTITLE ??
?? NEWTITLE := 'put_magnetic_tape_limit', EJECT ??

{ PURPOSE:
{   This procedure will display the magnetic_tape_limit attribute.

      PROCEDURE put_magnetic_tape_limit
        (    title: string ( * );
             magnetic_tape_limit: jmt$magnetic_tape_limit);

        IF magnetic_tape_limit = jmc$required_mag_tape_limit THEN
          put_name (title, lowercase_required);
        ELSEIF magnetic_tape_limit = jmc$system_default_mag_tape_lim THEN
          put_name (title, lowercase_system_default);
        ELSEIF magnetic_tape_limit = jmc$unlimited_mag_tape_limit THEN
          put_name (title, lowercase_unlimited);
        ELSEIF magnetic_tape_limit = jmc$unspecified_mag_tape_limit THEN
          put_name (title, lowercase_unspecified);
        ELSE
          put_integer (title, magnetic_tape_limit);
        IFEND;
      PROCEND put_magnetic_tape_limit;
?? OLDTITLE ??
?? NEWTITLE := 'put_maximum_working_set', EJECT ??

{ PURPOSE:
{   This procedure will display the maximum_working_set attribute.

      PROCEDURE put_maximum_working_set
        (    title: string ( * );
             maximum_working_set: jmt$working_set_size);

        IF maximum_working_set = jmc$required_working_set_size THEN
          put_name (title, lowercase_required);
        ELSEIF maximum_working_set = jmc$system_default_work_set_siz THEN
          put_name (title, lowercase_system_default);
        ELSEIF maximum_working_set = jmc$unlimited_working_set_size THEN
          put_name (title, lowercase_unlimited);
        ELSEIF maximum_working_set = jmc$unspecified_work_set_size THEN
          put_name (title, lowercase_unspecified);
        ELSE
          put_integer (title, maximum_working_set);
        IFEND;
      PROCEND put_maximum_working_set;
?? OLDTITLE ??
?? NEWTITLE := 'put_name', EJECT ??

{ PURPOSE:
{   The purpose of this procedure is to display a name value.  If the name value is the empty string
{ then the value "none" is displayed.

      PROCEDURE put_name
        (    title: string ( * );
             name: string ( * <= osc$max_name_size));

        VAR
          string_size: 0 .. osc$max_name_size,
          translated_name: ost$name;

        string_size := clp$trimmed_string_size (name);
        IF string_size = 0 THEN
          translated_name := 'none';
          string_size := 4;
        ELSE
          #TRANSLATE (osv$upper_to_lower, name (1, string_size), translated_name);
        IFEND;
        put_attribute (title, translated_name (1, string_size));
      PROCEND put_name;
?? OLDTITLE ??
?? NEWTITLE := 'put_sense_switches', EJECT ??

{ PURPOSE:
{   This procedure will display the sense switches given.

      PROCEDURE put_sense_switches
        (    header: string ( * );
             sense_switches: pmt$sense_switches);

{ The "3" originates from a 1 character numeral plus a comma plus a space.
{ There are eight sense switches.

        CONST
          max_sense_switch_string_size = 3 * 8;

        VAR
          switch_index: 1 .. 8,
          switch_string: string (max_sense_switch_string_size),
          string_index: 1 .. max_sense_switch_string_size + 1;

        switch_string (1) := '[';
        string_index := 2;

        FOR switch_index := 1 TO 8 DO
          IF switch_index IN sense_switches THEN
            switch_string (string_index) := $CHAR (switch_index + $INTEGER ('0'));
            string_index := string_index + 1;
            switch_string (string_index, 2) := ', ';
            string_index := string_index + 2;
          IFEND;
        FOREND;
        IF string_index > 2 THEN
          string_index := string_index - 2;
        IFEND;
        switch_string (string_index) := ']';

        put_attribute (header, switch_string (1, string_index));
      PROCEND put_sense_switches;
?? OLDTITLE ??
?? NEWTITLE := 'put_sru_limit', EJECT ??

{ PURPOSE:
{   This request will display the sru_limit attribute.

      PROCEDURE put_sru_limit
        (    title: string ( * );
             sru_limit: jmt$sru_limit);

        IF sru_limit = jmc$required_sru_limit THEN
          put_name (title, lowercase_required);
        ELSEIF sru_limit = jmc$system_default_sru_limit THEN
          put_name (title, lowercase_system_default);
        ELSEIF sru_limit = jmc$unlimited_sru_limit THEN
          put_name (title, lowercase_unlimited);
        ELSEIF sru_limit = jmc$unspecified_sru_limit THEN
          put_name (title, lowercase_unspecified);
        ELSE
          put_integer (title, sru_limit);
        IFEND;
      PROCEND put_sru_limit;
?? OLDTITLE ??
?? NEWTITLE := 'put_string', EJECT ??

{ PURPOSE:
{   The purpose of this request is to display a string value surrounded by single quotes (apostrophes).

      PROCEDURE put_string
        (    title: string ( * );
             string_value: string ( * ));

        VAR
          string_size: ost$string_size,
          temp_string: string (osc$max_string_size),
          result_length: integer;

        string_size := clp$trimmed_string_size (string_value);
        IF string_size = 0 THEN
          temp_string := ''' ''';
          result_length := 3;
        ELSE
          STRINGREP (temp_string, result_length, '''', string_value (1, string_size), '''');
        IFEND;
        IF result_length > osc$max_name_size THEN
          put_large_string (title, temp_string (1, result_length));
        ELSE
          put_attribute (title, temp_string (1, result_length));
        IFEND;
      PROCEND put_string;
?? OLDTITLE ??
?? NEWTITLE := 'put_status', EJECT ??

      PROCEDURE put_status
        (    title: string ( * );
             status_value: ^ost$status);

        VAR
          i: ost$status_message_line_count,
          message: ost$status_message,
          message_area: ^ost$status_message,
          message_line_count: ^ost$status_message_line_count,
          message_line_size: ^ost$status_message_line_size,
          message_line: ^string ( * );

        IF status_value = NIL THEN
          put_attribute (title, 'NORMAL STATUS');
          RETURN; {----->
        IFEND;

        osp$format_message (status_value^, osc$current_message_level, osc$max_string_size, message, status);
        IF NOT status.normal THEN
          EXIT jmp$display_attributes; {----->
        IFEND;
        message_area := ^message;
        RESET message_area;
        NEXT message_line_count IN message_area;
        IF message_line_count^ = 0 THEN
          put_attribute (title, 'NORMAL STATUS');
        ELSE
          FOR i := 1 TO message_line_count^ DO
            NEXT message_line_size IN message_area;
            NEXT message_line: [message_line_size^] IN message_area;
            IF i = 1 THEN
              put_attribute (title, message_line^ (2, * ));
            ELSE
              put_attribute ('', message_line^ (2, * ));
            IFEND;
          FOREND;
        IFEND;

      PROCEND put_status;
?? OLDTITLE ??
?? NEWTITLE := 'put_terminate_job_action_set', EJECT ??

      PROCEDURE put_terminate_job_action_set
        (    title: string ( * );
             terminate_job_action_set: jmt$terminate_job_action_set);

        CONST
          max_terj_action_string_size = ($INTEGER (jmc$tja_user_kill_enabled) + 1) *
                max_terminate_job_action_size;

        VAR
          action_index: jmt$terminate_job_action,
          action_string: string (max_terj_action_string_size),
          string_index: 1 .. max_terj_action_string_size + 1;

        action_string (1) := '(';
        string_index := 2;

        FOR action_index := LOWERVALUE (jmt$terminate_job_action) TO UPPERVALUE (jmt$terminate_job_action) DO
          IF action_index IN terminate_job_action_set THEN
            action_string (string_index, max_terminate_job_action_size) :=
                  terminate_job_action [action_index].value (1, terminate_job_action [action_index].size);
            string_index := string_index + terminate_job_action [action_index].size;
            action_string (string_index, 2) := ', ';
            string_index := string_index + 2;
          IFEND;
        FOREND;
        IF string_index > 2 THEN
          string_index := string_index - 2;
        IFEND;
        action_string (string_index) := ')';

        put_attribute (title, action_string (1, string_index));
      PROCEND put_terminate_job_action_set;
?? OLDTITLE ??
?? NEWTITLE := 'put_time_increment', EJECT ??

      PROCEDURE put_time_increment
        (    title: string ( * );
             time_increment: jmt$time_increment);

        VAR
          representation_p: ^clt$data_representation,
          scl_time_increment_value_p: ^clt$data_value,
          string_count_p: ^clt$data_representation_count,
          string_p: ^clt$string_value,
          string_size_p: ^clt$string_size,
          work_area_pp: ^^clt$work_area;

        IF time_increment.specified THEN
          PUSH scl_time_increment_value_p;
          scl_time_increment_value_p^.kind := clc$time_increment;
          PUSH scl_time_increment_value_p^.time_increment_value;
          scl_time_increment_value_p^.time_increment_value^ := time_increment.time_increment;
          clp$get_work_area (#RING (^work_area_pp), work_area_pp, status);
          IF NOT status.normal THEN
            EXIT jmp$display_attributes; {----->
          IFEND;
          clp$convert_data_to_string (scl_time_increment_value_p, clc$data_source_representation,
                clc$max_string_size, work_area_pp^, representation_p, status);
          IF NOT status.normal THEN
            EXIT jmp$display_attributes; {----->
          IFEND;
          NEXT string_count_p IN representation_p;
          NEXT string_size_p IN representation_p;
          NEXT string_p: [string_size_p^] IN representation_p;
          put_large_string (title, string_p^);
        ELSE
          put_name (title, '');
        IFEND;
      PROCEND put_time_increment;
?? OLDTITLE ??
?? EJECT ??
      status.normal := TRUE;

      CASE attribute.key OF
      = jmc$application_name =
        put_name ('Application_Name', attribute.application_name);

      = jmc$application_status =
        put_status ('Application_Status', attribute.application_status);

      = jmc$c170_os_type =
        put_name ('C170_OS_Type', c170_os_type [attribute.c170_os_type].
              value (1, c170_os_type [attribute.c170_os_type].size));

      = jmc$client_mainframe_id =
        put_name ('Client_Mainframe_Identifier', attribute.client_mainframe_id);

      = jmc$comment_banner =
        put_string ('Comment_Banner', attribute.comment_banner);

      = jmc$control_family =
        put_name ('Control_Family', attribute.control_family);

      = jmc$control_user =
        put_name ('Control_User', attribute.control_user);

      = jmc$copies =
        put_integer ('Copies', attribute.copies);

      = jmc$copies_printed =
        put_integer ('Copies_Printed', attribute.copies_printed);

      = jmc$cpu_time_limit =
        put_cpu_time_limit ('CPU_Time_Limit', attribute.cpu_time_limit);

      = jmc$cpu_time_used =
        put_cpu_time_used ('CPU_Time_Used', attribute.cpu_time_used);

      = jmc$cyclic_aging_interval =
        put_integer ('Cyclic_Aging_Interval', attribute.cyclic_aging_interval);

      = jmc$data_declaration =
        put_string ('Data_Declaration', attribute.data_declaration);

      = jmc$data_mode =
        put_name ('Data_Mode', data_mode [attribute.data_mode].value (1, data_mode [attribute.data_mode].
              size));

      = jmc$deferred_by_application =
        put_name ('Deferred_By_Application', boolean_string [attribute.deferred_by_application].
              value (1, boolean_string [attribute.deferred_by_application].size));

      = jmc$deferred_by_operator =
        put_name ('Deferred_By_Operator', boolean_string [attribute.deferred_by_operator].
              value (1, boolean_string [attribute.deferred_by_operator].size));

      = jmc$deferred_by_user =
        put_name ('Deferred_By_user', boolean_string [attribute.deferred_by_operator].
              value (1, boolean_string [attribute.deferred_by_operator].size));

      = jmc$destination =
        put_string ('Destination', attribute.destination);

      = jmc$detached_job_wait_time =
        put_detached_job_wait_time ('Detached_Job_Wait_Time', attribute.detached_job_wait_time);

      = jmc$device =
        put_name ('Device', attribute.device);

      = jmc$device_type =
        put_name ('Device_Type', device_type [attribute.device_type].
              value (1, device_type [attribute.device_type].size));

      = jmc$dispatching_priority =
        put_name ('Dispatching_Priority', attribute.dispatching_priority);

      = jmc$display_message =
        IF attribute.display_message^.size > 0 THEN
          put_large_string ('Display_Message', attribute.display_message^.
                value (1, clp$trimmed_string_size (attribute.display_message^.value)));
        ELSE
          put_name ('Display_Message', '');
        IFEND;

      = jmc$earliest_print_time =
        put_date_time_conditional ('Earliest_Print_Time', attribute.earliest_print_time);

      = jmc$earliest_run_time =
        put_date_time_conditional ('Earliest_Run_Time', attribute.earliest_run_time);

      = jmc$external_characteristics =
        put_string ('External_Characteristics', attribute.external_characteristics);

      = jmc$file_position =
        put_integer ('File_Position', attribute.file_position);

      = jmc$file_size =
        put_integer ('File_Size', attribute.file_size);

      = jmc$forms_code =
        put_string ('Forms_Code', attribute.forms_code);

      = jmc$input_file_location =
        put_name ('Input_File_Location', input_file_location [attribute.input_file_location].
              value (1, input_file_location [attribute.input_file_location].size));

      = jmc$job_abort_disposition =
        put_name ('Job_Abort_Disposition', job_abort_disposition [attribute.job_abort_disposition].
              value (1, job_abort_disposition [attribute.job_abort_disposition].size));

      = jmc$job_class =
        put_name ('Job_Class', attribute.job_class);

      = jmc$job_class_position =
        IF attribute.job_class_position = 0 THEN
          put_name ('Job_Class_Position', '');
        ELSE
          put_integer ('Job_Class_Position', attribute.job_class_position);
        IFEND;

      = jmc$job_deferred_by_operator =
        put_name ('Job_Deferred_By_Operator', boolean_string [attribute.job_deferred_by_operator].
              value (1, boolean_string [attribute.job_deferred_by_operator].size));

      = jmc$job_deferred_by_user =
        put_name ('Job_Deferred_By_User', boolean_string [attribute.job_deferred_by_user].
              value (1, boolean_string [attribute.job_deferred_by_user].size));

      = jmc$job_destination_family =
        put_string ('Job_Destination', attribute.job_destination_family);

      = jmc$job_destination_usage =
        put_name ('Job_Destination_Usage', attribute.job_destination_usage);

      = jmc$job_execution_ring =
        IF attribute.job_execution_ring = osc$invalid_ring THEN
          put_name ('Job_Execution_Ring', 'nominal');
        ELSE
          put_integer ('Job_Execution_Ring', attribute.job_execution_ring);
        IFEND;

      = jmc$job_initiation_time =
        put_date_time_conditional ('Job_Initiation_Time', attribute.job_initiation_time);

      = jmc$job_mode =
        put_name ('Job_Mode', job_mode [attribute.job_mode].value (1, job_mode [attribute.job_mode].size));

      = jmc$job_priority =
        put_name ('Job_Priority', attribute.job_priority);

      = jmc$job_qualifier_list =
        put_job_qualifiers ('Job_Qualifier', attribute.job_qualifier_list^);

      = jmc$job_recovery_disposition =
        put_name ('Job_Recovery_Disposition', job_recovery_disposition [attribute.job_recovery_disposition].
              value (1, job_recovery_disposition [attribute.job_recovery_disposition].size));

      = jmc$job_size =
        put_integer ('Job_Size', attribute.job_size);

      = jmc$job_state =
        put_name ('Job_State', job_state [attribute.job_state].value (1, job_state [attribute.job_state].
              size));

      = jmc$job_submission_time =
        put_date_time ('Job_Submission_Time', attribute.job_submission_time);

      = jmc$latest_print_time =
        put_date_time_conditional ('Latest_Print_Time', attribute.latest_print_time);

      = jmc$latest_run_time =
        put_date_time_conditional ('Latest_Run_Time', attribute.latest_run_time);

      = jmc$login_account =
        put_name ('Login_Account', attribute.login_account);

      = jmc$login_family =
        put_name ('Login_Family', attribute.login_family);

      = jmc$login_project =
        put_name ('Login_Project', attribute.login_project);

      = jmc$login_user =
        put_name ('Login_User', attribute.login_user);

      = jmc$magnetic_tape_limit =
        put_magnetic_tape_limit ('Magnetic_Tape_Limit', attribute.magnetic_tape_limit);

      = jmc$maximum_working_set =
        put_maximum_working_set ('Maximum_Working_Set', attribute.maximum_working_set);

      = jmc$minimum_working_set =
        put_integer ('Minimum_Working_Set', attribute.minimum_working_set);

      = jmc$null_attribute =
        ;

      = jmc$operator_action_posted =
        put_name ('Operator_Action_Posted', boolean_string [attribute.operator_action_posted].
              value (1, boolean_string [attribute.operator_action_posted].size));

      = jmc$origin_application_name =
        put_name ('Originating_Application_Name', attribute.origin_application_name);

      = jmc$os_version =
        put_name ('OS_Version', attribute.os_version);

      = jmc$output_class =
        put_name ('Output_Class', attribute.output_class);

      = jmc$output_deferred_by_operator =
        put_name ('Output_Deferred_By_Operator', boolean_string [attribute.output_deferred_by_operator].
              value (1, boolean_string [attribute.output_deferred_by_operator].size));

      = jmc$output_deferred_by_user =
        put_name ('Output_Deferred_By_User', boolean_string [attribute.output_deferred_by_user].
              value (1, boolean_string [attribute.output_deferred_by_user].size));

      = jmc$output_destination =
        put_string ('Output_Destination', attribute.output_destination);

      = jmc$output_destination_family =
        put_name ('Operator_Family', attribute.output_destination_family);

      = jmc$output_destination_usage =
        put_name ('Output_Destination_Usage', attribute.output_destination_usage);

      = jmc$output_disposition =
        IF attribute.output_disposition.key = jmc$standard_output_path THEN
          put_large_string ('Output_Disposition', attribute.output_disposition.
                standard_output_path^ (1, clp$trimmed_string_size
                (attribute.output_disposition.standard_output_path^)));
        ELSE
          put_name ('Output_Disposition', output_disposition [attribute.output_disposition.key].
                value (1, output_disposition [attribute.output_disposition.key].size));
        IFEND;

      = jmc$output_priority =
        put_name ('Output_Priority', attribute.output_priority);

      = jmc$output_state =
        put_name ('Output_State', output_state [attribute.output_state].
              value (1, output_state [attribute.output_state].size));

      = jmc$output_submission_time =
        put_date_time ('Output_Submission_Time', attribute.output_submission_time);

      = jmc$page_aging_interval =
        put_integer ('Page_Aging_Interval', attribute.page_aging_interval);

      = jmc$page_faults =
        STRINGREP (temp_string, result_length, 'Assigned-', attribute.page_faults.new_pages_assigned,
              '  From Disk-', attribute.page_faults.pages_read_from_disk, '  Reclaimed-',
              attribute.page_faults.pages_reclaimed_from_memory);
        put_large_string ('Page_Faults', temp_string (1, result_length));

      = jmc$processing_phase =
        put_attribute ('Processing_Phase', processing_phase
              [translated_processing_phase (attribute.processing_phase)].
              value (1, processing_phase [translated_processing_phase (attribute.processing_phase)].size));

      = jmc$purge_delay =
        put_time_increment ('Purge_Delay', attribute.purge_delay^);

      = jmc$qfile_state =
        put_name ('State', qfile_state [attribute.qfile_state].value (1,
              qfile_state [attribute.qfile_state].size));

      = jmc$remote_host_directive =
        IF attribute.remote_host_directive^.size = 0 THEN
          put_string ('Remote_Host_Directive', '');
        ELSE
          put_string ('Remote_Host_Directive', attribute.remote_host_directive^.
                parameters (1, attribute.remote_host_directive^.size));
        IFEND;

      = jmc$routing_banner =
        put_string ('Routing_Banner', attribute.routing_banner);

      = jmc$sense_switches =
        put_sense_switches ('Sense_Switches', attribute.sense_switches);

      = jmc$server_mainframe_id =
        put_name ('Server_Mainframe_Identifier', attribute.server_mainframe_id);

      = jmc$service_class =
        put_name ('Service_Class', attribute.service_class);

      = jmc$site_information =
        put_string ('Site_Information', attribute.site_information^);

      = jmc$source_logical_id =
        put_name ('Source_Logical_ID', attribute.source_logical_id);

      = jmc$sru_limit =
        put_sru_limit ('SRU_limit', attribute.sru_limit);

      = jmc$station =
        put_name ('Station', attribute.station);

      = jmc$station_operator =
        put_name ('Operator_User', attribute.station_operator);

      = jmc$system_file_name =
        put_name ('System_File_Name', attribute.system_file_name);

      = jmc$system_job_name =
        put_name ('System_Job_Name', attribute.system_job_name);

      = jmc$terminate_job_action_set =
        put_terminate_job_action_set ('Terminate_Job_Action', attribute.terminate_job_action_set);

      = jmc$user_file_name =
        put_name ('User_File_Name', attribute.user_file_name);

      = jmc$user_information =
        put_string ('User_Information', attribute.user_information^);

      = jmc$user_job_name =
        put_name ('User_Job_Name', attribute.user_job_name);

      = jmc$vertical_print_density =
        CASE attribute.vertical_print_density OF
        = jmc$vertical_print_density_file =
          put_name ('Vertical_Print_Density', 'file');
        = jmc$vertical_print_density_none =
          put_name ('Vertical_Print_Density', '');
        = jmc$vertical_print_density_6 =
          put_name ('Vertical_Print_Density', 'six');
        ELSE
          put_name ('Vertical_Print_Density', 'eight');
        CASEND;

      = jmc$vfu_load_procedure =
        put_name ('VFU_Load_Procedure', attribute.vfu_load_procedure);

      ELSE
        put_name ('Undefined_Attribute', '');

      CASEND;
    PROCEND display_attribute;
?? OLDTITLE ??
?? EJECT ??

    VAR
      attribute_values_pp: ^^array [1 .. * ] of ^jmt$attribute_values,
      data_written: boolean,
      default_ring_attributes: amt$ring_attributes,
      display_control: clt$display_control,
      display_index: 0 .. jmc$maximum_attribute_index,
      ignore_status: ost$status,
      name_index: integer,
      object_index: integer,
      output_open: boolean,
      string_size: ost$string_size,
      temp_string: string (osc$max_string_size);

    pmp$get_compact_date_time (current_date_time, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

{ Set-up access to the array by converting it from a sequence to the expected pointer object.

    RESET attribute_values_seq;
    NEXT attribute_values_pp IN attribute_values_seq;

    output_open := FALSE;
    #SPOIL (output_open);
    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 (file_reference, ^clp$new_page_procedure, fsc$list, default_ring_attributes,
          display_control, status);
    IF NOT status.normal THEN
      osp$disestablish_cond_handler;
      RETURN {----->
    IFEND;
    output_open := TRUE;
    #SPOIL (output_open);

    clv$titles_built := FALSE;
    clv$command_name := command_title;

  /display/
    BEGIN

    /display_all_objects/
      FOR object_index := 1 TO number_to_display DO
        data_written := FALSE;
        IF object_index > 1 THEN
          clp$new_display_line (display_control, 1, status);
          IF NOT status.normal THEN
            EXIT /display/; {----->
          IFEND;
        ELSEIF NOT (display_control.page_format = amc$continuous_form) AND
              NOT (display_control.page_format = amc$untitled_form) THEN
          clp$new_display_page (display_control, status);
          IF NOT status.normal THEN
            EXIT /display/; {----->
          IFEND;
        IFEND;

{ Display the header to augment each list of attributes.  If there are more lists
{ of attributes to be displayed, use the last header available.

        IF header_display_list_p <> NIL THEN
          IF object_index <= UPPERBOUND (header_display_list_p^) THEN
            put_header (header_display_list_p^ [object_index].value (1,
                  header_display_list_p^ [object_index].size));
          ELSE
            put_header (header_display_list_p^ [UPPERBOUND (header_display_list_p^)].
                  value (1, header_display_list_p^ [UPPERBOUND (header_display_list_p^)].size));
          IFEND;
        IFEND;

      /display_all_attributes/
        FOR display_index := 1 TO UPPERBOUND (attribute_values_pp^^ [object_index]^) DO
          display_attribute (attribute_values_pp^^ [object_index]^ [display_index], status);
          IF NOT status.normal THEN
            EXIT /display_all_objects/; {----->
          IFEND;
        FOREND /display_all_attributes/;
      FOREND /display_all_objects/;

      IF (not_found_name_list_p <> NIL) AND (not_found_name_list_count > 0) THEN
        FOR name_index := 1 TO not_found_name_list_count DO
          IF not_found_name_list_p^ [name_index].kind = jmc$system_supplied_name THEN
            #TRANSLATE (osv$upper_to_lower, not_found_name_list_p^ [name_index].system_supplied_name,
                  temp_string);
          ELSE
            string_size := clp$trimmed_string_size (not_found_name_list_p^ [name_index].user_supplied_name);
            #TRANSLATE (osv$upper_to_lower, not_found_name_list_p^ [name_index].
                  user_supplied_name (1, string_size), temp_string);
          IFEND;

{ If anything has been displayed, a blank line must be added otherwise a new page may be necessary.

          IF (number_to_display > 0) OR (name_index > 1) THEN
            clp$new_display_line (display_control, 1, status);
            IF NOT status.normal THEN
              EXIT /display/; {----->
            IFEND;
          ELSEIF NOT (display_control.page_format = amc$continuous_form) AND
                NOT (display_control.page_format = amc$untitled_form) THEN
            clp$new_display_page (display_control, status);
            IF NOT status.normal THEN
              EXIT /display/; {----->
            IFEND;
          IFEND;
          put_attribute ('Name Not Found', temp_string);
        FOREND;
      ELSE
        IF number_to_display = 0 THEN
          IF (display_control.page_format <> amc$continuous_form) AND
                (display_control.page_format <> amc$untitled_form) THEN
            clp$new_display_page (display_control, status);
            IF NOT status.normal THEN
              EXIT /display/; {----->
            IFEND;
          IFEND;
          put_attribute ('None Were Found.', '');
        IFEND;
      IFEND;
    END /display/;

    clp$close_display (display_control, ignore_status);
    output_open := FALSE;
    #SPOIL (output_open);
    osp$disestablish_cond_handler;

  PROCEND jmp$display_attributes;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] jmp$get_attribute_index', EJECT ??
*copy jmh$get_attribute_index

  PROCEDURE [XDCL, #GATE] jmp$get_attribute_index
    (    attribute_name: string ( * <= osc$max_name_size);
     VAR attribute_index: jmt$attribute_keys);

    VAR
      low_index: 1 .. alphabetical_attribute_count + 1,
      high_index: 0 .. alphabetical_attribute_count,
      temp: integer,
      current_index: 1 .. alphabetical_attribute_count;

    low_index := 1;
    high_index := alphabetical_attribute_count;
    REPEAT
      temp := low_index + high_index;
      current_index := temp DIV 2;
      IF attribute_name = alphabetical_attribute_list [current_index].attribute_name THEN
        attribute_index := alphabetical_attribute_list [current_index].attribute_index;
        RETURN; {----->
      ELSEIF attribute_name > alphabetical_attribute_list [current_index].attribute_name THEN
        low_index := current_index + 1;
      ELSE
        high_index := current_index - 1;
      IFEND;
    UNTIL low_index > high_index;
    attribute_index := jmc$unknown_attribute;
  PROCEND jmp$get_attribute_index;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] jmp$get_attribute_name', EJECT ??
*copy jmh$get_attribute_name

  PROCEDURE [XDCL, #GATE] jmp$get_attribute_name
    (    attribute_index: jmt$attribute_keys;
     VAR attribute_name: ost$name);

    VAR
      low_index: 1 .. indexed_attribute_count + 1,
      high_index: 0 .. indexed_attribute_count,
      temp: integer,
      current_index: 1 .. indexed_attribute_count;

    low_index := 1;
    high_index := indexed_attribute_count;
    REPEAT
      temp := low_index + high_index;
      current_index := temp DIV 2;
      IF attribute_index = indexed_attribute_list [current_index].attribute_index THEN
        attribute_name := indexed_attribute_list [current_index].attribute_name;
        RETURN; {----->
      ELSEIF attribute_index > indexed_attribute_list [current_index].attribute_index THEN
        low_index := current_index + 1;
      ELSE
        high_index := current_index - 1;
      IFEND;
    UNTIL low_index > high_index;
    attribute_name := unknown_attribute_name;
  PROCEND jmp$get_attribute_name;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] jmp$get_result_size', EJECT ??
*copy jmh$get_result_size

  PROCEDURE [XDCL, #GATE] jmp$get_result_size
    (    number_of_items: ost$non_negative_integers;
         results_keys_seq_p: ^SEQ ( * );
     VAR size: ost$segment_length);

    VAR
      application_attr_size_added: boolean,
      seq_p: ^SEQ ( * ),
      result_keys_p: ^jmt$results_keys,
      result_index: ost$positive_integers,
      number_of_keys: ost$positive_integers;


    application_attr_size_added := FALSE;
    size := 0;
    IF results_keys_seq_p <> NIL THEN
      seq_p := results_keys_seq_p;
      number_of_keys := #SIZE (seq_p^) DIV #SIZE (jmt$attribute_keys);
      IF number_of_keys > 0 THEN
        NEXT result_keys_p: [1 .. number_of_keys] IN seq_p;

        size := #SIZE (jmt$attribute_values: [1 .. 1]) + (number_of_keys * #SIZE (jmt$attribute_value));
        FOR result_index := 1 TO number_of_keys DO
          CASE result_keys_p^ [result_index] OF
          = jmc$application_attributes_1, jmc$application_attributes_2, jmc$application_attributes_3,
                jmc$application_attributes_4, jmc$application_attributes_5, jmc$application_attributes_6,
                jmc$application_attributes_7, jmc$application_attributes_8, jmc$application_attributes_9,
                jmc$application_attributes_10 =
            IF NOT application_attr_size_added THEN
              application_attr_size_added := TRUE;
              size := size + jmc$max_qfile_appl_attr_size;
            IFEND;
          = jmc$application_status =
            size := size + #SIZE (ost$status);
          = jmc$display_message =
            size := size + #SIZE (jmt$display_message);
          = jmc$job_qualifier_list =
            size := size + #SIZE (jmt$job_qualifier_list: [1 .. jmc$maximum_job_qualifiers]);
          = jmc$output_disposition =
            size := size + #SIZE (fst$path);
          = jmc$purge_delay =
            size := size + #SIZE (jmt$time_increment);
          = jmc$remote_host_directive =
            size := size + #SIZE (jmt$remote_host_directive);
          = jmc$site_information =
            size := size + #SIZE (jmt$site_information);
          = jmc$user_information =
            size := size + #SIZE (jmt$user_information);
          ELSE
          CASEND;
        FOREND;
        size := size * number_of_items;
      IFEND;
    IFEND;
  PROCEND jmp$get_result_size;
?? OLDTITLE ??
MODEND jmm$attribute_display_functions;
