?? RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE job management program level interfaces' ??
MODULE jmm$program_level_interfaces;
?? RIGHT := 110 ??

{ Purpose: This module contains the procedures that provide the NOS/VE
{          program level interfaces for Job Management.

?? NEWTITLE := '    Global Declarations Referenced by this Module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc oss$mainframe_pageable
*copyc oss$mainframe_paged_literal
*copyc tmc$signal_identifiers
*copyc jme$job_scheduler_conditions
*copyc jme$queued_file_conditions
*copyc pme$program_services_exceptions
*copyc jmt$clock_time
*copyc jmt$job_class
*copyc jmt$job_class_name
*copyc jmt$job_internal_information
*copyc jmt$job_mode
*copyc jmt$job_system_id
*copyc jmt$sense_switch_signal
*copyc jmt$system_job_parameters
*copyc jmt$system_supplied_name
*copyc jmt$user_supplied_name
*copyc ost$date_time
*copyc ost$execution_control_block
*copyc ost$status
*copyc ost$user_identification
*copyc pmt$family_name_count
*copyc pmt$family_name_list
*copyc pmt$sense_switches
?? POP ??
*copyc jmp$manage_sense_switches
*copyc osp$get_family_names
*copyc osp$set_status_abnormal
*copyc osp$set_status_condition
*copyc pmp$get_microsecond_clock
*copyc pmp$send_signal
*copyc qfp$get_job_internal_info
*copyc jmv$executing_within_system_job
*copyc jmv$jcb
*copyc jmv$jmtr_xcb
*copyc jmv$job_class_table_p
*copyc jmv$max_service_class_in_use
*copyc jmv$maximum_job_class_in_use
*copyc jmv$service_classes
?? TITLE := '    Global Variables Declared in this Module', EJECT ??

  CONST
    priority_table_size = 15;

  VAR
    priority_table: [STATIC, READ, oss$mainframe_paged_literal] array [1 .. priority_table_size] of record
      dispatching_priority: jmt$dispatching_priority,
      name: string (7),
    recend := [[jmc$null_dispatching_priority, 'DEFAULT'], [jmc$priority_p1, 'P1     '], [jmc$priority_p2,
          'P2     '], [jmc$priority_p3, 'P3     '], [jmc$priority_p4, 'P4     '],
          [jmc$priority_p5, 'P5     '], [jmc$priority_p6, 'P6     '], [jmc$priority_p7, 'P7     '],
          [jmc$priority_p8, 'P8     '], [jmc$priority_p9, 'P9     '], [jmc$priority_p10, 'P10    '],
          [jmc$priority_p11, 'P11    '], [jmc$priority_p12, 'P12    '], [jmc$priority_p13, 'P13    '],
          [jmc$priority_p14, 'P14    ']];

  VAR
    jmv$null_date_time: [XDCL, #GATE, STATIC, READ, oss$mainframe_paged_literal] ost$date_time :=
          [0, 1, 1, 0, 0, 0, 0];

?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] jmp$convert_date_time_to_clock', EJECT ??
*copy jmh$convert_date_time_to_clock

  PROCEDURE [XDCL, #GATE] jmp$convert_date_time_to_clock
    (    date_time: ost$date_time;
     VAR free_running_clock_value: jmt$clock_time);

    VAR
      days_cummulative_by_month: [STATIC, READ, oss$mainframe_paged_literal] array [1 .. 12] of
            0 .. 366 := [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334];

    VAR
      number_of_days: integer;

    number_of_days := date_time.year * 365 + ((date_time.year DIV 4) + 1) +
          days_cummulative_by_month [date_time.month] + date_time.day;

    IF ((date_time.year MOD 4) = 0) AND (date_time.month <= 2) THEN
      number_of_days := number_of_days - 1;
    IFEND;

    free_running_clock_value := (((((number_of_days * 24) + date_time.hour) * 60 + date_time.minute) *
          60 + date_time.second) * 1000 + date_time.millisecond) * 1000;

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

  PROCEDURE [XDCL, #GATE] jmp$determine_dis_priority
    (    name: ost$name;
     VAR dispatching_priority: jmt$dispatching_priority;
     VAR status: ost$status);

    VAR
      i: 1 .. priority_table_size;

    status.normal := TRUE;

    FOR i := 1 TO priority_table_size DO
      IF priority_table [i].name = name THEN
        dispatching_priority := priority_table [i].dispatching_priority;
        RETURN; {----->
      IFEND;
    FOREND;

    osp$set_status_abnormal ('JM', jme$invalid_dispatch_priority, ' ', status);

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

  PROCEDURE [XDCL, #GATE] jmp$determine_dis_priority_name
    (    dispatching_priority: jmt$dispatching_priority;
     VAR priority_name: ost$name;
     VAR status: ost$status);

    VAR
      i: 1 .. priority_table_size;

    status.normal := TRUE;
    FOR i := 1 TO priority_table_size DO
      IF priority_table [i].dispatching_priority = dispatching_priority THEN
        priority_name := priority_table [i].name;
        RETURN; {----->
      IFEND;
    FOREND;

    osp$set_status_condition (jme$invalid_dispatch_priority, status);

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

  PROCEDURE [XDCL, #GATE] jmp$determine_job_class
    (    job_class_name: jmt$job_class_name;
     VAR job_class: jmt$job_class;
     VAR status: ost$status);

    VAR
      class_index: jmt$job_class;

    status.normal := TRUE;

    FOR class_index := jmc$system_job_class TO jmv$maximum_job_class_in_use DO
      IF (job_class_name = jmv$job_class_table_p^ [class_index].name) OR
            (job_class_name = jmv$job_class_table_p^ [class_index].abbreviation) THEN
        IF jmv$job_class_table_p^ [class_index].defined THEN
          job_class := class_index;
          RETURN; {----->
        IFEND;
      IFEND;
    FOREND;

    osp$set_status_condition (jme$job_class_not_defined, status);
  PROCEND jmp$determine_job_class;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] jmp$determine_job_class_name', EJECT ??
*copy jmh$determine_job_class_name

  PROCEDURE [XDCL, #GATE] jmp$determine_job_class_name
    (    job_class: jmt$job_class;
     VAR job_class_name: jmt$job_class_name;
     VAR status: ost$status);

    status.normal := TRUE;

    IF jmv$job_class_table_p^ [job_class].defined THEN
      job_class_name := jmv$job_class_table_p^ [job_class].name;
    ELSE
      osp$set_status_condition (jme$job_class_not_defined, status);
    IFEND;

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

  PROCEDURE [XDCL, #GATE] jmp$determine_job_class_abbrev
    (    job_class: jmt$job_class;
     VAR job_class_abbrev: jmt$job_class_name;
     VAR status: ost$status);

    status.normal := TRUE;

    IF jmv$job_class_table_p^ [job_class].defined THEN
      IF jmv$job_class_table_p^ [job_class].abbreviation <> '                               ' THEN
        job_class_abbrev := jmv$job_class_table_p^ [job_class].abbreviation;
      ELSE
        job_class_abbrev := jmv$job_class_table_p^ [job_class].name;
      IFEND;
    ELSE
      osp$set_status_condition (jme$service_class_not_defined, status);
    IFEND;

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

  PROCEDURE [XDCL, #GATE] jmp$determine_service_class
    (    service_class_name: jmt$service_class_name;
     VAR service_class: jmt$service_class_index;
     VAR status: ost$status);

    VAR
      class_index: jmt$service_class_index,
      service_class_p: ^jmt$service_class_entry;

    status.normal := TRUE;
    FOR class_index := jmc$system_service_class TO jmv$max_service_class_in_use DO
      service_class_p := jmv$service_classes [class_index];
      IF (service_class_p <> NIL) AND service_class_p^.attributes.defined THEN
        IF (service_class_name = service_class_p^.attributes.name) OR
              (service_class_name = service_class_p^.attributes.abbreviation) THEN
          service_class := class_index;
          RETURN; {----->
        IFEND;
      IFEND;
    FOREND;

    osp$set_status_condition (jme$service_class_not_defined, status);

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

  PROCEDURE [XDCL, #GATE] jmp$determine_serv_class_name
    (    service_class: jmt$service_class_index;
     VAR service_class_name: jmt$service_class_name;
     VAR status: ost$status);

    VAR
      service_class_p: ^jmt$service_class_entry;

    status.normal := TRUE;
    service_class_p := jmv$service_classes [service_class];
    IF (service_class_p <> NIL) AND service_class_p^.attributes.defined THEN
      service_class_name := service_class_p^.attributes.name;
    ELSE
      osp$set_status_condition (jme$service_class_not_defined, status);
    IFEND;

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

  PROCEDURE [XDCL, #GATE] jmp$determine_serv_class_abbrev
    (    service_class: jmt$service_class_index;
     VAR service_class_abbrev: jmt$service_class_name;
     VAR status: ost$status);

    VAR
      service_class_p: ^jmt$service_class_entry;

    status.normal := TRUE;
    service_class_p := jmv$service_classes [service_class];
    IF (service_class_p <> NIL) AND service_class_p^.attributes.defined THEN
      service_class_abbrev := service_class_p^.attributes.abbreviation;
      IF service_class_abbrev = '                               ' THEN
        service_class_abbrev := service_class_p^.attributes.name;
      IFEND;
    ELSE
      osp$set_status_condition (jme$service_class_not_defined, status);
    IFEND;

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

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

    VAR
      class_index: jmt$job_class;

    status.normal := TRUE;
    FOR class_index := jmc$system_job_class TO jmv$maximum_job_class_in_use DO
      IF (job_class_name = jmv$job_class_table_p^ [class_index].name) OR
            (job_class_name = jmv$job_class_table_p^ [class_index].abbreviation) THEN
        IF jmv$job_class_table_p^ [class_index].defined THEN
          job_class_name := jmv$job_class_table_p^ [class_index].name;
          RETURN; {----->
        IFEND;
      IFEND;
    FOREND;

    osp$set_status_condition (jme$job_class_not_defined, status);

  PROCEND jmp$expand_job_class_abbrev;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] pmp$get_user_identification', EJECT ??
*copy pmh$get_user_identification

  PROCEDURE [XDCL, #GATE] pmp$get_user_identification
    (VAR identification: ost$user_identification;
     VAR status: ost$status);

    status.normal := TRUE;
    identification := jmv$jcb.user_id;

  PROCEND pmp$get_user_identification;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] pmp$get_family_names', EJECT ??
*copy pmh$get_family_names

  PROCEDURE [XDCL, #GATE] pmp$get_family_names
    (VAR family_names: pmt$family_name_list;
     VAR name_count: pmt$family_name_count;
     VAR status: ost$status);

    osp$get_family_names (family_names, name_count, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF name_count > UPPERBOUND (family_names) THEN
      osp$set_status_abnormal ('PM', pme$result_array_too_small, 'FAMILY_NAMES', status);
    IFEND;

  PROCEND pmp$get_family_names;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] pmp$get_job_monitor_gtid', EJECT ??
*copy pmh$get_job_monitor_gtid

  PROCEDURE [XDCL, #GATE] pmp$get_job_monitor_gtid
    (VAR global_task_id: ost$global_task_id;
     VAR status: ost$status);

    status.normal := TRUE;
    global_task_id := jmv$jcb.job_monitor_id;

  PROCEND pmp$get_job_monitor_gtid;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] pmp$get_job_names', EJECT ??
*copy pmh$get_job_names

  PROCEDURE [XDCL, #GATE] pmp$get_job_names
    (VAR user_supplied_name: jmt$user_supplied_name;
     VAR system_supplied_name: jmt$system_supplied_name;
     VAR status: ost$status);

    status.normal := TRUE;
    user_supplied_name := jmv$jcb.jobname;
    system_supplied_name := jmv$jcb.system_name;

  PROCEND pmp$get_job_names;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] pmp$get_job_mode', EJECT ??
*copy pmh$get_job_mode

  PROCEDURE [XDCL, #GATE] pmp$get_job_mode
    (VAR mode: jmt$job_mode;
     VAR status: ost$status);

    status.normal := TRUE;
    mode := jmv$jcb.ijle_p^.job_mode;

  PROCEND pmp$get_job_mode;
?? OLDTITLE ??
?? NEWTITLE := '[xdcl, #gate] PMF$JOB_MODE', EJECT ??

  FUNCTION [XDCL, #GATE] pmf$job_mode: jmt$job_mode;

    pmf$job_mode := jmv$jcb.ijle_p^.job_mode;

  FUNCEND pmf$job_mode;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] pmp$manage_sense_switches', EJECT ??
*copy pmh$manage_sense_switches

  PROCEDURE [XDCL, #GATE] pmp$manage_sense_switches
    (    ON: pmt$sense_switches;
         OFF: pmt$sense_switches;
     VAR current: pmt$sense_switches;
     VAR status: ost$status);

    status.normal := TRUE;
    jmp$manage_sense_switches (ON, OFF);
    current := jmv$jcb.sense_switches;

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

  PROCEDURE [XDCL, #GATE] jmp$get_job_internal_info
    (    system_supplied_name: jmt$system_supplied_name;
     VAR job_internal_info: jmt$job_internal_information;
     VAR status: ost$status);

    qfp$get_job_internal_info (system_supplied_name, job_internal_info, status);

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

  FUNCTION [XDCL, #GATE] jmp$job_monitor_xcb: ^ost$execution_control_block;

    jmp$job_monitor_xcb := ^jmv$jmtr_xcb;

  FUNCEND jmp$job_monitor_xcb;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] jmp$system_job', EJECT ??
*copy jmh$system_job

  FUNCTION [XDCL, #GATE] jmp$system_job: boolean;

    jmp$system_job := jmv$executing_within_system_job;

  FUNCEND jmp$system_job;
?? OLDTITLE ??
MODEND jmm$program_level_interfaces;
