?? RIGHT := 110 ??
?? NEWTITLE := 'NOSVE job management operator facility command procedures' ??
MODULE jmm$operator_facility_commands;
?? RIGHT := 110 ??

{ PURPOSE:
{   This module contains the command processors for the Job Management related
{ operator facility commands.

?? NEWTITLE := 'Global Declarations Referenced by this Module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc cle$ecc_miscellaneous
*copyc jme$queued_file_conditions
*copyc jmt$attribute_keys_set
*copyc jmt$attribute_values
*copyc jmt$job_counts
*copyc jmt$job_status_count
*copyc jmt$job_status_options
*copyc jmt$job_status_results
*copyc jmt$output_counts
*copyc jmt$output_status_count
*copyc jmt$output_status_options
*copyc jmt$output_status_results
*copyc jmt$system_supplied_name
?? POP ??
*copyc clp$count_list_elements
*copyc clp$evaluate_parameters
*copyc jmp$change_attribute_defaults
*copyc jmp$change_terminate_job_action
*copyc jmp$display_attributes
*copyc jmp$get_attribute_index
*copyc jmp$get_job_status
*copyc jmp$get_output_status
*copyc jmp$get_result_size
*copyc jmp$get_terminate_job_action
*copyc jmp$idle_system
*copyc jmp$resume_system
*copyc jmp$system_job
*copyc jmp$set_system_sequence_number
*copyc mmp$create_scratch_segment
*copyc mmp$delete_scratch_segment
*copyc osp$disestablish_cond_handler
*copyc osp$establish_block_exit_hndlr
*copyc osp$set_status_abnormal
*copyc osp$set_status_from_condition
?? TITLE := '[XDCL, #GATE] clp$change_job_attr_default_cmd', EJECT ??

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

{ PROCEDURE (osm$chajad) change_job_attribute_default, change_job_attribute_defaults, chajad (
{   job_mode, jm: any of
{       key
{         all
{       keyend
{       list of key
{         (batch, b)
{         (interactive, i)
{       keyend
{     anyend = all
{   cpu_time_limit, ctl: any of
{       key
{         required, unlimited
{       keyend
{       integer jmc$lowest_cpu_time_limit..jmc$highest_cpu_time_limit
{     anyend = $optional
{   job_abort_disposition, jad: key
{       (restart, r)
{       (terminate, t)
{     keyend = $optional
{   job_class, jc: name = $optional
{   job_deferred_by_operator, jdbo: boolean = $optional
{   job_destination_usage, jdu: key
{       ve, ve_family, ve_local, ve_qtf
{     keyend = $optional
{   job_qualifier, job_qualifiers, jq: any of
{       key
{         none, required
{       keyend
{       list 1..jmc$maximum_job_qualifiers of name
{     anyend = $optional
{   job_recovery_disposition, jrd: key
{       (continue, c)
{       (restart, r)
{       (terminate, t)
{     keyend = $optional
{   login_family, lf: name = $optional
{   magnetic_tape_limit, mtl: any of
{       key
{         required, unlimited, unspecified
{       keyend
{       integer jmc$lowest_magnetic_tape_limit..jmc$highest_magnetic_tape_limit
{     anyend = $optional
{   maximum_working_set, maxws: any of
{       key
{         required, unlimited
{       keyend
{       integer jmc$lowest_working_set_size..jmc$highest_working_set_size
{     anyend = $optional
{   output_class, oc: key
{       normal
{     keyend = $optional
{   output_deferred_by_operator, odbo: boolean = $optional
{   output_destination_usage, destination_usage, du, odu: any of
{       key
{         dual_state, ntf, private, public, qtf
{       keyend
{       name
{     anyend = $optional
{   purge_delay, pd: any of
{       key
{         none
{       keyend
{       time_increment
{     anyend = $optional
{   site_information, si: string 0..jmc$site_information_size = $optional
{   sru_limit, sl: any of
{       key
{         required, unlimited
{       keyend
{       integer jmc$lowest_sru_limit..jmc$highest_sru_limit
{     anyend = $optional
{   station, s: name = $optional
{   vertical_print_density, vpd: key
{       six, eight, none, file
{     keyend = $optional
{   status)

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

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 42] of clt$pdt_parameter_name,
      parameters: array [1 .. 20] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 1] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$list_type_qualifier_v2,
          element_type_spec: record
            header: clt$type_specification_header,
            qualifier: clt$keyword_type_qualifier,
            keyword_specs: array [1 .. 4] of clt$keyword_specification,
          recend,
        recend,
        default_value: string (3),
      recend,
      type2: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 2] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$integer_type_qualifier,
        recend,
      recend,
      type3: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 4] of clt$keyword_specification,
      recend,
      type4: record
        header: clt$type_specification_header,
        qualifier: clt$name_type_qualifier,
      recend,
      type5: record
        header: clt$type_specification_header,
      recend,
      type6: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 4] of clt$keyword_specification,
      recend,
      type7: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 2] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$list_type_qualifier_v2,
          element_type_spec: record
            header: clt$type_specification_header,
            qualifier: clt$name_type_qualifier,
          recend,
        recend,
      recend,
      type8: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 6] of clt$keyword_specification,
      recend,
      type9: record
        header: clt$type_specification_header,
        qualifier: clt$name_type_qualifier,
      recend,
      type10: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 3] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$integer_type_qualifier,
        recend,
      recend,
      type11: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 2] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$integer_type_qualifier,
        recend,
      recend,
      type12: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 1] of clt$keyword_specification,
      recend,
      type13: record
        header: clt$type_specification_header,
      recend,
      type14: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 5] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$name_type_qualifier,
        recend,
      recend,
      type15: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 1] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
        recend,
      recend,
      type16: record
        header: clt$type_specification_header,
        qualifier: clt$string_type_qualifier,
      recend,
      type17: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 2] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$integer_type_qualifier,
        recend,
      recend,
      type18: record
        header: clt$type_specification_header,
        qualifier: clt$name_type_qualifier,
      recend,
      type19: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 4] of clt$keyword_specification,
      recend,
      type20: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [91, 7, 8, 15, 40, 21, 820],
    clc$command, 42, 20, 0, 0, 0, 0, 20, 'OSM$CHAJAD'], [
    ['CPU_TIME_LIMIT                 ',clc$nominal_entry, 2],
    ['CTL                            ',clc$abbreviation_entry, 2],
    ['DESTINATION_USAGE              ',clc$alias_entry, 14],
    ['DU                             ',clc$alias_entry, 14],
    ['JAD                            ',clc$abbreviation_entry, 3],
    ['JC                             ',clc$abbreviation_entry, 4],
    ['JDBO                           ',clc$abbreviation_entry, 5],
    ['JDU                            ',clc$abbreviation_entry, 6],
    ['JM                             ',clc$abbreviation_entry, 1],
    ['JOB_ABORT_DISPOSITION          ',clc$nominal_entry, 3],
    ['JOB_CLASS                      ',clc$nominal_entry, 4],
    ['JOB_DEFERRED_BY_OPERATOR       ',clc$nominal_entry, 5],
    ['JOB_DESTINATION_USAGE          ',clc$nominal_entry, 6],
    ['JOB_MODE                       ',clc$nominal_entry, 1],
    ['JOB_QUALIFIER                  ',clc$nominal_entry, 7],
    ['JOB_QUALIFIERS                 ',clc$alias_entry, 7],
    ['JOB_RECOVERY_DISPOSITION       ',clc$nominal_entry, 8],
    ['JQ                             ',clc$abbreviation_entry, 7],
    ['JRD                            ',clc$abbreviation_entry, 8],
    ['LF                             ',clc$abbreviation_entry, 9],
    ['LOGIN_FAMILY                   ',clc$nominal_entry, 9],
    ['MAGNETIC_TAPE_LIMIT            ',clc$nominal_entry, 10],
    ['MAXIMUM_WORKING_SET            ',clc$nominal_entry, 11],
    ['MAXWS                          ',clc$abbreviation_entry, 11],
    ['MTL                            ',clc$abbreviation_entry, 10],
    ['OC                             ',clc$abbreviation_entry, 12],
    ['ODBO                           ',clc$abbreviation_entry, 13],
    ['ODU                            ',clc$abbreviation_entry, 14],
    ['OUTPUT_CLASS                   ',clc$nominal_entry, 12],
    ['OUTPUT_DEFERRED_BY_OPERATOR    ',clc$nominal_entry, 13],
    ['OUTPUT_DESTINATION_USAGE       ',clc$nominal_entry, 14],
    ['PD                             ',clc$abbreviation_entry, 15],
    ['PURGE_DELAY                    ',clc$nominal_entry, 15],
    ['S                              ',clc$abbreviation_entry, 18],
    ['SI                             ',clc$abbreviation_entry, 16],
    ['SITE_INFORMATION               ',clc$nominal_entry, 16],
    ['SL                             ',clc$abbreviation_entry, 17],
    ['SRU_LIMIT                      ',clc$nominal_entry, 17],
    ['STATION                        ',clc$nominal_entry, 18],
    ['STATUS                         ',clc$nominal_entry, 20],
    ['VERTICAL_PRINT_DENSITY         ',clc$nominal_entry, 19],
    ['VPD                            ',clc$abbreviation_entry, 19]],
    [
{ PARAMETER 1
    [14, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 235,
  clc$optional_default_parameter, 0, 3],
{ PARAMETER 2
    [1, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 121,
  clc$optional_parameter, 0, 0],
{ PARAMETER 3
    [10, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 155,
  clc$optional_parameter, 0, 0],
{ PARAMETER 4
    [11, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 5, clc$optional_parameter, 0
  , 0],
{ PARAMETER 5
    [12, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$optional_parameter, 0
  , 0],
{ PARAMETER 6
    [13, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 155,
  clc$optional_parameter, 0, 0],
{ PARAMETER 7
    [15, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 122,
  clc$optional_parameter, 0, 0],
{ PARAMETER 8
    [17, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 229,
  clc$optional_parameter, 0, 0],
{ PARAMETER 9
    [21, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 5, clc$optional_parameter, 0
  , 0],
{ PARAMETER 10
    [22, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 158,
  clc$optional_parameter, 0, 0],
{ PARAMETER 11
    [23, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 121,
  clc$optional_parameter, 0, 0],
{ PARAMETER 12
    [29, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 44, clc$optional_parameter,
  0, 0],
{ PARAMETER 13
    [30, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$optional_parameter, 0
  , 0],
{ PARAMETER 14
    [31, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 217,
  clc$optional_parameter, 0, 0],
{ PARAMETER 15
    [33, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 67, clc$optional_parameter,
  0, 0],
{ PARAMETER 16
    [36, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 8, clc$optional_parameter, 0
  , 0],
{ PARAMETER 17
    [38, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 121,
  clc$optional_parameter, 0, 0],
{ PARAMETER 18
    [39, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 5, clc$optional_parameter, 0
  , 0],
{ PARAMETER 19
    [41, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 155,
  clc$optional_parameter, 0, 0],
{ PARAMETER 20
    [40, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$union_type], [[clc$keyword_type, clc$list_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['ALL                            ', clc$nominal_entry, clc$normal_usage_entry, 1]]
      ],
    171, [[1, 0, clc$list_type], [155, 1, clc$max_list_size, 0, FALSE, FALSE],
        [[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]]
        ]
      ]
    ,
    'all'],
{ PARAMETER 2
    [[1, 0, clc$union_type], [[clc$integer_type, clc$keyword_type],
    FALSE, 2],
    81, [[1, 0, clc$keyword_type], [2], [
      ['REQUIRED                       ', clc$nominal_entry, clc$normal_usage_entry, 1],
      ['UNLIMITED                      ', clc$nominal_entry, clc$normal_usage_entry, 2]]
      ],
    20, [[1, 0, clc$integer_type], [jmc$lowest_cpu_time_limit, jmc$highest_cpu_time_limit, 10]]
    ],
{ PARAMETER 3
    [[1, 0, clc$keyword_type], [4], [
    ['R                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
    ['RESTART                        ', clc$nominal_entry, clc$normal_usage_entry, 1],
    ['T                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
    ['TERMINATE                      ', clc$nominal_entry, clc$normal_usage_entry, 2]]
    ],
{ PARAMETER 4
    [[1, 0, clc$name_type], [1, osc$max_name_size]],
{ PARAMETER 5
    [[1, 0, clc$boolean_type]],
{ PARAMETER 6
    [[1, 0, clc$keyword_type], [4], [
    ['VE                             ', clc$nominal_entry, clc$normal_usage_entry, 1],
    ['VE_FAMILY                      ', clc$nominal_entry, clc$normal_usage_entry, 2],
    ['VE_LOCAL                       ', clc$nominal_entry, clc$normal_usage_entry, 3],
    ['VE_QTF                         ', clc$nominal_entry, clc$normal_usage_entry, 4]]
    ],
{ PARAMETER 7
    [[1, 0, clc$union_type], [[clc$keyword_type, clc$list_type],
    FALSE, 2],
    81, [[1, 0, clc$keyword_type], [2], [
      ['NONE                           ', clc$nominal_entry, clc$normal_usage_entry, 1],
      ['REQUIRED                       ', clc$nominal_entry, clc$normal_usage_entry, 2]]
      ],
    21, [[1, 0, clc$list_type], [5, 1, jmc$maximum_job_qualifiers, 0, FALSE, FALSE],
        [[1, 0, clc$name_type], [1, osc$max_name_size]]
      ]
    ],
{ PARAMETER 8
    [[1, 0, clc$keyword_type], [6], [
    ['C                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
    ['CONTINUE                       ', clc$nominal_entry, clc$normal_usage_entry, 1],
    ['R                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
    ['RESTART                        ', clc$nominal_entry, clc$normal_usage_entry, 2],
    ['T                              ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
    ['TERMINATE                      ', clc$nominal_entry, clc$normal_usage_entry, 3]]
    ],
{ PARAMETER 9
    [[1, 0, clc$name_type], [1, osc$max_name_size]],
{ PARAMETER 10
    [[1, 0, clc$union_type], [[clc$integer_type, clc$keyword_type],
    FALSE, 2],
    118, [[1, 0, clc$keyword_type], [3], [
      ['REQUIRED                       ', clc$nominal_entry, clc$normal_usage_entry, 1],
      ['UNLIMITED                      ', clc$nominal_entry, clc$normal_usage_entry, 2],
      ['UNSPECIFIED                    ', clc$nominal_entry, clc$normal_usage_entry, 3]]
      ],
    20, [[1, 0, clc$integer_type], [jmc$lowest_magnetic_tape_limit, jmc$highest_magnetic_tape_limit, 10]]
    ],
{ PARAMETER 11
    [[1, 0, clc$union_type], [[clc$integer_type, clc$keyword_type],
    FALSE, 2],
    81, [[1, 0, clc$keyword_type], [2], [
      ['REQUIRED                       ', clc$nominal_entry, clc$normal_usage_entry, 1],
      ['UNLIMITED                      ', clc$nominal_entry, clc$normal_usage_entry, 2]]
      ],
    20, [[1, 0, clc$integer_type], [jmc$lowest_working_set_size, jmc$highest_working_set_size, 10]]
    ],
{ PARAMETER 12
    [[1, 0, clc$keyword_type], [1], [
    ['NORMAL                         ', clc$nominal_entry, clc$normal_usage_entry, 1]]
    ],
{ PARAMETER 13
    [[1, 0, clc$boolean_type]],
{ PARAMETER 14
    [[1, 0, clc$union_type], [[clc$keyword_type, clc$name_type],
    FALSE, 2],
    192, [[1, 0, clc$keyword_type], [5], [
      ['DUAL_STATE                     ', clc$nominal_entry, clc$normal_usage_entry, 1],
      ['NTF                            ', clc$nominal_entry, clc$normal_usage_entry, 2],
      ['PRIVATE                        ', clc$nominal_entry, clc$normal_usage_entry, 3],
      ['PUBLIC                         ', clc$nominal_entry, clc$normal_usage_entry, 4],
      ['QTF                            ', clc$nominal_entry, clc$normal_usage_entry, 5]]
      ],
    5, [[1, 0, clc$name_type], [1, osc$max_name_size]]
    ],
{ PARAMETER 15
    [[1, 0, clc$union_type], [[clc$keyword_type, clc$time_increment_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['NONE                           ', clc$nominal_entry, clc$normal_usage_entry, 1]]
      ],
    3, [[1, 0, clc$time_increment_type]]
    ],
{ PARAMETER 16
    [[1, 0, clc$string_type], [0, jmc$site_information_size, FALSE]],
{ PARAMETER 17
    [[1, 0, clc$union_type], [[clc$integer_type, clc$keyword_type],
    FALSE, 2],
    81, [[1, 0, clc$keyword_type], [2], [
      ['REQUIRED                       ', clc$nominal_entry, clc$normal_usage_entry, 1],
      ['UNLIMITED                      ', clc$nominal_entry, clc$normal_usage_entry, 2]]
      ],
    20, [[1, 0, clc$integer_type], [jmc$lowest_sru_limit, jmc$highest_sru_limit, 10]]
    ],
{ PARAMETER 18
    [[1, 0, clc$name_type], [1, osc$max_name_size]],
{ PARAMETER 19
    [[1, 0, clc$keyword_type], [4], [
    ['EIGHT                          ', clc$nominal_entry, clc$normal_usage_entry, 2],
    ['FILE                           ', clc$nominal_entry, clc$normal_usage_entry, 4],
    ['NONE                           ', clc$nominal_entry, clc$normal_usage_entry, 3],
    ['SIX                            ', clc$nominal_entry, clc$normal_usage_entry, 1]]
    ],
{ PARAMETER 20
    [[1, 0, clc$status_type]]];

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

    CONST
      p$job_mode = 1,
      p$cpu_time_limit = 2,
      p$job_abort_disposition = 3,
      p$job_class = 4,
      p$job_deferred_by_operator = 5,
      p$job_destination_usage = 6,
      p$job_qualifier = 7,
      p$job_recovery_disposition = 8,
      p$login_family = 9,
      p$magnetic_tape_limit = 10,
      p$maximum_working_set = 11,
      p$output_class = 12,
      p$output_deferred_by_operator = 13,
      p$output_destination_usage = 14,
      p$purge_delay = 15,
      p$site_information = 16,
      p$sru_limit = 17,
      p$station = 18,
      p$vertical_print_density = 19,
      p$status = 20;

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

    VAR
      change_batch: boolean,
      change_interactive: boolean,
      default_attribute_changes: ^jmt$default_attribute_changes,
      default_attribute_index: 0 .. p$vertical_print_density,
      index: 1 .. clc$max_list_size,
      list_count: 0 .. clc$max_list_size,
      number_of_default_attributes: 0 .. p$vertical_print_density,
      qualifier_options: ^clt$data_value,
      set_list: ^clt$data_value;

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

    default_attribute_index := 0;
    number_of_default_attributes := 0;

    FOR index := p$cpu_time_limit TO p$vertical_print_density DO
      IF pvt [index].specified THEN
        number_of_default_attributes := number_of_default_attributes + 1;
      IFEND;
    FOREND;

    PUSH default_attribute_changes: [1 .. number_of_default_attributes];

{  Process CPU_TIME_LIMIT parameter.

    IF pvt [p$cpu_time_limit].specified THEN
      default_attribute_index := default_attribute_index + 1;
      default_attribute_changes^ [default_attribute_index].key := jmc$cpu_time_limit;
      IF pvt [p$cpu_time_limit].value^.kind = clc$integer THEN
        default_attribute_changes^ [default_attribute_index].cpu_time_limit := pvt [p$cpu_time_limit].
              value^.integer_value.value;
      ELSE
        IF pvt [p$cpu_time_limit].value^.keyword_value = 'REQUIRED' THEN
          default_attribute_changes^ [default_attribute_index].cpu_time_limit := jmc$required_cpu_time_limit;
        ELSE { pvt [p$cpu_time_limit].value^.keyword_value = 'UNLIMITED'.
          default_attribute_changes^ [default_attribute_index].cpu_time_limit := jmc$unlimited_cpu_time_limit;
        IFEND;
      IFEND;
    IFEND;

{  Process JOB_ABORT_DISPOSITION parameter.

    IF pvt [p$job_abort_disposition].specified THEN
      default_attribute_index := default_attribute_index + 1;
      default_attribute_changes^ [default_attribute_index].key := jmc$job_abort_disposition;
      IF pvt [p$job_abort_disposition].value^.keyword_value = 'RESTART' THEN
        default_attribute_changes^ [default_attribute_index].job_abort_disposition := jmc$restart_on_abort;
      ELSE { TERMINATE is the only other choice. }
        default_attribute_changes^ [default_attribute_index].job_abort_disposition := jmc$terminate_on_abort;
      IFEND;
    IFEND;

{ Process JOB_CLASS parameter.

    IF pvt [p$job_class].specified THEN
      default_attribute_index := default_attribute_index + 1;
      default_attribute_changes^ [default_attribute_index].key := jmc$job_class;
      default_attribute_changes^ [default_attribute_index].job_class := pvt [p$job_class].value^.name_value;
    IFEND;

{  Process JOB_DEFERRED_BY_OPERATOR parameter.

    IF pvt [p$job_deferred_by_operator].specified THEN
      default_attribute_index := default_attribute_index + 1;
      default_attribute_changes^ [default_attribute_index].key := jmc$job_deferred_by_operator;
      default_attribute_changes^ [default_attribute_index].
            job_deferred_by_operator := pvt [p$job_deferred_by_operator].value^.boolean_value.value;
    IFEND;

{  Process JOB_DESTINATION_USAGE parameter.

    IF pvt [p$job_destination_usage].specified THEN
      default_attribute_index := default_attribute_index + 1;
      default_attribute_changes^ [default_attribute_index].key := jmc$job_destination_usage;
      default_attribute_changes^ [default_attribute_index].
            job_destination_usage := pvt [p$job_destination_usage].value^.keyword_value;
    IFEND;

{  Process JOB_QUALIFIER parameter.

    IF pvt [p$job_qualifier].specified THEN
      default_attribute_index := default_attribute_index + 1;
      default_attribute_changes^ [default_attribute_index].key := jmc$job_qualifier_list;
      IF pvt [p$job_qualifier].value^.kind = clc$keyword THEN
        PUSH default_attribute_changes^ [default_attribute_index].job_qualifier_list: [1 .. 1];
        IF pvt [p$job_qualifier].value^.keyword_value = 'NONE' THEN
          default_attribute_changes^ [default_attribute_index].job_qualifier_list^ [1] := osc$null_name;
        ELSE { keyword_value = 'REQUIRED'}
          default_attribute_changes^ [default_attribute_index].job_qualifier_list^ [1] :=
                pvt [p$job_qualifier].value^.keyword_value;
        IFEND;
      ELSE
        list_count := clp$count_list_elements (pvt [p$job_qualifier].value);
        PUSH default_attribute_changes^ [default_attribute_index].job_qualifier_list: [1 .. list_count];
        qualifier_options := pvt [p$job_qualifier].value;
        FOR index := 1 TO list_count DO
          default_attribute_changes^ [default_attribute_index].job_qualifier_list^ [index] :=
                qualifier_options^.element_value^.name_value;
          qualifier_options := qualifier_options^.link;
        FOREND;
      IFEND;
    IFEND;

{  Process JOB_RECOVERY_DISPOSITION parameter.

    IF pvt [p$job_recovery_disposition].specified THEN
      default_attribute_index := default_attribute_index + 1;
      default_attribute_changes^ [default_attribute_index].key := jmc$job_recovery_disposition;
      IF pvt [p$job_recovery_disposition].value^.keyword_value = 'RESTART' THEN
        default_attribute_changes^ [default_attribute_index].job_recovery_disposition :=
              jmc$restart_on_recovery;
      ELSEIF pvt [p$job_recovery_disposition].value^.keyword_value = 'CONTINUE' THEN
        default_attribute_changes^ [default_attribute_index].job_recovery_disposition :=
              jmc$continue_on_recovery;
      ELSE { pvt [p$job_recovery_disposition].value^.keyword_value = 'TERMINATE'.
        default_attribute_changes^ [default_attribute_index].job_recovery_disposition :=
              jmc$terminate_on_recovery;
      IFEND;
    IFEND;

{  Process LOGIN_FAMILY parameter.

    IF pvt [p$login_family].specified THEN
      default_attribute_index := default_attribute_index + 1;
      default_attribute_changes^ [default_attribute_index].key := jmc$login_family;
      default_attribute_changes^ [default_attribute_index].login_family := pvt [p$login_family].
            value^.name_value;
    IFEND;

{  Process MAGNETIC_TAPE_LIMIT parameter.

    IF pvt [p$magnetic_tape_limit].specified THEN
      default_attribute_index := default_attribute_index + 1;
      default_attribute_changes^ [default_attribute_index].key := jmc$magnetic_tape_limit;
      IF pvt [p$magnetic_tape_limit].value^.kind = clc$integer THEN
        default_attribute_changes^ [default_attribute_index].
              magnetic_tape_limit := pvt [p$magnetic_tape_limit].value^.integer_value.value;
      ELSE
        IF pvt [p$magnetic_tape_limit].value^.keyword_value = 'UNSPECIFIED' THEN
          default_attribute_changes^ [default_attribute_index].magnetic_tape_limit :=
                jmc$unspecified_mag_tape_limit;
        ELSEIF pvt [p$magnetic_tape_limit].value^.keyword_value = 'REQUIRED' THEN
          default_attribute_changes^ [default_attribute_index].magnetic_tape_limit :=
                jmc$required_mag_tape_limit;
        ELSE { pvt [p$magnetic_tape_limit].value^.keyword_value = 'UNLIMITED'.
          default_attribute_changes^ [default_attribute_index].magnetic_tape_limit :=
                jmc$unlimited_mag_tape_limit;
        IFEND;
      IFEND;
    IFEND;

{  Process MAXIMUM_WORKING_SET parameter.

    IF pvt [p$maximum_working_set].specified THEN
      default_attribute_index := default_attribute_index + 1;
      default_attribute_changes^ [default_attribute_index].key := jmc$maximum_working_set;
      IF pvt [p$maximum_working_set].value^.kind = clc$integer THEN
        default_attribute_changes^ [default_attribute_index].
              maximum_working_set := pvt [p$maximum_working_set].value^.integer_value.value;
      ELSE
        IF pvt [p$maximum_working_set].value^.keyword_value = 'REQUIRED' THEN
          default_attribute_changes^ [default_attribute_index].maximum_working_set :=
                jmc$required_working_set_size;
        ELSE { pvt [p$maximum_working_set].value^.keyword_value = 'UNLIMITED'.
          default_attribute_changes^ [default_attribute_index].maximum_working_set :=
                jmc$unlimited_working_set_size;
        IFEND;
      IFEND;
    IFEND;

{  Process OUTPUT_CLASS parameter.

    IF pvt [p$output_class].specified THEN
      default_attribute_index := default_attribute_index + 1;
      default_attribute_changes^ [default_attribute_index].key := jmc$output_class;
      default_attribute_changes^ [default_attribute_index].output_class := pvt [p$output_class].
            value^.name_value;
    IFEND;

{  Process OUTPUT_DEFERRED_BY_OPERATOR parameter.

    IF pvt [p$output_deferred_by_operator].specified THEN
      default_attribute_index := default_attribute_index + 1;
      default_attribute_changes^ [default_attribute_index].key := jmc$output_deferred_by_operator;
      default_attribute_changes^ [default_attribute_index].
            output_deferred_by_operator := pvt [p$output_deferred_by_operator].value^.boolean_value.value;
    IFEND;

{  Process OUTPUT_DESTINATION_USAGE parameter.

    IF pvt [p$output_destination_usage].specified THEN
      default_attribute_index := default_attribute_index + 1;
      default_attribute_changes^ [default_attribute_index].key := jmc$output_destination_usage;
      IF pvt [p$output_destination_usage].value^.kind = clc$name THEN
        default_attribute_changes^ [default_attribute_index].
              output_destination_usage := pvt [p$output_destination_usage].value^.name_value;
      ELSE
        default_attribute_changes^ [default_attribute_index].
              output_destination_usage := pvt [p$output_destination_usage].value^.keyword_value;
      IFEND;
    IFEND;

{  Process PURGE_DELAY parameter.

    IF pvt [p$purge_delay].specified THEN
      default_attribute_index := default_attribute_index + 1;
      default_attribute_changes^ [default_attribute_index].key := jmc$purge_delay;
      PUSH default_attribute_changes^ [default_attribute_index].purge_delay;
      IF pvt [p$purge_delay].value^.kind = clc$keyword THEN { the only keyword allowed is NONE. }
        default_attribute_changes^ [default_attribute_index].purge_delay^.specified := FALSE;
      ELSE
        default_attribute_changes^ [default_attribute_index].purge_delay^.specified := TRUE;
        default_attribute_changes^ [default_attribute_index].
              purge_delay^.time_increment := pvt [p$purge_delay].value^.time_increment_value^;
      IFEND;
    IFEND;

{  Process SITE_INFORMATION parameter.

    IF pvt [p$site_information].specified THEN
      default_attribute_index := default_attribute_index + 1;
      default_attribute_changes^ [default_attribute_index].key := jmc$site_information;
      PUSH default_attribute_changes^ [default_attribute_index].site_information;
      default_attribute_changes^ [default_attribute_index].site_information^ := pvt [p$site_information].
            value^.string_value^;
    IFEND;

{  Process SRU_LIMIT parameter.

    IF pvt [p$sru_limit].specified THEN
      default_attribute_index := default_attribute_index + 1;
      default_attribute_changes^ [default_attribute_index].key := jmc$sru_limit;
      IF pvt [p$sru_limit].value^.kind = clc$integer THEN
        default_attribute_changes^ [default_attribute_index].sru_limit := pvt [p$sru_limit].
              value^.integer_value.value;
      ELSE
        IF pvt [p$sru_limit].value^.keyword_value = 'REQUIRED' THEN
          default_attribute_changes^ [default_attribute_index].sru_limit := jmc$required_sru_limit;
        ELSE { pvt [p$sru_limit].value^.keyword_value = 'UNLIMITED'.
          default_attribute_changes^ [default_attribute_index].sru_limit := jmc$unlimited_sru_limit;
        IFEND;
      IFEND;
    IFEND;

{  Process STATION parameter.

    IF pvt [p$station].specified THEN
      default_attribute_index := default_attribute_index + 1;
      default_attribute_changes^ [default_attribute_index].key := jmc$station;
      default_attribute_changes^ [default_attribute_index].station := pvt [p$station].value^.name_value;
    IFEND;

{  Process VERTICAL_PRINT_DENSITY parameter.

    IF pvt [p$vertical_print_density].specified THEN
      default_attribute_index := default_attribute_index + 1;
      default_attribute_changes^ [default_attribute_index].key := jmc$vertical_print_density;
      IF pvt [p$vertical_print_density].value^.keyword_value = 'FILE' THEN
        default_attribute_changes^ [default_attribute_index].vertical_print_density :=
              jmc$vertical_print_density_file;
      ELSEIF pvt [p$vertical_print_density].value^.keyword_value = 'NONE' THEN
        default_attribute_changes^ [default_attribute_index].vertical_print_density :=
              jmc$vertical_print_density_none;
      ELSEIF pvt [p$vertical_print_density].value^.keyword_value = 'SIX' THEN
        default_attribute_changes^ [default_attribute_index].vertical_print_density :=
              jmc$vertical_print_density_6;
      ELSE { pvt [p$vertical_print_density].value^.keyword_value = 'EIGHT'
        default_attribute_changes^ [default_attribute_index].vertical_print_density :=
              jmc$vertical_print_density_8;
      IFEND;
    IFEND;

{  Process JOB_MODE parameter.

    change_batch := FALSE;
    change_interactive := FALSE;

    IF pvt [p$job_mode].value^.kind = clc$keyword THEN { the only keyword allowed is ALL. }
      change_batch := TRUE;
      change_interactive := TRUE;
    ELSE
      set_list := pvt [p$job_mode].value;
      WHILE set_list <> NIL DO
        IF set_list^.element_value^.keyword_value = 'BATCH' THEN
          change_batch := TRUE;
        ELSE { set_list^.element_value^.keyword_value = 'INTERACTIVE' THEN
          change_interactive := TRUE;
        IFEND;
        set_list := set_list^.link;
      WHILEND;
    IFEND;

    IF change_batch THEN
      jmp$change_attribute_defaults (jmc$batch, default_attribute_changes, status);
    IFEND;

    IF status.normal AND change_interactive THEN
      jmp$change_attribute_defaults (jmc$interactive_connected, default_attribute_changes, status);
    IFEND;
  PROCEND clp$change_job_attr_default_cmd;
?? TITLE := '[XDCL] jmp$change_job_name_counter', EJECT ??

  PROCEDURE [XDCL] jmp$change_job_name_counter
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{ PROCEDURE change_job_name_counter (
{   counter, c: name jmc$long_ssn_size..jmc$long_ssn_size = $required
{   status)

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

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 3] of clt$pdt_parameter_name,
      parameters: array [1 .. 2] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
        qualifier: clt$name_type_qualifier,
      recend,
      type2: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [104, 9, 30, 11, 37, 11, 990],
    clc$command, 3, 2, 1, 0, 0, 0, 2, ''], [
    ['C                              ',clc$abbreviation_entry, 1],
    ['COUNTER                        ',clc$nominal_entry, 1],
    ['STATUS                         ',clc$nominal_entry, 2]],
    [
{ PARAMETER 1
    [2, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 5, clc$required_parameter, 0
  , 0],
{ PARAMETER 2
    [3, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$name_type], [jmc$long_ssn_size, jmc$long_ssn_size]],
{ PARAMETER 2
    [[1, 0, clc$status_type]]];

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

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

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

    IF NOT jmp$system_job () THEN
      osp$set_status_abnormal ('JM', jme$must_be_system_job, 'jmp$change_job_name_counter', status);
      RETURN; {----->
    IFEND;

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

    jmp$set_system_sequence_number (pvt [p$counter].value^.name_value, status);

  PROCEND jmp$change_job_name_counter;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] jmp$_change_kill_job_action', EJECT ??

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

{ PROCEDURE (osm$sysou_chakja) change_kill_job_action, chakja (
{   kill_option, ko: any of
{       key
{         (kill_disabled, kd)
{       keyend
{       list of key
{         (operator_kill_enabled, oke)
{         (user_kill_enabled, uke)
{       keyend
{     anyend = $required
{   status)

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

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 3] of clt$pdt_parameter_name,
      parameters: array [1 .. 2] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 2] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$list_type_qualifier,
          element_type_spec: record
            header: clt$type_specification_header,
            qualifier: clt$keyword_type_qualifier,
            keyword_specs: array [1 .. 4] of clt$keyword_specification,
          recend,
        recend,
      recend,
      type2: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [89, 2, 3, 13, 30, 25, 12],
    clc$command, 3, 2, 1, 0, 0, 0, 2, 'OSM$SYSOU_CHAKJA'], [
    ['KILL_OPTION                    ',clc$nominal_entry, 1],
    ['KO                             ',clc$abbreviation_entry, 1],
    ['STATUS                         ',clc$nominal_entry, 2]],
    [
{ PARAMETER 1
    [1, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 272,
  clc$required_parameter, 0, 0],
{ PARAMETER 2
    [3, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$union_type], [[clc$keyword_type, clc$list_type],
    FALSE, 2],
    81, [[1, 0, clc$keyword_type], [2], [
      ['KD                             ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
      ['KILL_DISABLED                  ', clc$nominal_entry, clc$normal_usage_entry, 1]]
      ],
    171, [[1, 0, clc$list_type], [155, 1, clc$max_list_size, FALSE],
        [[1, 0, clc$keyword_type], [4], [
        ['OKE                            ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
        ['OPERATOR_KILL_ENABLED          ', clc$nominal_entry, clc$normal_usage_entry, 1],
        ['UKE                            ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
        ['USER_KILL_ENABLED              ', clc$nominal_entry, clc$normal_usage_entry, 2]]
        ]
      ]
    ],
{ PARAMETER 2
    [[1, 0, clc$status_type]]];

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

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

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

    VAR
      keyword_list: ^clt$data_value,
      terminate_job_action_set: jmt$terminate_job_action_set;

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

    IF pvt [p$kill_option].value^.kind = clc$keyword THEN

{ The only "keyword" value is KILL_DISABLED.  All other selections come  in as list of key.

      terminate_job_action_set := $jmt$terminate_job_action_set [jmc$tja_kill_disabled];
    ELSE
      terminate_job_action_set := $jmt$terminate_job_action_set [];
      keyword_list := pvt [p$kill_option].value;
      WHILE keyword_list <> NIL DO
        IF keyword_list^.element_value^.keyword_value = 'OPERATOR_KILL_ENABLED' THEN
          terminate_job_action_set := terminate_job_action_set +
                $jmt$terminate_job_action_set [jmc$tja_operator_kill_enabled];
        ELSE { IF keyword_list^.element_value^.keyword_value = 'USER_KILL_ENABLED' THEN
          terminate_job_action_set := terminate_job_action_set +
                $jmt$terminate_job_action_set [jmc$tja_user_kill_enabled];
        IFEND;
        keyword_list := keyword_list^.link;
      WHILEND;
    IFEND;

    jmp$change_terminate_job_action (terminate_job_action_set, status);

  PROCEND jmp$_change_kill_job_action;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] clp$display_all_input_command', EJECT ??

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

{ PROCEDURE display_all_input (
{   user, u: any of
{       key
{         all
{       keyend
{       name
{     anyend = all
{   family_name, family, fn, f: any of
{       key
{         all
{       keyend
{       name
{     anyend = all
{   output, o: file = $output
{   display_option, display_options, do: any of
{       key
{         all
{       keyend
{       list of key
{         (control_family, cf)
{         (control_user, cu)
{         (cpu_time_used, ctu)
{         (display_message, dm)
{         (job_class, jc)
{         (job_class_position, jcp)
{         (job_destination_usage, jdu)
{         (job_initiation_time, jit)
{         (job_mode, jm)
{         (job_state, js)
{         (login_family, lf)
{         (login_user, lu)
{         (operator_action_posted, oap)
{         (page_faults, pf)
{         (system_job_name, sjn)
{         (user_job_name, ujn)
{       hidden_key
{         (client_mainframe_identifier, cmi)
{         (input_file_location, ifl)
{         (server_mainframe_identifier, smi)
{       keyend
{     anyend = (job_class, job_state, login_family, login_user, operator_action_posted, system_job_name)
{   status)

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

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 12] of clt$pdt_parameter_name,
      parameters: array [1 .. 5] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 1] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$name_type_qualifier,
        recend,
        default_value: string (3),
      recend,
      type2: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 1] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$name_type_qualifier,
        recend,
        default_value: string (3),
      recend,
      type3: record
        header: clt$type_specification_header,
        default_value: string (7),
      recend,
      type4: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 1] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$list_type_qualifier_v2,
          element_type_spec: record
            header: clt$type_specification_header,
            qualifier: clt$keyword_type_qualifier,
            keyword_specs: array [1 .. 38] of clt$keyword_specification,
          recend,
        recend,
        default_value: string (89),
      recend,
      type5: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [104, 9, 30, 12, 33, 46, 654],
    clc$command, 12, 5, 0, 0, 0, 0, 5, ''], [
    ['DISPLAY_OPTION                 ',clc$nominal_entry, 4],
    ['DISPLAY_OPTIONS                ',clc$alias_entry, 4],
    ['DO                             ',clc$abbreviation_entry, 4],
    ['F                              ',clc$abbreviation_entry, 2],
    ['FAMILY                         ',clc$alias_entry, 2],
    ['FAMILY_NAME                    ',clc$nominal_entry, 2],
    ['FN                             ',clc$alias_entry, 2],
    ['O                              ',clc$abbreviation_entry, 3],
    ['OUTPUT                         ',clc$nominal_entry, 3],
    ['STATUS                         ',clc$nominal_entry, 5],
    ['U                              ',clc$abbreviation_entry, 1],
    ['USER                           ',clc$nominal_entry, 1]],
    [
{ PARAMETER 1
    [12, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 69,
  clc$optional_default_parameter, 0, 3],
{ PARAMETER 2
    [6, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 69,
  clc$optional_default_parameter, 0, 3],
{ PARAMETER 3
    [9, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_default_parameter, 0, 7],
{ PARAMETER 4
    [1, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 1493,
  clc$optional_default_parameter, 0, 89],
{ PARAMETER 5
    [10, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$union_type], [[clc$keyword_type, clc$name_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['ALL                            ', clc$nominal_entry, clc$normal_usage_entry, 1]]
      ],
    5, [[1, 0, clc$name_type], [1, osc$max_name_size]]
    ,
    'all'],
{ PARAMETER 2
    [[1, 0, clc$union_type], [[clc$keyword_type, clc$name_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['ALL                            ', clc$nominal_entry, clc$normal_usage_entry, 1]]
      ],
    5, [[1, 0, clc$name_type], [1, osc$max_name_size]]
    ,
    'all'],
{ PARAMETER 3
    [[1, 0, clc$file_type],
    '$output'],
{ PARAMETER 4
    [[1, 0, clc$union_type], [[clc$keyword_type, clc$list_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['ALL                            ', clc$nominal_entry, clc$normal_usage_entry, 1]]
      ],
    1429, [[1, 0, clc$list_type], [1413, 1, clc$max_list_size, 0, FALSE, FALSE],
        [[1, 0, clc$keyword_type], [38], [
        ['CF                             ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
        ['CLIENT_MAINFRAME_IDENTIFIER    ', clc$nominal_entry, clc$hidden_entry, 17],
        ['CMI                            ', clc$abbreviation_entry, clc$hidden_entry, 17],
        ['CONTROL_FAMILY                 ', clc$nominal_entry, clc$normal_usage_entry, 1],
        ['CONTROL_USER                   ', clc$nominal_entry, clc$normal_usage_entry, 2],
        ['CPU_TIME_USED                  ', clc$nominal_entry, clc$normal_usage_entry, 3],
        ['CTU                            ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
        ['CU                             ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
        ['DISPLAY_MESSAGE                ', clc$nominal_entry, clc$normal_usage_entry, 4],
        ['DM                             ', clc$abbreviation_entry, clc$normal_usage_entry, 4],
        ['IFL                            ', clc$abbreviation_entry, clc$hidden_entry, 18],
        ['INPUT_FILE_LOCATION            ', clc$nominal_entry, clc$hidden_entry, 18],
        ['JC                             ', clc$abbreviation_entry, clc$normal_usage_entry, 5],
        ['JCP                            ', clc$abbreviation_entry, clc$normal_usage_entry, 6],
        ['JDU                            ', clc$abbreviation_entry, clc$normal_usage_entry, 7],
        ['JIT                            ', clc$abbreviation_entry, clc$normal_usage_entry, 8],
        ['JM                             ', clc$abbreviation_entry, clc$normal_usage_entry, 9],
        ['JOB_CLASS                      ', clc$nominal_entry, clc$normal_usage_entry, 5],
        ['JOB_CLASS_POSITION             ', clc$nominal_entry, clc$normal_usage_entry, 6],
        ['JOB_DESTINATION_USAGE          ', clc$nominal_entry, clc$normal_usage_entry, 7],
        ['JOB_INITIATION_TIME            ', clc$nominal_entry, clc$normal_usage_entry, 8],
        ['JOB_MODE                       ', 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],
        ['OAP                            ', clc$abbreviation_entry, clc$normal_usage_entry, 13],
        ['OPERATOR_ACTION_POSTED         ', clc$nominal_entry, clc$normal_usage_entry, 13],
        ['PAGE_FAULTS                    ', clc$nominal_entry, clc$normal_usage_entry, 14],
        ['PF                             ', clc$abbreviation_entry, clc$normal_usage_entry, 14],
        ['SERVER_MAINFRAME_IDENTIFIER    ', clc$nominal_entry, clc$hidden_entry, 19],
        ['SJN                            ', clc$abbreviation_entry, clc$normal_usage_entry, 15],
        ['SMI                            ', clc$abbreviation_entry, clc$hidden_entry, 19],
        ['SYSTEM_JOB_NAME                ', clc$nominal_entry, clc$normal_usage_entry, 15],
        ['UJN                            ', clc$abbreviation_entry, clc$normal_usage_entry, 16],
        ['USER_JOB_NAME                  ', clc$nominal_entry, clc$normal_usage_entry, 16]]
        ]
      ]
    ,
    '(job_class, job_state, login_family, login_user, operator_action_posted, system_job_name)'],
{ PARAMETER 5
    [[1, 0, clc$status_type]]];

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

    CONST
      p$user = 1,
      p$family_name = 2,
      p$output = 3,
      p$display_option = 4,
      p$status = 5;

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

    CONST
      maximum_get_keys = 16,
      non_duplicate_hidden_keys = 3;

    VAR
      attribute_key: jmt$attribute_keys,
      display_option_list: ^clt$data_value,
      get_attribute: jmt$attribute_keys,
      get_key_count: 0 .. maximum_get_keys + non_duplicate_hidden_keys,
      get_key_number: 0 .. maximum_get_keys + non_duplicate_hidden_keys,
      get_keys: jmt$attribute_keys_set,
      name_count: 0 .. clc$max_list_size,
      number_of_jobs_found: jmt$job_status_count,
      size_of_sequence: ost$segment_length,
      status_options_p: ^jmt$job_status_options,
      status_results_keys_p: ^jmt$results_keys,
      status_results_p: ^jmt$job_status_results,
      status_results_seq: ^SEQ ( * ),
      status_results_work_area_p: ^jmt$work_area;

?? NEWTITLE := 'add_to_attributes', EJECT ??

    PROCEDURE [INLINE] add_to_attributes
      (    get_attribute_key: jmt$attribute_keys);

      IF get_attribute_key IN get_keys THEN
        get_key_number := get_key_number + 1;
        status_results_keys_p^ [get_key_number] := get_attribute_key;
      IFEND;

    PROCEND add_to_attributes;
?? OLDTITLE ??
?? EJECT ??

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

{Job Status Options
    PUSH status_options_p: [1 .. 2];
    IF pvt [p$user].value^.kind = clc$keyword THEN
      status_options_p^ [1].key := jmc$null_attribute;
    ELSE
      status_options_p^ [1].key := jmc$login_user;
      status_options_p^ [1].login_user := pvt [p$user].value^.name_value;
    IFEND;

    IF pvt [p$family_name].value^.kind = clc$keyword THEN
      status_options_p^ [2].key := jmc$null_attribute;
    ELSE
      status_options_p^ [2].key := jmc$login_family;
      status_options_p^ [2].login_family := pvt [p$family_name].value^.name_value;
    IFEND;

{Result Keys
    get_keys := $jmt$attribute_keys_set [];
    IF pvt [p$display_option].value^.kind <> clc$keyword THEN
      display_option_list := pvt [p$display_option].value;
      WHILE display_option_list <> NIL DO
        jmp$get_attribute_index (display_option_list^.element_value^.keyword_value, get_attribute);
        IF NOT (get_attribute IN get_keys) THEN
          get_keys := get_keys + $jmt$attribute_keys_set [get_attribute];
        IFEND;
        display_option_list := display_option_list^.link;
      WHILEND;

    ELSE
      get_keys := $jmt$attribute_keys_set [jmc$control_family, jmc$control_user, jmc$cpu_time_used,
            jmc$display_message, jmc$job_class, jmc$job_class_position, jmc$job_destination_usage,
            jmc$job_initiation_time, jmc$job_mode, jmc$job_state, jmc$login_family, jmc$login_user,
            jmc$operator_action_posted, jmc$page_faults, jmc$system_job_name, jmc$user_job_name];
    IFEND;

    get_key_number := 0;
    get_key_count := 0;

    FOR attribute_key := LOWERVALUE (attribute_key) TO UPPERVALUE (attribute_key) DO
      IF attribute_key IN get_keys THEN
        get_key_count := get_key_count + 1;
      IFEND;
    FOREND;

    PUSH status_results_keys_p: [1 .. get_key_count];
    add_to_attributes (jmc$client_mainframe_id);
    add_to_attributes (jmc$control_family);
    add_to_attributes (jmc$control_user);
    add_to_attributes (jmc$cpu_time_used);
    add_to_attributes (jmc$display_message);
    add_to_attributes (jmc$input_file_location);
    add_to_attributes (jmc$job_class);
    add_to_attributes (jmc$job_class_position);
    add_to_attributes (jmc$job_destination_usage);
    add_to_attributes (jmc$job_initiation_time);
    add_to_attributes (jmc$job_mode);
    add_to_attributes (jmc$job_state);
    add_to_attributes (jmc$login_family);
    add_to_attributes (jmc$login_user);
    add_to_attributes (jmc$operator_action_posted);
    add_to_attributes (jmc$page_faults);
    add_to_attributes (jmc$server_mainframe_id);
    add_to_attributes (jmc$system_job_name);
    add_to_attributes (jmc$user_job_name);

    name_count := 5; {A Guess, the loop wil lensure the proper size.
    jmp$get_result_size (name_count * 2, #SEQ (status_results_keys_p^), size_of_sequence);
    PUSH status_results_work_area_p: [[REP size_of_sequence OF cell]];

    jmp$get_job_status (status_options_p, status_results_keys_p, status_results_work_area_p, status_results_p,
          number_of_jobs_found, status);

    WHILE (NOT status.normal) AND (status.condition = jme$work_area_too_small) DO
      status.normal := TRUE;
      jmp$get_result_size (number_of_jobs_found + 1, #SEQ (status_results_keys_p^), size_of_sequence);
      PUSH status_results_work_area_p: [[REP size_of_sequence OF cell]];
      jmp$get_job_status (status_options_p, status_results_keys_p, status_results_work_area_p,
            status_results_p, number_of_jobs_found, status);
    WHILEND;

    IF NOT status.normal THEN
      IF status.condition = jme$no_jobs_were_found THEN
        status.normal := TRUE;
        number_of_jobs_found := 0;
      ELSE
        RETURN; {----->
      IFEND;
    IFEND;

    status_results_seq := #SEQ (status_results_p);
    jmp$display_attributes (pvt [p$output].value^.file_value^, status_results_seq, number_of_jobs_found, NIL,
          NIL, 0, 'display_all_input', status);

  PROCEND clp$display_all_input_command;
?? TITLE := '[XDCL] clp$display_all_output_command', EJECT ??

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

{ PROCEDURE display_all_output (
{   user, u: any of
{       key
{         all
{       keyend
{       name
{     anyend = all
{   family_name, family, fn, f: any of
{       key
{         all
{       keyend
{       name
{     anyend = all
{   output, o: file = $output
{   status)

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

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 9] of clt$pdt_parameter_name,
      parameters: array [1 .. 4] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 1] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$name_type_qualifier,
        recend,
        default_value: string (3),
      recend,
      type2: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 1] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$name_type_qualifier,
        recend,
        default_value: string (3),
      recend,
      type3: record
        header: clt$type_specification_header,
        default_value: string (7),
      recend,
      type4: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [104, 9, 30, 11, 27, 36, 841],
    clc$command, 9, 4, 0, 0, 0, 0, 4, ''], [
    ['F                              ',clc$abbreviation_entry, 2],
    ['FAMILY                         ',clc$alias_entry, 2],
    ['FAMILY_NAME                    ',clc$nominal_entry, 2],
    ['FN                             ',clc$alias_entry, 2],
    ['O                              ',clc$abbreviation_entry, 3],
    ['OUTPUT                         ',clc$nominal_entry, 3],
    ['STATUS                         ',clc$nominal_entry, 4],
    ['U                              ',clc$abbreviation_entry, 1],
    ['USER                           ',clc$nominal_entry, 1]],
    [
{ PARAMETER 1
    [9, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 69,
  clc$optional_default_parameter, 0, 3],
{ PARAMETER 2
    [3, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 69,
  clc$optional_default_parameter, 0, 3],
{ PARAMETER 3
    [6, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_default_parameter, 0, 7],
{ PARAMETER 4
    [7, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$union_type], [[clc$keyword_type, clc$name_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['ALL                            ', clc$nominal_entry, clc$normal_usage_entry, 1]]
      ],
    5, [[1, 0, clc$name_type], [1, osc$max_name_size]]
    ,
    'all'],
{ PARAMETER 2
    [[1, 0, clc$union_type], [[clc$keyword_type, clc$name_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['ALL                            ', clc$nominal_entry, clc$normal_usage_entry, 1]]
      ],
    5, [[1, 0, clc$name_type], [1, osc$max_name_size]]
    ,
    'all'],
{ PARAMETER 3
    [[1, 0, clc$file_type],
    '$output'],
{ PARAMETER 4
    [[1, 0, clc$status_type]]];

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

    CONST
      p$user = 1,
      p$family_name = 2,
      p$output = 3,
      p$status = 4;

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

    VAR
      ignore_status: ost$status,
      output_status_count: jmt$output_status_count,
      output_status_options_p: ^jmt$output_status_options,
      output_status_results_p: ^jmt$output_status_results,
      output_status_results_seq: ^SEQ ( * ),
      segment_pointer: amt$segment_pointer,
      status_results_keys_p: ^jmt$results_keys;

?? NEWTITLE := 'handle_block_exit', EJECT ??

{ PURPOSE:
{   The purpose of this procedure is to deal with block exit conditions that arise.

    PROCEDURE handle_block_exit
      (    condition: pmt$condition;
           condition_information_p: ^pmt$condition_information;
           sfsa_p: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      VAR
        ignore_status: ost$status;

      IF segment_pointer.sequence_pointer <> NIL THEN
        mmp$delete_scratch_segment (segment_pointer, ignore_status);
      IFEND;
      IF status.normal THEN
        osp$set_status_from_condition ('JM', condition, sfsa_p, status, ignore_status);
      IFEND;
    PROCEND handle_block_exit;
?? OLDTITLE, EJECT ??

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

    segment_pointer.sequence_pointer := NIL;
    #SPOIL (segment_pointer.sequence_pointer);
    PUSH output_status_options_p: [1 .. 2];

    IF pvt [p$user].value^.kind = clc$keyword THEN
      output_status_options_p^ [1].key := jmc$null_attribute;
    ELSE
      output_status_options_p^ [1].key := jmc$login_user;
      output_status_options_p^ [1].login_user := pvt [p$user].value^.name_value;
    IFEND;

    IF pvt [p$family_name].value^.kind = clc$keyword THEN
      output_status_options_p^ [2].key := jmc$null_attribute;
    ELSE
      output_status_options_p^ [2].key := jmc$login_family;
      output_status_options_p^ [2].login_family := pvt [p$family_name].value^.name_value;
    IFEND;

    osp$establish_block_exit_hndlr (^handle_block_exit);
    mmp$create_scratch_segment (amc$sequence_pointer, mmc$as_sequential, segment_pointer, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;
    RESET segment_pointer.sequence_pointer;

    PUSH status_results_keys_p: [1 .. 3];
    status_results_keys_p^ [1] := jmc$system_file_name;
    status_results_keys_p^ [2] := jmc$system_job_name;
    status_results_keys_p^ [3] := jmc$user_file_name;

    jmp$get_output_status (output_status_options_p, status_results_keys_p, segment_pointer.sequence_pointer,
          output_status_results_p, output_status_count, status);
    IF NOT status.normal THEN
      IF status.condition = jme$no_outputs_were_found THEN
        status.normal := TRUE;
        output_status_count := 0;
      ELSE
        RETURN; {----->
      IFEND;
    IFEND;

    output_status_results_seq := #SEQ (output_status_results_p);
    jmp$display_attributes (pvt [p$output].value^.file_value^, output_status_results_seq, output_status_count,
          NIL, NIL, 0, 'display_all_output', status);

    mmp$delete_scratch_segment (segment_pointer, ignore_status);
    osp$disestablish_cond_handler;

  PROCEND clp$display_all_output_command;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] jmp$_display_kill_job_action', EJECT ??

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

{ PROCEDURE (osm$sysou_diskja) display_kill_job_action, diskja (
{   output, o: file = $OUTPUT
{   status)

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

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 3] of clt$pdt_parameter_name,
      parameters: array [1 .. 2] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
        default_value: string (7),
      recend,
      type2: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [89, 2, 3, 13, 46, 47, 764],
    clc$command, 3, 2, 0, 0, 0, 0, 2, 'OSM$SYSOU_DISKJA'], [
    ['O                              ',clc$abbreviation_entry, 1],
    ['OUTPUT                         ',clc$nominal_entry, 1],
    ['STATUS                         ',clc$nominal_entry, 2]],
    [
{ PARAMETER 1
    [2, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_default_parameter, 0, 7],
{ PARAMETER 2
    [3, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$file_type],
    '$OUTPUT'],
{ PARAMETER 2
    [[1, 0, clc$status_type]]];

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

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

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

    VAR
      kill_job_action_set_p: ^jmt$attribute_values,
      kill_job_action_set_pp: ^array [1 .. * ] of ^jmt$attribute_values,
      kill_job_action_set_seq_p: ^SEQ ( * ),
      terminate_job_action_set: jmt$terminate_job_action_set;

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

    PUSH kill_job_action_set_p: [1 .. 1];
    kill_job_action_set_p^ [1].key := jmc$terminate_job_action_set;
    jmp$get_terminate_job_action (kill_job_action_set_p^ [1].terminate_job_action_set, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    PUSH kill_job_action_set_pp: [1 .. 1];
    kill_job_action_set_pp^ [1] := kill_job_action_set_p;
    kill_job_action_set_seq_p := #SEQ (kill_job_action_set_pp);

{  Process OUTPUT parameter.
    jmp$display_attributes (pvt [p$output].value^.file_value^, kill_job_action_set_seq_p, 1, NIL, NIL, 0,
          'display_kill_job_action', status);

  PROCEND jmp$_display_kill_job_action;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL] clp$idle_jobs_command', EJECT ??

  PROCEDURE [XDCL] clp$idle_jobs_command
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{ PROCEDURE idle_jobs (
{   status)

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

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 1] of clt$pdt_parameter_name,
      parameters: array [1 .. 1] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [104, 9, 30, 11, 34, 33, 287],
    clc$command, 1, 1, 0, 0, 0, 0, 1, ''], [
    ['STATUS                         ',clc$nominal_entry, 1]],
    [
{ PARAMETER 1
    [1, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$status_type]]];

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

    CONST
      p$status = 1;

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

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

    jmp$idle_system (status);

  PROCEND clp$idle_jobs_command;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL] clp$resume_jobs_command', EJECT ??

  PROCEDURE [XDCL] clp$resume_jobs_command
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{ PROCEDURE resume_jobs (
{   status)

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

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 1] of clt$pdt_parameter_name,
      parameters: array [1 .. 1] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [104, 9, 30, 11, 35, 24, 201],
    clc$command, 1, 1, 0, 0, 0, 0, 1, ''], [
    ['STATUS                         ',clc$nominal_entry, 1]],
    [
{ PARAMETER 1
    [1, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$status_type]]];

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

    CONST
      p$status = 1;

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

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

    jmp$resume_system (status);

  PROCEND clp$resume_jobs_command;
MODEND jmm$operator_facility_commands;
