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

{ PURPOSE:
{   This module contains the interfaces that physically set a job's attributes, both as a result of job
{   initiation and as a result of a user changing a job's attributes directly or through the initiation
{   of an application for which special scheduling is done.
{
{ DESIGN:
{   These procedures operate in ring 2 with a call bracket of 3.  When a job's attributes are changed
{ the ring 2 interface jmp$set_job_attributes is called.  This procedure will directly change the Job
{ Pageable job attribute structure and will call a ring one interface to change the other job attributes.
{
{   When a job initiates its job attributes are initialized by the procedure jmp$initialize_job_attributes.
{ This procedure will take the values from the job's system label built by jmp$submit_job.  If the job is
{ the system job that "becomes" at deadstart the values used are a pre-defined set.
{
{   The ring 2 interface jmp$set_application_scheduling is called when an application starts that has
{ special scheduling requirements.  This call overrides the job attributes that need to be changed while
{ the application is executing.  The job attributes are restored when the application completes by
{ calling jmp$end_application_scheduling.  When an attribute is overridden by application scheduling
{ the jmp$set_job_attributes call will only change the pageable copy of the attribute and not call the
{ ring one interface.

?? NEWTITLE := 'Global Declarations Referenced by this Module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc jmc$class_names
*copyc jmc$system_family
*copyc jme$queued_file_conditions
*copyc jmt$application_attributes
*copyc jmt$job_attribute_changes
*copyc jmt$job_attributes
*copyc jmt$job_execution_attributes
*copyc jmt$job_system_label
*copyc jmt$rb_scheduler_requests
*copyc osc$deadstart
*copyc osc$xterm_application_name
*copyc oss$job_pageable
*copyc ost$status
?? POP ??

*copyc jmp$get_ijle_p
*copyc osp$clear_job_signature_lock
*copyc osp$initialize_sig_lock
*copyc osp$set_job_signature_lock
*copyc qfp$discard_job_output
*copyc qfp$set_job_attributes
*copyc jmv$default_job_attributes
*copyc jmv$ijl_p
*copyc jmv$jcb
*copyc jmv$job_class_table_p
*copyc jmv$kjl_p
*copyc jmv$kjlx_p
*copyc jmv$service_classes
*copyc jmv$xterm_job

?? TITLE := 'Global Variables Declared by this Module', EJECT ??

{ The job attribute structure is statically initialized only to present a reasonable set of
{ attributes for an output file if a job should abort early during job begin.  This is not
{ expected to happen often, but is necessary to indicate the file'e existance.

?? FMT (FORMAT := OFF) ??
  VAR
    jmv$job_attributes: [XDCL, #GATE, oss$job_pageable] jmt$job_attributes := [
         { comment_banner } 'SYSTEM_ERROR - See Site Info',
         { copy_count } 1,
         { device } 'AUTOMATIC',
         { earliest_run_time } [FALSE],
         { earliest_print_time } [FALSE],
         { external_characteristics } 'NORMAL',
         { forms_code } 'NORMAL',
         { implicit_routing_text} [0, ''],
         { job_controller } [jmc$system_user, jmc$system_family],
         { job_initiation_time } [0, 1, 1, 0, 0, 0, 0],
         { job_input_device } [0, ''],
         { job_qualifier_list } [REP jmc$maximum_job_qualifiers OF osc$null_name],
         { job_size } 0,
         { job_submission_time } *,
         { latest_run_time } [FALSE],
         { latest_print_time } [FALSE],
         { login_command_supplied } TRUE,
         { originating_application_name } 'OSA$JOB_BEGIN',
         { originating_ssn } jmc$full_system_supplied_name,
         { output_class } 'NORMAL',
         { output_deferred_by_user } FALSE,
         { output_destination } '',
         { output_destination_family } jmc$system_family,
         { output_destination_usage } 'SYSTEM_ERROR',
         { output_disposition_key } jmc$normal_output_disposition,
         { output_disposition_path } '',
         { output_priority } 'LOW',
         { processor_user_prolog_and_epilog } TRUE,
         { purge_delay } [FALSE],
         { remote_host_directive } [0, ''],
         { routing_banner } 'SYSTEM_ERROR - See Site Info',
         { source_logical_id } '',
         { site_information } 'The job has aborted as part of initiation.  The job attributes have not ' CAT
                              'been initialized.  The Job Log in the standard output file contains the ' CAT
                              'status of the initiation failure.  To print this file change the OUTPUT_' CAT
                              'DESTINATION_USAGE.',
         { station } 'AUTOMATIC',
         { station_operator } jmc$system_user,
         { system_job_parameters } [0, ''],
         { system_routing_text } [0, ''],
         { user_information } 'A system error occured during job initiation.  See Site_Information ' CAT
                              'for additional information.',
         { vertical_print_density } jmc$vertical_print_density_none,
         { vfu_load_procedure } osc$null_name];
?? FMT (FORMAT := ON) ??

  VAR
    jmv$job_disposition_code: [XDCL, #GATE, oss$job_pageable] jmt$disposition_code,
    jmv$job_execution_attributes: [XDCL, #GATE, oss$job_pageable] jmt$job_execution_attributes;

?? TITLE := 'jmp$end_application_scheduling', EJECT ??
*copyc jmh$end_application_scheduling

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

    VAR
      old_service_accumulator: jmt$service_accumulator,
      attribute: jmt$job_attribute_change;

    status.normal := TRUE;
    osp$set_job_signature_lock (jmv$job_execution_attributes.lock);

    IF jmv$job_execution_attributes.maximum_ws_overridden THEN
      attribute.key := jmc$maximum_working_set;
      attribute.maximum_working_set := jmv$job_execution_attributes.maximum_working_set;
      qfp$set_job_attributes (attribute, status);
      jmv$job_execution_attributes.maximum_ws_overridden := FALSE;
    IFEND;

    IF jmv$job_execution_attributes.minimum_ws_overridden THEN
      attribute.key := jmc$minimum_working_set;
      attribute.minimum_working_set := jmv$job_execution_attributes.minimum_working_set;
      qfp$set_job_attributes (attribute, status);
      jmv$job_execution_attributes.minimum_ws_overridden := FALSE;
    IFEND;

    IF jmv$job_execution_attributes.page_ai_overridden THEN
      attribute.key := jmc$page_aging_interval;
      attribute.page_aging_interval := jmv$job_execution_attributes.page_aging_interval;
      qfp$set_job_attributes (attribute, status);
      jmv$job_execution_attributes.page_ai_overridden := FALSE;
    IFEND;

    IF jmv$job_execution_attributes.cyclic_ai_overridden THEN
      attribute.key := jmc$cyclic_aging_interval;
      attribute.cyclic_aging_interval := jmv$job_execution_attributes.cyclic_aging_interval;
      qfp$set_job_attributes (attribute, status);
      jmv$job_execution_attributes.cyclic_ai_overridden := FALSE;
    IFEND;

    IF jmv$job_execution_attributes.service_class_overridden THEN
      set_service_class (jmc$unspecified_service_class, 0, old_service_accumulator);
    IFEND;

    osp$clear_job_signature_lock (jmv$job_execution_attributes.lock);

  PROCEND jmp$end_application_scheduling;
?? TITLE := 'jmp$initialize_job_attributes', EJECT ??
*copyc jmh$initialize_job_attributes

  PROCEDURE [XDCL, #GATE] jmp$initialize_job_attributes
    (    system_label_p: ^jmt$job_system_label;
     VAR status: ost$status);

    status.normal := TRUE;

{ A NIL system_label_p implies the system job

    IF system_label_p = NIL THEN
      jmv$job_attributes.comment_banner := osc$null_name;
      jmv$job_attributes.copy_count := 1;
      jmv$job_attributes.device := jmv$default_job_attributes [jmc$batch].device;
      jmv$job_attributes.earliest_run_time.specified := FALSE;
      jmv$job_attributes.earliest_print_time.specified := FALSE;
      jmv$job_attributes.external_characteristics := jmv$default_job_attributes [jmc$batch].
            external_characteristics;
      jmv$job_attributes.forms_code := jmv$default_job_attributes [jmc$batch].forms_code;
      jmv$job_attributes.implicit_routing_text.size := 0;
      jmv$job_attributes.implicit_routing_text.text := '';
      jmv$job_attributes.job_controller := jmv$jcb.user_id;
      jmv$job_attributes.job_initiation_time := jmv$kjlx_p^ [jmv$jcb.job_id].job_initiation_time;
      jmv$job_attributes.job_input_device.size := 0;
      jmv$job_attributes.job_input_device.text := '';
      jmv$job_attributes.job_qualifier_list := jmv$default_job_attributes [jmc$batch].job_qualifier_list;
      jmv$job_attributes.job_submission_time := jmv$kjlx_p^ [jmv$jcb.job_id].job_initiation_time;
      jmv$job_attributes.job_size := 0;
      jmv$job_attributes.latest_run_time.specified := FALSE;
      jmv$job_attributes.latest_print_time.specified := FALSE;
      jmv$job_attributes.login_command_supplied := FALSE;
      jmv$job_attributes.originating_application_name := osc$deadstart;
      jmv$job_attributes.originating_ssn := jmv$jcb.system_name;
      jmv$job_attributes.output_class := jmv$default_job_attributes [jmc$batch].output_class;
      jmv$job_attributes.output_deferred_by_user := FALSE;
      jmv$job_attributes.output_destination := jmv$jcb.user_id.family;
      jmv$job_attributes.output_destination_family := jmv$jcb.user_id.family;
      jmv$job_attributes.output_destination_usage := jmv$default_job_attributes [jmc$batch].
            output_destination_usage;
      jmv$job_attributes.output_disposition_key := jmc$normal_output_disposition;
      jmv$job_attributes.output_disposition_path := '';
      jmv$job_attributes.output_priority := jmv$default_job_attributes [jmc$batch].output_priority;
      jmv$job_attributes.process_user_prolog_and_epilog := TRUE;
      jmv$job_attributes.purge_delay.specified := FALSE;
      jmv$job_attributes.remote_host_directive.size := 0;
      jmv$job_attributes.remote_host_directive.parameters := '';
      jmv$job_attributes.routing_banner := osc$null_name;
      jmv$job_attributes.site_information := jmv$default_job_attributes [jmc$batch].site_information;
      jmv$job_attributes.source_logical_id := '';
      jmv$job_attributes.station := jmv$default_job_attributes [jmc$batch].station;
      jmv$job_attributes.station_operator := jmv$jcb.user_id.user;
      jmv$job_attributes.system_job_parameters.system_job_parameter := '';
      jmv$job_attributes.system_job_parameters.system_job_parameter_count := 0;
      jmv$job_attributes.system_routing_text.size := 0;
      jmv$job_attributes.system_routing_text.parameters := '';
      jmv$job_attributes.user_information := '';
      jmv$job_attributes.vertical_print_density := jmv$default_job_attributes [jmc$batch].
            vertical_print_density;
      jmv$job_attributes.vfu_load_procedure := jmv$default_job_attributes [jmc$batch].vfu_load_procedure;
      jmv$job_disposition_code := '  ';
    ELSE
      jmv$job_attributes := system_label_p^.job_attributes;
      jmv$job_disposition_code := system_label_p^.disposition_code;
      jmv$xterm_job := (osc$xterm_application_name = jmv$job_attributes.originating_application_name);
    IFEND;
    jmv$job_execution_attributes.maximum_working_set := jmv$jcb.max_working_set_size;
    jmv$job_execution_attributes.maximum_ws_overridden := FALSE;
    jmv$job_execution_attributes.minimum_working_set := jmv$jcb.min_working_set_size;
    jmv$job_execution_attributes.minimum_ws_overridden := FALSE;
    jmv$job_execution_attributes.page_aging_interval := jmv$jcb.page_aging_interval;
    jmv$job_execution_attributes.page_ai_overridden := FALSE;
    jmv$job_execution_attributes.cyclic_aging_interval := jmv$jcb.cyclic_aging_interval;
    jmv$job_execution_attributes.cyclic_ai_overridden := FALSE;
    jmv$job_execution_attributes.service_class_overridden := FALSE;
    osp$initialize_sig_lock (jmv$job_execution_attributes.lock);
  PROCEND jmp$initialize_job_attributes;
?? TITLE := 'jmp$set_application_scheduling', EJECT ??
*copyc jmh$set_application_scheduling

  PROCEDURE [XDCL, #GATE] jmp$set_application_scheduling
    (    application_attributes: jmt$application_attributes;
         new_service_accumulator: jmt$service_accumulator;
     VAR old_service_accumulator: jmt$service_accumulator;
     VAR status: ost$status);

    VAR
      attribute: jmt$job_attribute_change;

    status.normal := TRUE;
    osp$set_job_signature_lock (jmv$job_execution_attributes.lock);

    attribute.key := jmc$maximum_working_set;
    IF application_attributes.maximum_working_set <> jmc$unspecified_work_set_size THEN
      attribute.maximum_working_set := application_attributes.maximum_working_set;
      jmv$job_execution_attributes.maximum_ws_overridden := TRUE;
      qfp$set_job_attributes (attribute, status);
    ELSEIF jmv$job_execution_attributes.maximum_ws_overridden THEN
      attribute.maximum_working_set := jmv$job_execution_attributes.maximum_working_set;
      jmv$job_execution_attributes.maximum_ws_overridden := FALSE;
      qfp$set_job_attributes (attribute, status);
    IFEND;

    attribute.key := jmc$minimum_working_set;
    IF application_attributes.minimum_working_set <> jmc$unspecified_work_set_size THEN
      attribute.minimum_working_set := application_attributes.minimum_working_set;
      jmv$job_execution_attributes.minimum_ws_overridden := TRUE;
      qfp$set_job_attributes (attribute, status);
    ELSEIF jmv$job_execution_attributes.minimum_ws_overridden THEN
      attribute.minimum_working_set := jmv$job_execution_attributes.minimum_working_set;
      jmv$job_execution_attributes.minimum_ws_overridden := FALSE;
      qfp$set_job_attributes (attribute, status);
    IFEND;

    attribute.key := jmc$page_aging_interval;
    IF application_attributes.page_aging_interval <> jmc$unspecified_aging_interval THEN
      attribute.page_aging_interval := application_attributes.page_aging_interval;
      jmv$job_execution_attributes.page_ai_overridden := TRUE;
      qfp$set_job_attributes (attribute, status);
    ELSEIF jmv$job_execution_attributes.page_ai_overridden THEN
      attribute.page_aging_interval := jmv$job_execution_attributes.page_aging_interval;
      jmv$job_execution_attributes.page_ai_overridden := FALSE;
      qfp$set_job_attributes (attribute, status);
    IFEND;

    attribute.key := jmc$cyclic_aging_interval;
    IF application_attributes.cyclic_aging_interval <> jmc$unspecified_aging_interval THEN
      attribute.cyclic_aging_interval := application_attributes.cyclic_aging_interval;
      jmv$job_execution_attributes.cyclic_ai_overridden := TRUE;
      qfp$set_job_attributes (attribute, status);
    ELSEIF jmv$job_execution_attributes.cyclic_ai_overridden THEN
      attribute.cyclic_aging_interval := jmv$job_execution_attributes.cyclic_aging_interval;
      jmv$job_execution_attributes.cyclic_ai_overridden := FALSE;
      qfp$set_job_attributes (attribute, status);
    IFEND;

    attribute.key := jmc$service_class;
    IF application_attributes.service_class_index <> jmc$unspecified_service_class THEN
      set_service_class (application_attributes.service_class_index, new_service_accumulator,
            old_service_accumulator);
    ELSEIF jmv$job_execution_attributes.service_class_overridden THEN
      set_service_class (jmc$unspecified_service_class, new_service_accumulator, old_service_accumulator);
    ELSE
      old_service_accumulator := 0;
    IFEND;

    osp$clear_job_signature_lock (jmv$job_execution_attributes.lock);

  PROCEND jmp$set_application_scheduling;
?? TITLE := 'jmp$set_job_attributes', EJECT ??
*copyc jmh$set_job_attributes

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

    VAR
      attribute_index: integer;

    status.normal := TRUE;

    FOR attribute_index := LOWERBOUND (job_attribute_changes^) TO UPPERBOUND (job_attribute_changes^) DO
      CASE job_attribute_changes^ [attribute_index].key OF
      = jmc$comment_banner =
        jmv$job_attributes.comment_banner := job_attribute_changes^ [attribute_index].comment_banner;

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

      = jmc$cyclic_aging_interval =
        osp$set_job_signature_lock (jmv$job_execution_attributes.lock);
        jmv$job_execution_attributes.cyclic_aging_interval :=
              job_attribute_changes^ [attribute_index].cyclic_aging_interval;
        IF NOT jmv$job_execution_attributes.cyclic_ai_overridden THEN
          qfp$set_job_attributes (job_attribute_changes^ [attribute_index], status);
        IFEND;
        osp$clear_job_signature_lock (jmv$job_execution_attributes.lock);

      = jmc$detached_job_wait_time =
        qfp$set_job_attributes (job_attribute_changes^ [attribute_index], status);

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

      = jmc$dispatching_priority =
        qfp$set_job_attributes (job_attribute_changes^ [attribute_index], status);

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

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

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

      = jmc$job_abort_disposition =
        qfp$set_job_attributes (job_attribute_changes^ [attribute_index], status);

      = jmc$job_recovery_disposition =
        qfp$set_job_attributes (job_attribute_changes^ [attribute_index], status);

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

      = jmc$maximum_working_set =
        osp$set_job_signature_lock (jmv$job_execution_attributes.lock);
        jmv$job_execution_attributes.maximum_working_set :=
              job_attribute_changes^ [attribute_index].maximum_working_set;
        IF NOT jmv$job_execution_attributes.maximum_ws_overridden THEN
          qfp$set_job_attributes (job_attribute_changes^ [attribute_index], status);
        IFEND;
        osp$clear_job_signature_lock (jmv$job_execution_attributes.lock);

      = jmc$minimum_working_set =
        osp$set_job_signature_lock (jmv$job_execution_attributes.lock);
        jmv$job_execution_attributes.minimum_working_set :=
              job_attribute_changes^ [attribute_index].minimum_working_set;
        IF NOT jmv$job_execution_attributes.minimum_ws_overridden THEN
          qfp$set_job_attributes (job_attribute_changes^ [attribute_index], status);
        IFEND;
        osp$clear_job_signature_lock (jmv$job_execution_attributes.lock);

      = jmc$null_attribute =
        ;

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

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

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

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

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

      = jmc$output_disposition =
        jmv$job_attributes.output_disposition_key := job_attribute_changes^ [attribute_index].
              output_disposition.key;
        IF jmv$job_attributes.output_disposition_key = jmc$standard_output_path THEN
          jmv$job_attributes.output_disposition_path := job_attribute_changes^ [attribute_index].
                output_disposition.standard_output_path^;
        ELSE
          jmv$job_attributes.output_disposition_path := '';
        IFEND;
        qfp$discard_job_output (jmv$job_attributes.output_disposition_key);

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

      = jmc$page_aging_interval =
        osp$set_job_signature_lock (jmv$job_execution_attributes.lock);
        jmv$job_execution_attributes.page_aging_interval :=
              job_attribute_changes^ [attribute_index].page_aging_interval;
        IF NOT jmv$job_execution_attributes.page_ai_overridden THEN
          qfp$set_job_attributes (job_attribute_changes^ [attribute_index], status);
        IFEND;
        osp$clear_job_signature_lock (jmv$job_execution_attributes.lock);

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

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

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

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

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

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

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

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

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

      ELSE
        ;
      CASEND;
    FOREND;

  PROCEND jmp$set_job_attributes;
?? TITLE := 'jmp$set_job_input_device', EJECT ??

{ PURPOSE:
{   This procedure changes the value of the job_input_device job attribute.

  PROCEDURE [XDCL, #GATE] jmp$set_job_input_device
    (    job_input_device: jmt$job_input_device);

    jmv$job_attributes.job_input_device := job_input_device;
  PROCEND jmp$set_job_input_device;
?? TITLE := 'set_service_class', EJECT ??

{  Purpose
{    Sets or resets the service class of the job based on changes introduced
{    by application scheduling.
{
{  Design
{    If the provided service class is specified and valid then the service
{    class of the job is changed to the provided service class.  The old
{    service class index and accumulator is saved if this is the initial
{    change.  If the specified service class is unspecified or invalid and
{    the service class had been overridden by a previous call then the
{    service class and accumulator are reset to the original values.  If
{    the service class no longer exists then the initial service class in
{    the job class table is used.

  PROCEDURE set_service_class
    (    service_class_index: jmt$service_class_index;
         new_service_accumulator: jmt$service_accumulator;
     VAR old_service_accumulator: jmt$service_accumulator);

    VAR
      keep_old_service_data: boolean,
      rb: jmt$rb_scheduler_requests,
      ijle_p: ^jmt$initiated_job_list_entry;

    IF (service_class_index <> jmc$unspecified_service_class) AND
          (jmv$service_classes [service_class_index] <> NIL) AND
          jmv$service_classes [service_class_index]^.attributes.defined THEN
      rb.new_service_class := service_class_index;
      rb.new_service_accumulator := new_service_accumulator;
      keep_old_service_data := NOT jmv$job_execution_attributes.service_class_overridden;
      jmv$job_execution_attributes.service_class_overridden := TRUE;

    ELSEIF jmv$job_execution_attributes.service_class_overridden THEN
      rb.new_service_class := jmv$job_execution_attributes.service_class_index;
      rb.new_service_accumulator := jmv$job_execution_attributes.service_accumulator;
      jmv$job_execution_attributes.service_class_overridden := FALSE;
      keep_old_service_data := FALSE;

      IF (jmv$service_classes [rb.new_service_class] = NIL) OR NOT jmv$service_classes
            [rb.new_service_class]^.attributes.defined THEN
        rb.new_service_class := jmv$job_class_table_p^ [jmv$kjl_p^ [jmv$jcb.job_id].job_class].
              initial_service_class_index;
      IFEND;

    ELSE
      RETURN;
    IFEND;

    rb.reqcode := syc$rc_job_scheduler_request;
    rb.sub_reqcode := jmc$src_class_switch;
    rb.system_supplied_name := jmv$jcb.system_name;
    rb.old_service_class := jmc$null_service_class;
    rb.old_service_accumulator := 0;

    i#call_monitor (#LOC (rb), #SIZE (rb));

    old_service_accumulator := rb.old_service_accumulator;
    IF keep_old_service_data THEN
      jmv$job_execution_attributes.service_class_index := rb.old_service_class;
      jmv$job_execution_attributes.service_accumulator := rb.old_service_accumulator;
    IFEND;
  PROCEND set_service_class;

MODEND jmm$set_job_attributes;
