?? RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE: Job Management Job Attribute Interfaces' ??
MODULE jmm$job_attribute_manager;

{ PURPOSE:
{   This module contains the job attribute management interfaces.  These interfaces control job attributes
{ as well as the system's job attribute defaults.
{
{ DESIGN:
{   The program interfaces contained in this module are designed in such a fashion that binary
{ compatability can be maintained.  Any change to the size of a record element in a variant record
{ will result in an interface breakage.  These procedures operate in rings 2 and 3 with a call bracket
{ of ring 13.
{
{   This module contains procedures to change and retrieve job attributes.  The change interfaces make
{ a local copy of their caller supplied inputs, validate them for accuracy and call a lower ring interface
{ to change the attributes.  The attribute retrieval interface uses its ring 3 privilege to gain access to
{ the values that it needs.  Since it executes in rings 2 or 3, it has access to all system variables - this
{ allows this interface to directly reference the attribute requested, irrespective of its residency.

?? NEWTITLE := 'Global Declarations Referenced by this Module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc ave$validation_interface_errors
*copyc clc$standard_file_names
*copyc clt$value
*copyc cle$ecc_lexical
*copyc jmc$change_attribute_defaults
*copyc jmc$change_job_attributes
*copyc jmc$get_attribute_defaults
*copyc jmc$get_job_attributes
*copyc jmc$job_management_id
*copyc jme$job_monitor_conditions
*copyc jme$queued_file_conditions
*copyc jmt$default_attribute_changes
*copyc jmt$default_attribute_results
*copyc jmt$dispatching_control
*copyc jmt$job_attribute_changes
*copyc jmt$job_attribute_results
*copyc jmt$job_processing_phase
*copyc jmt$sense_switch_signal
*copyc ofe$error_codes
*copyc osd$virtual_address
*copyc oss$job_paged_literal
*copyc ost$name
*copyc ost$status
*copyc tmc$signal_identifiers
*copyc tmt$change_priority_origin
?? POP ??

*copyc avp$configuration_administrator
*copyc avp$system_operator
*copyc clp$convert_string_to_file_ref
*copyc clp$get_processing_phase
*copyc clp$validate_name
*copyc jmf$ijle_p
*copyc jmp$convert_string_to_disp_pr
*copyc jmp$determine_dis_priority_name
*copyc jmp$determine_job_class_name
*copyc jmp$determine_name_kind
*copyc jmp$general_purpose_cluster_rpc
*copyc jmp$get_attribute_name
*copyc jmp$get_job_ijl_ordinal
*copyc jmp$get_job_internal_info
*copyc jmp$get_job_status
*copyc jmp$get_result_size
*copyc jmp$queue_operator_request
*copyc jmp$set_job_attributes
*copyc jmp$system_job
*copyc osp$append_status_parameter
*copyc osp$set_status_abnormal
*copyc osp$set_status_condition
*copyc pmp$get_job_names
*copyc pmp$get_os_version
*copyc pmp$get_170_os_type
*copyc pmp$manage_sense_switches
*copyc pmp$send_signal
*copyc qfp$change_attribute_defaults
*copyc qfp$change_job_rcv_disposition
*copyc avv$account_name
*copyc avv$project_name
*copyc jmv$default_job_attributes
*copyc jmv$ijl_p
*copyc jmv$jcb
*copyc jmv$job_attributes
*copyc jmv$job_class_table_p
*copyc jmv$job_execution_attributes
*copyc jmv$kjl_p
*copyc jmv$kjlx_p
*copyc jmv$service_classes
*copyc jmv$system_ijl_ordinal
?? TITLE := 'Global Declarations Declared by This Module', EJECT ??

  VAR
    job_processing_phase_mask: [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];

?? TITLE := 'jmp$change_attribute_defaults', EJECT ??
*copy jmh$change_attribute_defaults

  PROCEDURE [XDCL, #GATE] jmp$change_attribute_defaults
    (    job_mode: jmt$job_mode;
         default_attribute_changes: ^jmt$default_attribute_changes;
     VAR status: ost$status);

    VAR
      job_qualifier_index: 1 .. jmc$maximum_job_qualifiers,
      local_status: ost$status,
      option_index: integer,
      scl_name: ost$name,
      valid_attribute_changes_p: ^jmt$default_attribute_changes,
      valid_job_mode: jmt$job_mode,
      valid_name: boolean;

    status.normal := TRUE;
    local_status.normal := TRUE;

    IF NOT avp$configuration_administrator () THEN
      osp$set_status_abnormal ('OF', ofe$sou_not_active, 'configuration_administration', status);
      RETURN;
    IFEND;

    IF job_mode = jmc$batch THEN
      valid_job_mode := jmc$batch;
    ELSE
      valid_job_mode := jmc$interactive_connected;
    IFEND;

    IF default_attribute_changes <> NIL THEN
      PUSH valid_attribute_changes_p: [1 .. UPPERBOUND (default_attribute_changes^)];

    /validate_attribute_changes/
      FOR option_index := 1 TO UPPERBOUND (valid_attribute_changes_p^) DO
        valid_attribute_changes_p^ [option_index].key := default_attribute_changes^ [option_index].key;
        CASE default_attribute_changes^ [option_index].key OF
        = jmc$cpu_time_limit =
          valid_attribute_changes_p^ [option_index].cpu_time_limit :=
                default_attribute_changes^ [option_index].cpu_time_limit;

        = jmc$job_abort_disposition =
          valid_attribute_changes_p^ [option_index].job_abort_disposition :=
                default_attribute_changes^ [option_index].job_abort_disposition;

        = jmc$job_class =
          clp$validate_name (default_attribute_changes^ [option_index].job_class, scl_name, valid_name);
          IF NOT valid_name THEN
            osp$set_status_abnormal ('CL', cle$improper_name,
                  default_attribute_changes^ [option_index].job_class, local_status);
            EXIT /validate_attribute_changes/;
          IFEND;
          valid_attribute_changes_p^ [option_index].job_class := scl_name;

        = jmc$job_deferred_by_operator =
          valid_attribute_changes_p^ [option_index].job_deferred_by_operator :=
                default_attribute_changes^ [option_index].job_deferred_by_operator;

        = jmc$job_destination_usage =
          clp$validate_name (default_attribute_changes^ [option_index].job_destination_usage, scl_name,
                valid_name);
          IF NOT valid_name THEN
            osp$set_status_abnormal ('CL', cle$improper_name,
                  default_attribute_changes^ [option_index].job_destination_usage, local_status);
            EXIT /validate_attribute_changes/;
          IFEND;
          valid_attribute_changes_p^ [option_index].job_destination_usage := scl_name;

        = jmc$job_qualifier_list =
          PUSH valid_attribute_changes_p^ [option_index].job_qualifier_list:
                [1 .. jmc$maximum_job_qualifiers];
          FOR job_qualifier_index := 1 TO jmc$maximum_job_qualifiers DO
            IF (default_attribute_changes^ [option_index].job_qualifier_list <> NIL) AND
                  (UPPERBOUND (default_attribute_changes^ [option_index].job_qualifier_list^) >=
                  job_qualifier_index) THEN
              IF default_attribute_changes^ [option_index].job_qualifier_list^ [job_qualifier_index] =
                    osc$null_name THEN
                scl_name := osc$null_name;
              ELSE
                clp$validate_name (default_attribute_changes^ [option_index].
                      job_qualifier_list^ [job_qualifier_index], scl_name, valid_name);
                IF NOT valid_name THEN
                  osp$set_status_abnormal ('CL', cle$improper_name,
                        default_attribute_changes^ [option_index].job_qualifier_list^ [job_qualifier_index],
                        local_status);
                  EXIT /validate_attribute_changes/;
                IFEND;
              IFEND;
              valid_attribute_changes_p^ [option_index].job_qualifier_list^ [job_qualifier_index] := scl_name;
            ELSE
              valid_attribute_changes_p^ [option_index].job_qualifier_list^ [job_qualifier_index] :=
                    osc$null_name;
            IFEND;
          FOREND;

        = jmc$job_recovery_disposition =
          valid_attribute_changes_p^ [option_index].job_recovery_disposition :=
                default_attribute_changes^ [option_index].job_recovery_disposition;

        = jmc$login_family =
          clp$validate_name (default_attribute_changes^ [option_index].login_family, scl_name, valid_name);
          IF NOT valid_name THEN
            osp$set_status_abnormal ('CL', cle$improper_name,
                  default_attribute_changes^ [option_index].login_family, local_status);
            EXIT /validate_attribute_changes/;
          IFEND;
          valid_attribute_changes_p^ [option_index].login_family := scl_name;

        = jmc$magnetic_tape_limit =
          valid_attribute_changes_p^ [option_index].magnetic_tape_limit :=
                default_attribute_changes^ [option_index].magnetic_tape_limit;

        = jmc$maximum_working_set =
          valid_attribute_changes_p^ [option_index].maximum_working_set :=
                default_attribute_changes^ [option_index].maximum_working_set;

        = jmc$null_attribute =
          ;

        = jmc$output_class =
          clp$validate_name (default_attribute_changes^ [option_index].output_class, scl_name, valid_name);
          IF NOT valid_name THEN
            osp$set_status_abnormal ('CL', cle$improper_name,
                  default_attribute_changes^ [option_index].output_class, local_status);
            EXIT /validate_attribute_changes/;
          IFEND;
          valid_attribute_changes_p^ [option_index].output_class := scl_name;

        = jmc$output_deferred_by_operator =
          valid_attribute_changes_p^ [option_index].output_deferred_by_operator :=
                default_attribute_changes^ [option_index].output_deferred_by_operator;

        = jmc$output_destination_usage =
          clp$validate_name (default_attribute_changes^ [option_index].output_destination_usage, scl_name,
                valid_name);
          IF NOT valid_name THEN
            osp$set_status_abnormal ('CL', cle$improper_name,
                  default_attribute_changes^ [option_index].output_destination_usage, local_status);
            EXIT /validate_attribute_changes/;
          IFEND;
          valid_attribute_changes_p^ [option_index].output_destination_usage := scl_name;

        = jmc$purge_delay =
          PUSH valid_attribute_changes_p^ [option_index].purge_delay;
          valid_attribute_changes_p^ [option_index].purge_delay^ :=
                default_attribute_changes^ [option_index].purge_delay^;

        = jmc$deferred_by_operator =
          valid_attribute_changes_p^ [option_index].deferred_by_operator :=
                default_attribute_changes^ [option_index].deferred_by_operator;

        = jmc$site_information =
          PUSH valid_attribute_changes_p^ [option_index].site_information;
          valid_attribute_changes_p^ [option_index].site_information^ :=
                default_attribute_changes^ [option_index].site_information^;

        = jmc$sru_limit =
          valid_attribute_changes_p^ [option_index].sru_limit :=
                default_attribute_changes^ [option_index].sru_limit;

        = jmc$station =
          clp$validate_name (default_attribute_changes^ [option_index].station, scl_name, valid_name);
          IF NOT valid_name THEN
            osp$set_status_abnormal ('CL', cle$improper_name,
                  default_attribute_changes^ [option_index].station, local_status);
            EXIT /validate_attribute_changes/;
          IFEND;
          valid_attribute_changes_p^ [option_index].station := scl_name;

        = jmc$vertical_print_density =
          valid_attribute_changes_p^ [option_index].vertical_print_density :=
                default_attribute_changes^ [option_index].vertical_print_density;
        ELSE
          jmp$get_attribute_name (default_attribute_changes^ [option_index].key, scl_name);
          osp$set_status_abnormal (jmc$job_management_id, jme$invalid_parameter, scl_name, local_status);
          osp$append_status_parameter (osc$status_parameter_delimiter, 'DEFAULT_ATTRIBUTE_CHANGES',
                local_status);
          osp$append_status_parameter (osc$status_parameter_delimiter, jmc$change_attribute_defaults,
                local_status);
          EXIT /validate_attribute_changes/;
        CASEND;
      FOREND /validate_attribute_changes/;
    ELSE

      valid_attribute_changes_p := NIL;
    IFEND;

    IF local_status.normal AND (valid_attribute_changes_p <> NIL) THEN
      qfp$change_attribute_defaults (valid_job_mode, valid_attribute_changes_p, local_status);
    IFEND;
    IF NOT local_status.normal THEN
      status := local_status;
    IFEND;

  PROCEND jmp$change_attribute_defaults;
?? TITLE := 'jmp$change_job_attributes', EJECT ??
*copyc jmh$change_job_attributes

{
{ NOTES:
{   The use of DISPATCHING_PRIORITY for the system job has been disabled.
{   For the System Job the follow attributes are not bound to the range specified by the minimum and maximum
{   of the system_job_class attributes:      CYCLIC_AGING_INTERVAL
{                                            MAXIMUM_WORKING_SET
{                                            MINIMUM_WORKING_SET
{                                            PAGE_AGING_INTERVAL
{

  PROCEDURE [XDCL, #GATE] jmp$change_job_attributes
    (    job_attribute_changes: ^jmt$job_attribute_changes;
     VAR status: ost$status);

    TYPE
      processing_phase_set = set of clt$processing_phase;

    VAR
      attribute_index: integer,
      attribute_value: integer,
      dummy_priority: jmt$dispatching_priority,
      local_status: ost$status,
      job_class: jmt$job_class,
      maximum_working_set: jmt$working_set_size,
      minimum_working_set: jmt$working_set_size,
      parsed_file_reference: fst$parsed_file_reference,
      processing_phase: clt$processing_phase,
      scl_name: ost$name,
      service_class: jmt$service_class_index,
      valid_attribute_changes_p: ^jmt$job_attribute_changes,
      valid_name: boolean;

    status.normal := TRUE;
    local_status.normal := TRUE;

    job_class := jmv$kjl_p^ [jmv$jcb.job_id].job_class;
    maximum_working_set := jmv$job_execution_attributes.maximum_working_set;
    minimum_working_set := jmv$job_execution_attributes.minimum_working_set;
    service_class := jmv$job_class_table_p^ [job_class].initial_service_class_index;

    IF job_attribute_changes <> NIL THEN
      PUSH valid_attribute_changes_p: [1 .. UPPERBOUND (job_attribute_changes^)];

    /validate_attribute_changes/
      FOR attribute_index := 1 TO UPPERBOUND (valid_attribute_changes_p^) DO
        valid_attribute_changes_p^ [attribute_index].key := job_attribute_changes^ [attribute_index].key;
        CASE job_attribute_changes^ [attribute_index].key OF
        = jmc$comment_banner =
          valid_attribute_changes_p^ [attribute_index].comment_banner :=
                job_attribute_changes^ [attribute_index].comment_banner;

        = jmc$copies =
          valid_attribute_changes_p^ [attribute_index].copies :=
                job_attribute_changes^ [attribute_index].copies;

        = jmc$cyclic_aging_interval =
          attribute_value := job_attribute_changes^ [attribute_index].cyclic_aging_interval;

{JSE: This will need to change when job scheduling enhancements are done.

          IF NOT (jmp$system_job ()) THEN {The SYSTEM JOB is not bound by the "system" job class attributes
            IF (jmv$job_class_table_p^ [job_class].cyclic_aging_interval.minimum > attribute_value) OR
                  (jmv$job_class_table_p^ [job_class].cyclic_aging_interval.maximum < attribute_value) THEN
              osp$set_status_abnormal (jmc$job_management_id, jme$value_out_of_range, 'CYCLIC_AGING_INTERVAL',
                    local_status);
              EXIT /validate_attribute_changes/;
            IFEND;
          IFEND;
          valid_attribute_changes_p^ [attribute_index].cyclic_aging_interval := attribute_value;

        = jmc$detached_job_wait_time =
          attribute_value := job_attribute_changes^ [attribute_index].detached_job_wait_time;

{JSE: This will need to change when job scheduling enhancements are done.

          IF (jmv$job_class_table_p^ [job_class].detached_job_wait_time.minimum > attribute_value) OR
                (jmv$job_class_table_p^ [job_class].detached_job_wait_time.maximum < attribute_value) THEN
            osp$set_status_abnormal (jmc$job_management_id, jme$value_out_of_range, 'DETACHED_JOB_WAIT_TIME',
                  local_status);
            EXIT /validate_attribute_changes/;
          IFEND;
          valid_attribute_changes_p^ [attribute_index].detached_job_wait_time := attribute_value;

        = jmc$device =
          IF job_attribute_changes^ [attribute_index].device <> osc$null_name THEN
            clp$validate_name (job_attribute_changes^ [attribute_index].device, scl_name, valid_name);
            IF NOT valid_name THEN
              osp$set_status_abnormal ('CL', cle$improper_name,
                    job_attribute_changes^ [attribute_index].device, local_status);
              EXIT /validate_attribute_changes/;
            IFEND;
          ELSE
            scl_name := osc$null_name;
          IFEND;
          valid_attribute_changes_p^ [attribute_index].device := scl_name;

        = jmc$dispatching_priority =
          IF jmp$system_job () THEN
            osp$set_status_abnormal (jmc$job_management_id, jme$illegal_system_job_command,
                  'Specifying DISPATCHING_PRIORITY for the CHANGE_JOB_ATTRIBUTES', local_status);
            EXIT /validate_attribute_changes/;
          ELSE
            clp$validate_name (job_attribute_changes^ [attribute_index].dispatching_priority, scl_name,
                  valid_name);
            IF NOT valid_name THEN
              osp$set_status_abnormal ('CL', cle$improper_name,
                    job_attribute_changes^ [attribute_index].dispatching_priority, local_status);
              EXIT /validate_attribute_changes/;
            IFEND;

            jmp$convert_string_to_disp_pr (scl_name, dummy_priority, local_status);
            IF NOT local_status.normal THEN
              EXIT /validate_attribute_changes/;
            IFEND;

            valid_attribute_changes_p^ [attribute_index].dispatching_priority := scl_name;
          IFEND;

        = jmc$earliest_print_time =
          valid_attribute_changes_p^ [attribute_index].earliest_print_time :=
                job_attribute_changes^ [attribute_index].earliest_print_time;

        = jmc$external_characteristics =
          #TRANSLATE (osv$lower_to_upper, job_attribute_changes^ [attribute_index].external_characteristics,
                valid_attribute_changes_p^ [attribute_index].external_characteristics);

        = jmc$forms_code =
          #TRANSLATE (osv$lower_to_upper, job_attribute_changes^ [attribute_index].forms_code,
                valid_attribute_changes_p^ [attribute_index].forms_code);

        = jmc$job_abort_disposition =
          valid_attribute_changes_p^ [attribute_index].job_abort_disposition :=
                job_attribute_changes^ [attribute_index].job_abort_disposition;

        = jmc$job_recovery_disposition =
          valid_attribute_changes_p^ [attribute_index].job_recovery_disposition :=
                job_attribute_changes^ [attribute_index].job_recovery_disposition;

        = jmc$latest_print_time =
          valid_attribute_changes_p^ [attribute_index].latest_print_time :=
                job_attribute_changes^ [attribute_index].latest_print_time;

        = jmc$maximum_working_set =
          maximum_working_set := job_attribute_changes^ [attribute_index].maximum_working_set;

{JSE: This will need to change when job scheduling enhancements are done.

          IF NOT (jmp$system_job ()) THEN {The SYSTEM JOB is not bound by the "system" job class attributes
            IF (jmv$job_class_table_p^ [job_class].maximum_working_set.minimum > maximum_working_set) OR
                  (jmv$job_class_table_p^ [job_class].maximum_working_set.maximum < maximum_working_set) THEN
              osp$set_status_abnormal (jmc$job_management_id, jme$value_out_of_range, 'MAXIMUM_WORKING_SET',
                    local_status);
              EXIT /validate_attribute_changes/;
            IFEND;
          IFEND;
          valid_attribute_changes_p^ [attribute_index].maximum_working_set := maximum_working_set;

        = jmc$minimum_working_set =
          minimum_working_set := job_attribute_changes^ [attribute_index].minimum_working_set;

{JSE: This will need to change when job scheduling enhancements are done.

          IF NOT (jmp$system_job ()) THEN {The SYSTEM JOB is not bound by the "system" job class attributes
            IF (jmv$job_class_table_p^ [job_class].minimum_working_set.minimum > minimum_working_set) OR
                  (jmv$job_class_table_p^ [job_class].minimum_working_set.maximum < minimum_working_set) THEN
              osp$set_status_abnormal (jmc$job_management_id, jme$value_out_of_range, 'MINIMUM_WORKING_SET',
                    local_status);
              EXIT /validate_attribute_changes/;
            IFEND;
          IFEND;
          valid_attribute_changes_p^ [attribute_index].minimum_working_set := minimum_working_set;

        = jmc$null_attribute =
          ;

        = jmc$output_class =
          IF job_attribute_changes^ [attribute_index].output_class <> osc$null_name THEN
            clp$validate_name (job_attribute_changes^ [attribute_index].output_class, scl_name, valid_name);
            IF NOT valid_name THEN
              osp$set_status_abnormal ('CL', cle$improper_name,
                    job_attribute_changes^ [attribute_index].output_class, local_status);
              EXIT /validate_attribute_changes/;
            IFEND;
          ELSE
            scl_name := osc$null_name;
          IFEND;
          valid_attribute_changes_p^ [attribute_index].output_class := scl_name;

        = jmc$output_deferred_by_user =
          valid_attribute_changes_p^ [attribute_index].output_deferred_by_user :=
                job_attribute_changes^ [attribute_index].output_deferred_by_user;

        = jmc$output_destination =
          #TRANSLATE (osv$lower_to_upper, job_attribute_changes^ [attribute_index].output_destination,
                valid_attribute_changes_p^ [attribute_index].output_destination);

        = jmc$output_destination_family =
          clp$validate_name (job_attribute_changes^ [attribute_index].output_destination_family, scl_name,
                valid_name);
          IF NOT valid_name THEN
            osp$set_status_abnormal ('CL', cle$improper_name,
                  job_attribute_changes^ [attribute_index].output_destination_family, local_status);
            EXIT /validate_attribute_changes/;
          IFEND;
          valid_attribute_changes_p^ [attribute_index].output_destination_family := scl_name;

        = jmc$output_destination_usage =
          clp$validate_name (job_attribute_changes^ [attribute_index].output_destination_usage, scl_name,
                valid_name);
          IF NOT valid_name THEN
            osp$set_status_abnormal ('CL', cle$improper_name,
                  job_attribute_changes^ [attribute_index].output_destination_usage, local_status);
            EXIT /validate_attribute_changes/;
          IFEND;
          valid_attribute_changes_p^ [attribute_index].output_destination_usage := scl_name;

        = jmc$output_disposition =
          valid_attribute_changes_p^ [attribute_index].output_disposition :=
                job_attribute_changes^ [attribute_index].output_disposition;
          IF (valid_attribute_changes_p^ [attribute_index].output_disposition.key = jmc$standard_output_path)
                THEN
            clp$convert_string_to_file_ref (job_attribute_changes^ [attribute_index].output_disposition.
                  standard_output_path^, parsed_file_reference, local_status);
            IF NOT local_status.normal THEN
              EXIT /validate_attribute_changes/;
            IFEND;

            IF parsed_file_reference.path (parsed_file_reference.first_name.index,
                  parsed_file_reference.first_name.size) = '$LOCAL' THEN
              osp$set_status_condition (jme$permanent_file_required, local_status);
              EXIT /validate_attribute_changes/;
            IFEND;

            PUSH valid_attribute_changes_p^ [attribute_index].output_disposition.standard_output_path;
            valid_attribute_changes_p^ [attribute_index].output_disposition.standard_output_path^ :=
                  parsed_file_reference.path (1, parsed_file_reference.complete_path_size);
          IFEND;

        = jmc$output_priority =
          IF job_attribute_changes^ [attribute_index].output_priority <> osc$null_name THEN
            clp$validate_name (job_attribute_changes^ [attribute_index].output_priority, scl_name,
                  valid_name);
            IF NOT valid_name THEN
              osp$set_status_abnormal ('CL', cle$improper_name,
                    job_attribute_changes^ [attribute_index].output_priority, local_status);
              EXIT /validate_attribute_changes/;
            IFEND;
          ELSE
            scl_name := osc$null_name;
          IFEND;
          valid_attribute_changes_p^ [attribute_index].output_priority := scl_name;

        = jmc$page_aging_interval =
          attribute_value := job_attribute_changes^ [attribute_index].page_aging_interval;

{JSE: This will need to change when job scheduling enhancements are done.

          IF NOT (jmp$system_job ()) THEN {The SYSTEM JOB is not bound by the "system" job class attributes
            IF (jmv$job_class_table_p^ [job_class].page_aging_interval.minimum > attribute_value) OR
                  (jmv$job_class_table_p^ [job_class].page_aging_interval.maximum < attribute_value) THEN
              osp$set_status_abnormal (jmc$job_management_id, jme$value_out_of_range, 'PAGE_AGING_INTERVAL',
                    local_status);
              EXIT /validate_attribute_changes/;
            IFEND;
          IFEND;
          valid_attribute_changes_p^ [attribute_index].page_aging_interval := attribute_value;

        = jmc$purge_delay =
          PUSH valid_attribute_changes_p^ [attribute_index].purge_delay;
          valid_attribute_changes_p^ [attribute_index].purge_delay^ :=
                job_attribute_changes^ [attribute_index].purge_delay^;

        = jmc$remote_host_directive =
          PUSH valid_attribute_changes_p^ [attribute_index].remote_host_directive;
          valid_attribute_changes_p^ [attribute_index].remote_host_directive^ :=
                job_attribute_changes^ [attribute_index].remote_host_directive^;

        = jmc$routing_banner =
          valid_attribute_changes_p^ [attribute_index].routing_banner :=
                job_attribute_changes^ [attribute_index].routing_banner;

        = jmc$site_information =
          clp$get_processing_phase (processing_phase, {ignore} local_status);
          IF processing_phase IN $processing_phase_set [clc$system_prolog_phase, clc$class_prolog_phase,
                clc$account_prolog_phase, clc$project_prolog_phase, clc$project_epilog_phase,
                clc$account_epilog_phase, clc$class_epilog_phase, clc$system_epilog_phase] THEN
            PUSH valid_attribute_changes_p^ [attribute_index].site_information;
            valid_attribute_changes_p^ [attribute_index].site_information^ :=
                  job_attribute_changes^ [attribute_index].site_information^;
          ELSE
            osp$set_status_condition (ave$insufficient_authority, local_status);
            EXIT /validate_attribute_changes/;
          IFEND;

        = jmc$station =
          IF job_attribute_changes^ [attribute_index].station <> osc$null_name THEN
            clp$validate_name (job_attribute_changes^ [attribute_index].station, scl_name, valid_name);
            IF NOT valid_name THEN
              osp$set_status_abnormal ('CL', cle$improper_name,
                    job_attribute_changes^ [attribute_index].station, local_status);
              EXIT /validate_attribute_changes/;
            IFEND;
          ELSE
            scl_name := osc$null_name;
          IFEND;
          valid_attribute_changes_p^ [attribute_index].station := scl_name;

        = jmc$station_operator =
          clp$validate_name (job_attribute_changes^ [attribute_index].station_operator, scl_name, valid_name);
          IF NOT valid_name THEN
            osp$set_status_abnormal ('CL', cle$improper_name,
                  job_attribute_changes^ [attribute_index].station_operator, local_status);
            EXIT /validate_attribute_changes/;
          IFEND;
          valid_attribute_changes_p^ [attribute_index].station_operator := scl_name;

        = jmc$user_information =
          PUSH valid_attribute_changes_p^ [attribute_index].user_information;
          valid_attribute_changes_p^ [attribute_index].user_information^ :=
                job_attribute_changes^ [attribute_index].user_information^;

        = jmc$vertical_print_density =
          valid_attribute_changes_p^ [attribute_index].vertical_print_density :=
                job_attribute_changes^ [attribute_index].vertical_print_density;

        = jmc$vfu_load_procedure =
          IF job_attribute_changes^ [attribute_index].vfu_load_procedure <> osc$null_name THEN
            clp$validate_name (job_attribute_changes^ [attribute_index].vfu_load_procedure, scl_name,
                  valid_name);
            IF NOT valid_name THEN
              osp$set_status_abnormal ('CL', cle$improper_name,
                    job_attribute_changes^ [attribute_index].vfu_load_procedure, local_status);
              EXIT /validate_attribute_changes/;
            IFEND;
          ELSE
            scl_name := osc$null_name;
          IFEND;
          valid_attribute_changes_p^ [attribute_index].vfu_load_procedure := scl_name;

        ELSE
          jmp$get_attribute_name (job_attribute_changes^ [attribute_index].key, scl_name);
          osp$set_status_abnormal (jmc$job_management_id, jme$invalid_parameter, scl_name, local_status);
          osp$append_status_parameter (osc$status_parameter_delimiter, 'JOB_ATTRIBUTE_CHANGES', local_status);
          osp$append_status_parameter (osc$status_parameter_delimiter, jmc$change_job_attributes,
                local_status);
          EXIT /validate_attribute_changes/;

        CASEND;
      FOREND /validate_attribute_changes/;

{ Check to make sure that the working set sizes are compatible

      IF local_status.normal AND (minimum_working_set > maximum_working_set) THEN
        osp$set_status_abnormal (jmc$job_management_id, jme$invalid_working_set_size, '', local_status);
      IFEND;

      IF local_status.normal THEN
        jmp$set_job_attributes (valid_attribute_changes_p, local_status);
      IFEND;
    IFEND;
    IF NOT local_status.normal THEN
      status := local_status;
    IFEND;

  PROCEND jmp$change_job_attributes;

?? TITLE := 'JMP$CHANGE_DISPATCHING_PRIORITY', EJECT ??

{
{ NOTE:
{   This command is illegal for the system_job.
{

  PROCEDURE [XDCL, #GATE] jmp$change_dispatching_priority
    (    job_name: clt$value;
         dispatching_priority: jmt$dispatching_priority;
     VAR status: ost$status);

    VAR
      ijl_ordinal: jmt$ijl_ordinal,
      privileged_job: boolean,
      system_supplied_name: jmt$system_supplied_name;

    status.normal := TRUE;
    privileged_job := avp$system_operator ();

    IF NOT privileged_job THEN
      osp$set_status_abnormal ('OF', ofe$sou_not_active, 'system_operation', status);
      RETURN;
    IFEND;

    jmp$get_job_ijl_ordinal (job_name.name.value, privileged_job, ijl_ordinal, system_supplied_name, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    IF (ijl_ordinal = jmv$system_ijl_ordinal) THEN
      osp$set_status_abnormal (jmc$job_management_id, jme$illegal_system_job_command,
            'CHANGE_PRIORITY job_name = $AAA_0000', status);
    ELSE
      jmp$queue_operator_request (jmc$or_change_dispatching_prio, ijl_ordinal, system_supplied_name,
            dispatching_priority, {disable_recovery} FALSE, status);
    IFEND;
  PROCEND jmp$change_dispatching_priority;
?? TITLE := 'jmp$change_job_rcv_disposition', EJECT ??

  PROCEDURE [XDCL, #GATE] jmp$change_job_rcv_disposition
    (    new_job_recovery_disposition: jmt$job_recovery_disposition;
     VAR old_job_recovery_disposition: jmt$job_recovery_disposition);

    qfp$change_job_rcv_disposition (new_job_recovery_disposition, old_job_recovery_disposition);

  PROCEND jmp$change_job_rcv_disposition;
?? TITLE := 'jmp$get_attribute_defaults', EJECT ??
*copyc jmh$get_attribute_defaults

  PROCEDURE [XDCL, #GATE] jmp$get_attribute_defaults
    (    job_mode: jmt$job_mode;
         default_attribute_results: ^jmt$default_attribute_results;
     VAR status: ost$status);

    VAR
      attribute_index: integer,
      job_qualifier_index: integer,
      scl_name: ost$name,
      valid_job_mode: jmt$job_mode;

    status.normal := TRUE;

    IF job_mode = jmc$batch THEN
      valid_job_mode := jmc$batch;
    ELSE
      valid_job_mode := jmc$interactive_connected;
    IFEND;
    IF default_attribute_results <> NIL THEN

    /assign_requested_attributes/
      FOR attribute_index := 1 TO UPPERBOUND (default_attribute_results^) DO
        CASE default_attribute_results^ [attribute_index].key OF
        = jmc$cpu_time_limit =
          default_attribute_results^ [attribute_index].cpu_time_limit :=
                jmv$default_job_attributes [valid_job_mode].cpu_time_limit;

        = jmc$job_abort_disposition =
          default_attribute_results^ [attribute_index].job_abort_disposition :=
                jmv$default_job_attributes [valid_job_mode].job_abort_disposition;

        = jmc$job_deferred_by_operator =
          default_attribute_results^ [attribute_index].job_deferred_by_operator :=
                jmv$default_job_attributes [valid_job_mode].job_deferred_by_operator;

        = jmc$job_class =
          default_attribute_results^ [attribute_index].job_class :=
                jmv$default_job_attributes [valid_job_mode].job_class;

        = jmc$job_destination_usage =
          default_attribute_results^ [attribute_index].job_destination_usage :=
                jmv$default_job_attributes [valid_job_mode].job_destination_usage;

        = jmc$job_qualifier_list =
          IF default_attribute_results^ [attribute_index].job_qualifier_list <> NIL THEN
            FOR job_qualifier_index := 1 TO UPPERBOUND (default_attribute_results^ [attribute_index].
                  job_qualifier_list^) DO
              IF job_qualifier_index <= jmc$maximum_job_qualifiers THEN
                default_attribute_results^ [attribute_index].job_qualifier_list^ [job_qualifier_index] :=
                      jmv$default_job_attributes [valid_job_mode].job_qualifier_list [job_qualifier_index];
              ELSE
                default_attribute_results^ [attribute_index].job_qualifier_list^ [job_qualifier_index] :=
                      osc$null_name;
              IFEND;
            FOREND;
          IFEND;

        = jmc$job_recovery_disposition =
          default_attribute_results^ [attribute_index].job_recovery_disposition :=
                jmv$default_job_attributes [valid_job_mode].job_recovery_disposition;

        = jmc$login_family =
          default_attribute_results^ [attribute_index].login_family :=
                jmv$default_job_attributes [valid_job_mode].login_family;

        = jmc$magnetic_tape_limit =
          default_attribute_results^ [attribute_index].magnetic_tape_limit :=
                jmv$default_job_attributes [valid_job_mode].magnetic_tape_limit;

        = jmc$maximum_working_set =
          default_attribute_results^ [attribute_index].maximum_working_set :=
                jmv$default_job_attributes [valid_job_mode].maximum_working_set;

        = jmc$null_attribute =
          ;

        = jmc$output_class =
          default_attribute_results^ [attribute_index].output_class :=
                jmv$default_job_attributes [valid_job_mode].output_class;

        = jmc$output_deferred_by_operator =
          default_attribute_results^ [attribute_index].output_deferred_by_operator :=
                jmv$default_job_attributes [valid_job_mode].output_deferred_by_operator;

        = jmc$output_destination_usage =
          default_attribute_results^ [attribute_index].output_destination_usage :=
                jmv$default_job_attributes [valid_job_mode].output_destination_usage;

        = jmc$purge_delay =
          default_attribute_results^ [attribute_index].purge_delay^ :=
                jmv$default_job_attributes [valid_job_mode].purge_delay;

        = jmc$deferred_by_operator =
          default_attribute_results^ [attribute_index].deferred_by_operator :=
                jmv$default_job_attributes [valid_job_mode].qfile_deferred_by_operator;

        = jmc$site_information =
          default_attribute_results^ [attribute_index].site_information^ :=
                jmv$default_job_attributes [valid_job_mode].site_information;

        = jmc$sru_limit =
          default_attribute_results^ [attribute_index].sru_limit :=
                jmv$default_job_attributes [valid_job_mode].sru_limit;

        = jmc$station =
          default_attribute_results^ [attribute_index].station :=
                jmv$default_job_attributes [valid_job_mode].station;

        = jmc$vertical_print_density =
          default_attribute_results^ [attribute_index].vertical_print_density :=
                jmv$default_job_attributes [valid_job_mode].vertical_print_density;
        ELSE
          jmp$get_attribute_name (default_attribute_results^ [attribute_index].key, scl_name);
          osp$set_status_abnormal (jmc$job_management_id, jme$invalid_parameter, scl_name, status);
          osp$append_status_parameter (osc$status_parameter_delimiter, 'DEFAULT_ATTRIBUTE_RESULTS', status);
          osp$append_status_parameter (osc$status_parameter_delimiter, jmc$get_attribute_defaults, status);
          EXIT /assign_requested_attributes/;
        CASEND;
      FOREND /assign_requested_attributes/;
    IFEND;

  PROCEND jmp$get_attribute_defaults;
?? TITLE := 'jmp$get_job_attributes', EJECT ??
*copyc jmh$get_job_attributes

  PROCEDURE [XDCL, #GATE] jmp$get_job_attributes
    (    job_attribute_results: ^jmt$job_attribute_results;
     VAR status: ost$status);

    VAR
      attribute_index: integer,
      ignore_status: ost$status,
      job_qualifier_index: integer,
      processing_phase: clt$processing_phase,
      scl_name: ost$name;

    status.normal := TRUE;
    ignore_status.normal := TRUE;

    IF job_attribute_results <> NIL THEN

    /assign_requested_attributes/
      FOR attribute_index := 1 TO UPPERBOUND (job_attribute_results^) DO
        CASE job_attribute_results^ [attribute_index].key OF
        = jmc$c170_os_type =
          pmp$get_170_os_type (job_attribute_results^ [attribute_index].c170_os_type, ignore_status);

        = jmc$comment_banner =
          job_attribute_results^ [attribute_index].comment_banner := jmv$job_attributes.comment_banner;

        = jmc$control_family =
          job_attribute_results^ [attribute_index].control_family := jmv$job_attributes.job_controller.family;

        = jmc$control_user =
          job_attribute_results^ [attribute_index].control_user := jmv$job_attributes.job_controller.user;

        = jmc$copies =
          job_attribute_results^ [attribute_index].copies := jmv$job_attributes.copy_count;

        = jmc$cyclic_aging_interval =
          job_attribute_results^ [attribute_index].cyclic_aging_interval :=
                jmv$job_execution_attributes.cyclic_aging_interval;

        = jmc$detached_job_wait_time =
          job_attribute_results^ [attribute_index].detached_job_wait_time := jmv$jcb.detached_job_wait_time;

        = jmc$device =
          job_attribute_results^ [attribute_index].device := jmv$job_attributes.device;

        = jmc$dispatching_priority =
          jmp$determine_dis_priority_name (jmv$jcb.ijle_p^.dispatching_control.dispatching_priority,
                job_attribute_results^ [attribute_index].dispatching_priority, ignore_status);

        = jmc$earliest_print_time =
          job_attribute_results^ [attribute_index].earliest_print_time :=
                jmv$job_attributes.earliest_print_time;

        = jmc$earliest_run_time =
          job_attribute_results^ [attribute_index].earliest_run_time := jmv$job_attributes.earliest_run_time;

        = jmc$external_characteristics =
          job_attribute_results^ [attribute_index].external_characteristics :=
                jmv$job_attributes.external_characteristics;

        = jmc$forms_code =
          job_attribute_results^ [attribute_index].forms_code := jmv$job_attributes.forms_code;

        = jmc$job_abort_disposition =
          job_attribute_results^ [attribute_index].job_abort_disposition :=
                jmf$ijle_p (jmv$kjl_p^ [jmv$jcb.job_id].initiated_job_list_ordinal) ^.queue_file_information.
                job_abort_disposition;

        = jmc$job_class =
          jmp$determine_job_class_name (jmv$kjl_p^ [jmv$jcb.job_id].
                job_class, job_attribute_results^ [attribute_index].job_class, ignore_status);

        = jmc$job_input_device =
          job_attribute_results^ [attribute_index].job_input_device^ := jmv$job_attributes.job_input_device;

        = jmc$job_mode =
          job_attribute_results^ [attribute_index].job_mode := jmv$jcb.ijle_p^.job_mode;

        = jmc$job_qualifier_list =
          IF job_attribute_results^ [attribute_index].job_qualifier_list <> NIL THEN
            FOR job_qualifier_index := 1 TO UPPERBOUND (job_attribute_results^ [attribute_index].
                  job_qualifier_list^) DO
              IF job_qualifier_index <= jmc$maximum_job_qualifiers THEN
                job_attribute_results^ [attribute_index].job_qualifier_list^ [job_qualifier_index] :=
                      jmv$job_attributes.job_qualifier_list [job_qualifier_index];
              ELSE
                job_attribute_results^ [attribute_index].job_qualifier_list^ [job_qualifier_index] :=
                      osc$null_name;
              IFEND;
            FOREND;
          IFEND;

        = jmc$job_recovery_disposition =
          job_attribute_results^ [attribute_index].job_recovery_disposition :=
                jmf$ijle_p (jmv$kjl_p^ [jmv$jcb.job_id].initiated_job_list_ordinal)^.queue_file_information.
                job_recovery_disposition;

        = jmc$job_size =
          job_attribute_results^ [attribute_index].job_size := jmv$job_attributes.job_size;

        = jmc$job_submission_time =
          job_attribute_results^ [attribute_index].job_submission_time :=
                jmv$job_attributes.job_submission_time;

        = jmc$latest_print_time =
          job_attribute_results^ [attribute_index].latest_print_time := jmv$job_attributes.latest_print_time;

        = jmc$latest_run_time =
          job_attribute_results^ [attribute_index].latest_run_time := jmv$job_attributes.latest_run_time;

        = jmc$login_account =
          job_attribute_results^ [attribute_index].login_account := avv$account_name;

        = jmc$login_family =
          job_attribute_results^ [attribute_index].login_family := jmv$jcb.user_id.family;

        = jmc$login_project =
          job_attribute_results^ [attribute_index].login_project := avv$project_name;

        = jmc$login_user =
          job_attribute_results^ [attribute_index].login_user := jmv$jcb.user_id.user;

        = jmc$maximum_working_set =
          job_attribute_results^ [attribute_index].maximum_working_set :=
                jmv$job_execution_attributes.maximum_working_set;

        = jmc$minimum_working_set =
          job_attribute_results^ [attribute_index].minimum_working_set :=
                jmv$job_execution_attributes.minimum_working_set;

        = jmc$null_attribute =
          ;

        = jmc$operator_job =
          job_attribute_results^ [attribute_index].operator_job := jmp$system_job ();

        = jmc$origin_application_name =
          job_attribute_results^ [attribute_index].origin_application_name :=
                jmv$job_attributes.originating_application_name;

        = jmc$os_version =
          pmp$get_os_version (job_attribute_results^ [attribute_index].os_version, ignore_status);

        = jmc$output_class =
          job_attribute_results^ [attribute_index].output_class := jmv$job_attributes.output_class;

        = jmc$output_deferred_by_user =
          job_attribute_results^ [attribute_index].output_deferred_by_user :=
                jmv$job_attributes.output_deferred_by_user;

        = jmc$output_destination =
          job_attribute_results^ [attribute_index].output_destination :=
                jmv$job_attributes.output_destination;

        = jmc$output_destination_family =
          job_attribute_results^ [attribute_index].output_destination_family :=
                jmv$job_attributes.output_destination_family;

        = jmc$output_destination_usage =
          job_attribute_results^ [attribute_index].output_destination_usage :=
                jmv$job_attributes.output_destination_usage;

        = jmc$output_disposition =
          job_attribute_results^ [attribute_index].output_disposition.key :=
                jmv$kjlx_p^ [jmv$jcb.job_id].output_disposition_key;
          IF jmv$kjlx_p^ [jmv$jcb.job_id].output_disposition_key = jmc$standard_output_path THEN
            job_attribute_results^ [attribute_index].output_disposition.standard_output_path^ :=
                  jmv$job_attributes.output_disposition_path;
          IFEND;

        = jmc$output_priority =
          job_attribute_results^ [attribute_index].output_priority := jmv$job_attributes.output_priority;

        = jmc$page_aging_interval =
          job_attribute_results^ [attribute_index].page_aging_interval :=
                jmv$job_execution_attributes.page_aging_interval;

        = jmc$processing_phase =
          clp$get_processing_phase (processing_phase, ignore_status);
          job_attribute_results^ [attribute_index].processing_phase :=
                job_processing_phase_mask [processing_phase];

        = jmc$purge_delay =
          job_attribute_results^ [attribute_index].purge_delay^ := jmv$job_attributes.purge_delay;

        = jmc$remote_host_directive =
          job_attribute_results^ [attribute_index].remote_host_directive^ :=
                jmv$job_attributes.remote_host_directive;

        = jmc$routing_banner =
          job_attribute_results^ [attribute_index].routing_banner := jmv$job_attributes.routing_banner;

        = jmc$sense_switches =
          job_attribute_results^ [attribute_index].sense_switches := jmv$jcb.sense_switches;

        = jmc$service_class =
          job_attribute_results^ [attribute_index].service_class :=
                jmv$service_classes [jmf$ijle_p (jmv$kjl_p^ [jmv$jcb.job_id].initiated_job_list_ordinal)^.
                job_scheduler_data.service_class]^.attributes.name;

        = jmc$site_information =
          job_attribute_results^ [attribute_index].site_information^ := jmv$job_attributes.site_information;

        = jmc$station =
          job_attribute_results^ [attribute_index].station := jmv$job_attributes.station;

        = jmc$station_operator =
          job_attribute_results^ [attribute_index].station_operator := jmv$job_attributes.station_operator;

        = jmc$system_job =
          job_attribute_results^ [attribute_index].system_job := jmp$system_job ();

        = jmc$system_job_name =
          job_attribute_results^ [attribute_index].system_job_name := jmv$jcb.system_name;

        = jmc$user_information =
          job_attribute_results^ [attribute_index].user_information^ := jmv$job_attributes.user_information;

        = jmc$user_job_name =
          job_attribute_results^ [attribute_index].user_job_name := jmv$jcb.jobname;

        = jmc$vertical_print_density =
          job_attribute_results^ [attribute_index].vertical_print_density :=
                jmv$job_attributes.vertical_print_density;

        = jmc$vfu_load_procedure =
          job_attribute_results^ [attribute_index].vfu_load_procedure :=
                jmv$job_attributes.vfu_load_procedure;

        ELSE
          jmp$get_attribute_name (job_attribute_results^ [attribute_index].key, scl_name);
          osp$set_status_abnormal (jmc$job_management_id, jme$invalid_parameter, scl_name, status);
          osp$append_status_parameter (osc$status_parameter_delimiter, 'JOB_ATTRIBUTES_RESULTS', status);
          osp$append_status_parameter (osc$status_parameter_delimiter, jmc$get_job_attributes, status);
          EXIT /assign_requested_attributes/;

        CASEND;
      FOREND /assign_requested_attributes/;
    IFEND;

  PROCEND jmp$get_job_attributes;


?? TITLE := '    JMP$GET_JOB_PARAMETERS', EJECT ??

  PROCEDURE [XDCL] jmp$get_job_parameters
    (VAR job_parameters: jmt$system_job_parameters;
     VAR status: ost$status);

    status.normal := TRUE;
    job_parameters := jmv$job_attributes.system_job_parameters;

  PROCEND jmp$get_job_parameters;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] jmp$switch_command_r3', EJECT ??
*copyc jmh$switch_command_r3

  PROCEDURE [XDCL, #GATE] jmp$switch_command_r3
    (    name: string ( * <= osc$max_name_size);
         ON: pmt$sense_switches;
         OFF: pmt$sense_switches;
     VAR status: ost$status);

    VAR
      caller_ssn: jmt$system_supplied_name,
      caller_ujn: jmt$user_supplied_name,
      converted_name: jmt$name,
      jm_work_area_p: ^jmt$work_area,
      job_info: jmt$job_internal_information,
      job_status_results_keys_p: ^jmt$results_keys,
      job_status_results_seq_p: ^jmt$work_area,
      job_status_options_p: ^jmt$job_status_options,
      job_status_results_p: ^jmt$job_status_results,
      local_off_switches_p: ^pmt$sense_switches,
      local_on_switches_p: ^pmt$sense_switches,
      local_system_job_name_p: ^jmt$system_supplied_name,
      mainframes_processed: jmt$rpc_mainframes_processed,
      number_of_data_packets: ost$non_negative_integers,
      number_of_jobs_found: jmt$job_count_range,
      privileged_job: boolean,
      results: pmt$sense_switches,
      size_of_sequence: ost$segment_length,
      target_mainframe_reached: boolean,
      target_options_p: ^SEQ ( * );

    status.normal := TRUE;

    privileged_job := avp$system_operator ();
    jmp$determine_name_kind (name, converted_name, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    PUSH job_status_options_p: [1 .. 3];
    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] := converted_name;
    job_status_options_p^ [2].key := jmc$privilege;
    IF privileged_job THEN
      job_status_options_p^ [2].privilege := jmc$privileged;
    ELSE
      job_status_options_p^ [2].privilege := jmc$not_privileged;
    IFEND;
    job_status_options_p^ [3].key := jmc$continue_request_to_servers;
    job_status_options_p^ [3].continue_request_to_servers := TRUE;

    PUSH job_status_results_keys_p: [1 .. 2];
    job_status_results_keys_p^ [1] := jmc$system_job_name;
    job_status_results_keys_p^ [2] := jmc$client_mainframe_id;

    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]];

{ If we are able to status the input file, we have control over the file
{ so we can change the attributes of the file

    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 number_of_jobs_found = 0 THEN
      osp$set_status_abnormal (jmc$job_management_id, jme$name_not_found, name, status);
    ELSEIF number_of_jobs_found > 1 THEN
      osp$set_status_abnormal (jmc$job_management_id, jme$duplicate_name, name, status);
    IFEND;
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    pmp$get_job_names (caller_ujn, caller_ssn, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    IF job_status_results_p^ [1]^ [1].system_job_name = caller_ssn THEN
      pmp$manage_sense_switches (ON, OFF, results, status);
    ELSE

{ Set the sense switches in the job by using the general purpose cluster RPC request.

      PUSH target_options_p: [[REP (#SIZE (jmt$system_supplied_name) + #SIZE (pmt$sense_switches) +
            #SIZE (pmt$sense_switches)) OF cell]];
      RESET target_options_p;
      NEXT local_system_job_name_p IN target_options_p;
      local_system_job_name_p^ := job_status_results_p^ [1]^ [1].system_job_name;
      NEXT local_on_switches_p IN target_options_p;
      local_on_switches_p^ := ON;
      NEXT local_off_switches_p IN target_options_p;
      local_off_switches_p^ := OFF;
      mainframes_processed.count := 0;
      jm_work_area_p := NIL;

      jmp$general_purpose_cluster_rpc (job_status_results_p^ [1]^ [2].client_mainframe_id,
            jmc$gpro_set_sense_switches, {data_packet_size} 0, mainframes_processed, target_options_p,
            jm_work_area_p, target_mainframe_reached, mainframes_processed, number_of_data_packets, status);
    IFEND;

  PROCEND jmp$switch_command_r3;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL] jmp$mainframe_set_sense_switch', EJECT ??
*copy jmh$mainframe_set_sense_switch

  PROCEDURE [XDCL] jmp$mainframe_set_sense_switch
    (    target_options_p: ^SEQ ( * );
     VAR data_area_p: {input, output} ^SEQ ( * );
     VAR number_of_data_packets: ost$non_negative_integers;
     VAR status: ost$status);

    VAR
      job_info: jmt$job_internal_information,
      local_off_switches_p: ^pmt$sense_switches,
      local_on_switches_p: ^pmt$sense_switches,
      local_system_job_name_p: ^jmt$system_supplied_name,
      options_p: ^SEQ ( * ),
      signal: pmt$signal,
      signal_contents_p: ^jmt$sense_switch_signal;

    status.normal := TRUE;
    number_of_data_packets := 0;
    options_p := target_options_p;
    RESET options_p;
    NEXT local_system_job_name_p IN options_p;
    NEXT local_on_switches_p IN options_p;
    NEXT local_off_switches_p IN options_p;
    jmp$get_job_internal_info (local_system_job_name_p^, job_info, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    signal.identifier := jmc$sense_switch_signal_id;
    signal_contents_p := #LOC (signal.contents);
    signal_contents_p^. ON := local_on_switches_p^;
    signal_contents_p^. OFF := local_off_switches_p^;
    pmp$send_signal (job_info.jmtr_global_taskid, signal, status);
  PROCEND jmp$mainframe_set_sense_switch;
?? OLDTITLE ??
MODEND jmm$job_attribute_manager;
