?? RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE job management name query program interfaces' ??
MODULE jmm$name_manager;

{ PURPOSE:
{   This module contains the job-management name query interfaces.

?? NEWTITLE := 'Global Declarations Referenced by this module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc cle$ecc_lexical
*copyc dft$rpc_parameters
*copyc jme$queued_file_conditions
*copyc jmt$job_name_list
*copyc jmt$job_status_count
*copyc jmt$job_status_options
*copyc jmt$job_status_results
*copyc jmt$name
*copyc jmt$system_supplied_name
*copyc jmt$user_supplied_name
*copyc oss$job_paged_literal
*copyc ost$name
*copyc ost$status
?? POP ??
*copyc clp$validate_name
*copyc i#compare_collated
*copyc jmp$get_job_status
*copyc jmp$get_result_size
*copyc jmp$system_job
*copyc jmp$update_ssn_sequence
*copyc osp$set_status_abnormal
*copyc osp$set_status_condition
*copyc osp$verify_system_privilege
*copyc pmp$convert_mainframe_to_binary
*copyc pmp$get_job_names
*copyc qfp$get_job_internal_info
*copyc qfp$list_jobs_via_mode
*copyc jmv$ssn_previous_sequence
*copyc jmv$system_supplied_name
?? TITLE := 'Global Variables Declared in this Module', EJECT ??

  VAR
    jmv$ssn_mask: [STATIC, READ, oss$job_paged_literal] string (256) := $CHAR (00) CAT $CHAR (01) CAT
          $CHAR (02) CAT $CHAR (03) CAT $CHAR (04) CAT $CHAR (05) CAT $CHAR (06) CAT $CHAR (07) CAT
          $CHAR (08) CAT $CHAR (09) CAT $CHAR (10) CAT $CHAR (11) CAT $CHAR (12) CAT $CHAR (13) CAT
          $CHAR (14) CAT $CHAR (15) CAT $CHAR (16) CAT $CHAR (17) CAT $CHAR (18) CAT $CHAR (19) CAT
          $CHAR (20) CAT $CHAR (21) CAT $CHAR (22) CAT $CHAR (23) CAT $CHAR (24) CAT $CHAR (25) CAT
          $CHAR (26) CAT $CHAR (27) CAT $CHAR (28) CAT $CHAR (29) CAT $CHAR (30) CAT $CHAR (31) CAT
          ' !"#$%&''()*+,-./0000000000:;<=>?@AAAAAAAAAAAAAAAAAAAAAAAAAA[\]^_@AAAAAAAAAAAAAAAAAAAAAAAAAA{|}^'
          CAT $CHAR (127) CAT $CHAR (128) CAT $CHAR (129) CAT $CHAR (130) CAT $CHAR (131) CAT $CHAR (132) CAT
          $CHAR (133) CAT $CHAR (134) CAT $CHAR (135) CAT $CHAR (136) CAT $CHAR (137) CAT $CHAR (138) CAT
          $CHAR (139) CAT $CHAR (140) CAT $CHAR (141) CAT $CHAR (142) CAT $CHAR (143) CAT $CHAR (144) CAT
          $CHAR (145) CAT $CHAR (146) CAT $CHAR (147) CAT $CHAR (148) CAT $CHAR (149) CAT $CHAR (150) CAT
          $CHAR (151) CAT $CHAR (152) CAT $CHAR (153) CAT $CHAR (154) CAT $CHAR (155) CAT $CHAR (156) CAT
          $CHAR (157) CAT $CHAR (158) CAT $CHAR (159) CAT $CHAR (160) CAT $CHAR (161) CAT $CHAR (162) CAT
          $CHAR (163) CAT $CHAR (164) CAT $CHAR (165) CAT $CHAR (166) CAT $CHAR (167) CAT $CHAR (168) CAT
          $CHAR (169) CAT $CHAR (170) CAT $CHAR (171) CAT $CHAR (172) CAT $CHAR (173) CAT $CHAR (174) CAT
          $CHAR (175) CAT $CHAR (176) CAT $CHAR (177) CAT $CHAR (178) CAT $CHAR (179) CAT $CHAR (180) CAT
          $CHAR (181) CAT $CHAR (182) CAT $CHAR (183) CAT $CHAR (184) CAT $CHAR (185) CAT $CHAR (186) CAT
          $CHAR (187) CAT $CHAR (188) CAT $CHAR (189) CAT $CHAR (190) CAT $CHAR (191) CAT $CHAR (192) CAT
          $CHAR (193) CAT $CHAR (194) CAT $CHAR (195) CAT $CHAR (196) CAT $CHAR (197) CAT $CHAR (198) CAT
          $CHAR (199) CAT $CHAR (200) CAT $CHAR (201) CAT $CHAR (202) CAT $CHAR (203) CAT $CHAR (204) CAT
          $CHAR (205) CAT $CHAR (206) CAT $CHAR (207) CAT $CHAR (208) CAT $CHAR (209) CAT $CHAR (210) CAT
          $CHAR (211) CAT $CHAR (212) CAT $CHAR (213) CAT $CHAR (214) CAT $CHAR (215) CAT $CHAR (216) CAT
          $CHAR (217) CAT $CHAR (218) CAT $CHAR (219) CAT $CHAR (220) CAT $CHAR (221) CAT $CHAR (222) CAT
          $CHAR (223) CAT $CHAR (224) CAT $CHAR (225) CAT $CHAR (226) CAT $CHAR (227) CAT $CHAR (228) CAT
          $CHAR (229) CAT $CHAR (230) CAT $CHAR (231) CAT $CHAR (232) CAT $CHAR (233) CAT $CHAR (234) CAT
          $CHAR (235) CAT $CHAR (236) CAT $CHAR (237) CAT $CHAR (238) CAT $CHAR (239) CAT $CHAR (240) CAT
          $CHAR (241) CAT $CHAR (242) CAT $CHAR (243) CAT $CHAR (244) CAT $CHAR (245) CAT $CHAR (246) CAT
          $CHAR (247) CAT $CHAR (248) CAT $CHAR (249) CAT $CHAR (250) CAT $CHAR (251) CAT $CHAR (252) CAT
          $CHAR (253) CAT $CHAR (254) CAT $CHAR (255);

?? TITLE := '[XDCL] jmp$convert_name_to_ssn', EJECT ??
*copy jmh$convert_name_to_ssn

  PROCEDURE [XDCL] jmp$convert_name_to_ssn
    (    name: string ( * <= osc$max_name_size);
         privileged_job: boolean;
     VAR system_supplied_name: jmt$system_supplied_name;
     VAR status: ost$status);

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

    status.normal := TRUE;

    jmp$determine_name_kind (name, valid_name, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    PUSH job_status_options_p: [1 .. 2];
    job_status_options_p^ [1].key := jmc$name_list;
    PUSH job_status_options_p^ [1].name_list: [1 .. 1];
    job_status_options_p^ [1].name_list^ [1] := valid_name;
    job_status_options_p^ [2].key := jmc$privilege;
    job_status_options_p^ [2].privilege := jmc$users_default_privilege;
    IF privileged_job THEN
      job_status_options_p^ [2].privilege := jmc$privileged;
    IFEND;

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

    jmp$get_job_status (job_status_options_p, job_status_results_keys_p, job_status_results_seq_p,
          job_status_results_p, number_of_jobs_found, status);
    IF number_of_jobs_found = 0 THEN
      osp$set_status_abnormal ('JM', jme$name_not_found, name, status);
    ELSEIF number_of_jobs_found > 1 THEN
      osp$set_status_abnormal ('JM', jme$duplicate_name, name, status);
    IFEND;
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    system_supplied_name := job_status_results_p^ [1]^ [1].system_job_name;

  PROCEND jmp$convert_name_to_ssn;
?? TITLE := '[XDCL, #GATE] jmp$determine_name_kind', EJECT ??
*copy jmh$determine_name_kind

  PROCEDURE [XDCL, #GATE] jmp$determine_name_kind
    (    candidate_name: string ( * <= osc$max_name_size);
     VAR name: jmt$name;
     VAR status: ost$status);

    VAR
      compare_ssn: record
        case boolean of
        = FALSE =
          name: ost$name,
        = TRUE =
          system_supplied_name: jmt$system_supplied_name_mask,
        casend,
      recend,
      verified_name: ost$name,
      system_supplied_name: jmt$system_supplied_name_mask,
      length: integer,
      valid_name: boolean;

?? NEWTITLE := '      convert_alpha_to_numeric', EJECT ??

{    The purpose of this request is to convert the alphabetical characters in a string to the
{  character zero ('0').  It is assumed that the input string has all alphabetical characters
{  in upper case.

    PROCEDURE [INLINE] convert_alpha_to_numeric
      (VAR stng: string ( * ));

      VAR
        index: integer;

      length := STRLENGTH (stng);
      FOR index := 1 TO STRLENGTH (stng) DO
        IF (stng (index) >= 'A') AND (stng (index) <= 'Z') THEN
          stng (index) := '0';
        IFEND;
      FOREND;
    PROCEND convert_alpha_to_numeric;

?? OLDTITLE ??

    status.normal := TRUE;
    clp$validate_name (candidate_name, verified_name, valid_name);
    IF NOT valid_name THEN
      osp$set_status_abnormal ('cl', cle$improper_name, candidate_name, status);
      RETURN;
    IFEND;

{ The model number may be alpha-numeric - we need to convert the characters in the name in the
{ model# position in order for the compare collated to complete successfully if the model number
{ has an alphabetical character in it.

    compare_ssn.name := verified_name;
    convert_alpha_to_numeric (compare_ssn.system_supplied_name.model);

    IF i#compare_collated (compare_ssn.name, jmc$full_system_supplied_name, jmv$ssn_mask) = 0 THEN
      name.kind := jmc$system_supplied_name;
      name.system_supplied_name := verified_name;

    ELSEIF i#compare_collated (verified_name, jmc$long_system_supplied_name, jmv$ssn_mask) = 0 THEN
      name.kind := jmc$system_supplied_name;
      system_supplied_name := jmv$system_supplied_name;
      system_supplied_name.sequence := verified_name (2, jmc$ssn_sequence_number_size);
      system_supplied_name.counter := verified_name (6, jmc$ssn_counter_size);
      name.system_supplied_name := system_supplied_name.system_supplied_name;

    ELSEIF i#compare_collated (verified_name, jmc$short_system_supplied_name, jmv$ssn_mask) = 0 THEN
      name.kind := jmc$system_supplied_name;
      system_supplied_name := jmv$system_supplied_name;
      IF system_supplied_name.counter < verified_name (2, jmc$ssn_counter_size) THEN
        system_supplied_name.sequence := jmv$ssn_previous_sequence;
      IFEND;
      system_supplied_name.counter := verified_name (2, jmc$ssn_counter_size);
      name.system_supplied_name := system_supplied_name.system_supplied_name;

    ELSE
      name.kind := jmc$user_supplied_name;
      name.user_supplied_name := verified_name;
    IFEND;

  PROCEND jmp$determine_name_kind;
?? TITLE := '[XDCL] jmp$get_job_ijl_ordinal', EJECT ??
*copy jmh$get_job_ijl_ordinal

  PROCEDURE [XDCL] jmp$get_job_ijl_ordinal
    (    name: string ( * <= osc$max_name_size);
         privileged_job: boolean;
     VAR ijl_ordinal: jmt$ijl_ordinal;
     VAR system_supplied_name: jmt$system_supplied_name;
     VAR status: ost$status);

    VAR
      job_internal_info: jmt$job_internal_information;

    status.normal := TRUE;

    jmp$convert_name_to_ssn (name, privileged_job, system_supplied_name, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    qfp$get_job_internal_info (system_supplied_name, job_internal_info, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    ijl_ordinal := job_internal_info.ijl_ordinal;
  PROCEND jmp$get_job_ijl_ordinal;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL] jmp$get_job_names_by_user', EJECT ??
*copy jmh$get_job_names_by_user

  PROCEDURE [XDCL] jmp$get_job_names_by_user
    (    user: ost$name;
         family: ost$name;
         job_name_list_p: ^jmt$job_name_list;
     VAR number_of_jobs_found: jmt$job_status_count;
     VAR status: ost$status);

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

    status.normal := TRUE;

    PUSH job_status_options_p: [1 .. 5];
    job_status_options_p^ [1].key := jmc$login_user;
    job_status_options_p^ [1].login_user := user;
    job_status_options_p^ [2].key := jmc$login_family;
    job_status_options_p^ [2].login_family := family;
    job_status_options_p^ [3].key := jmc$job_state_set;
    job_status_options_p^ [3].job_state_set := $jmt$job_state_set [jmc$initiated_job, jmc$terminating_job];
    job_status_options_p^ [4].key := jmc$privilege;
    job_status_options_p^ [4].privilege := jmc$privileged;
    job_status_options_p^ [5].key := jmc$continue_request_to_servers;
    job_status_options_p^ [5].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 (UPPERBOUND (job_name_list_p^), #SEQ (job_status_results_keys_p^), size_of_sequence);
    PUSH job_status_results_seq_p: [[REP size_of_sequence OF cell]];

    jmp$get_job_status (job_status_options_p, job_status_results_keys_p, job_status_results_seq_p,
          job_status_results_p, number_of_jobs_found, status);
    IF (number_of_jobs_found > UPPERBOUND (job_name_list_p^)) THEN
      osp$set_status_condition (jme$result_array_too_small, status);
    ELSEIF number_of_jobs_found = 0 THEN
      osp$set_status_condition (jme$no_jobs_were_found, status);
    IFEND;
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    FOR result_index := 1 TO number_of_jobs_found DO
      job_name_list_p^ [result_index].system_job_name := job_status_results_p^ [result_index]^ [1].
            system_job_name;
      pmp$convert_mainframe_to_binary (job_status_results_p^ [result_index]^ [2].client_mainframe_id,
            job_name_list_p^ [result_index].mainframe_id, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
    FOREND;
  PROCEND jmp$get_job_names_by_user;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] jmp$job_exists', EJECT ??
*copy jmh$job_exists

  PROCEDURE [XDCL, #GATE] jmp$job_exists
    (    name: string ( * <= osc$max_name_size);
         job_state_set: jmt$job_state_set;
     VAR job_exists: boolean;
     VAR status: ost$status);

    VAR
      job_status_options_p: ^jmt$job_status_options,
      job_status_results_p: ^jmt$job_status_results,
      job_status_results_seq_p: ^jmt$work_area,
      number_of_jobs_found: jmt$job_status_count,
      valid_name: jmt$name;

    status.normal := TRUE;
    job_exists := FALSE;

    jmp$determine_name_kind (name, valid_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] := valid_name;
    job_status_options_p^ [2].key := jmc$job_state_set;
    job_status_options_p^ [2].job_state_set := job_state_set;
    job_status_options_p^ [3].key := jmc$privilege;
    job_status_options_p^ [3].privilege := jmc$privileged;
    job_status_results_seq_p := NIL;
    job_status_results_p := NIL;

    jmp$get_job_status (job_status_options_p, {job_status_results_keys_p} NIL, job_status_results_seq_p,
          job_status_results_p, number_of_jobs_found, status);
    IF number_of_jobs_found = 0 THEN
      status.normal := TRUE;
      RETURN;
    ELSEIF number_of_jobs_found > 1 THEN
      osp$set_status_abnormal ('JM', jme$duplicate_name, name, status);
    IFEND;
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    job_exists := TRUE;

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

  PROCEDURE [XDCL] jmp$list_jobs_via_mode
    (    mode: jmt$job_mode;
     VAR ssn_job_name_list: array [1 .. * ] of jmt$system_supplied_name;
     VAR number_returned: integer;
     VAR status: ost$status);

    status.normal := TRUE;

    qfp$list_jobs_via_mode (mode, ssn_job_name_list, number_returned, status);
  PROCEND jmp$list_jobs_via_mode;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] jmp$validate_name', EJECT ??
*copy jmh$validate_name

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

    VAR
      valid_name: jmt$name,
      clname: ost$name,
      verified_name: ost$name;

    status.normal := TRUE;

    CASE candidate_name.kind OF
    = jmc$system_supplied_name =
      clname := candidate_name.system_supplied_name;
      jmp$determine_name_kind (clname, valid_name, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      IF valid_name.kind <> jmc$system_supplied_name THEN
        osp$set_status_abnormal ('JM', jme$illegal_ssn, candidate_name.system_supplied_name, status);
        RETURN;
      IFEND;

      name := valid_name;

    = jmc$user_supplied_name =
      clname := candidate_name.user_supplied_name;

      jmp$determine_name_kind (clname, valid_name, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      IF valid_name.kind <> jmc$user_supplied_name THEN
        osp$set_status_abnormal ('JM', jme$illegal_usn, candidate_name.user_supplied_name, status);
        RETURN;
      IFEND;

      name := valid_name;

    ELSE
      ;
    CASEND;
  PROCEND jmp$validate_name;
?? TITLE := '[XDCL, #GATE] jmp$set_system_sequence_number', EJECT ??
*copyc jmh$set_system_sequence_number

  PROCEDURE [XDCL, #GATE] jmp$set_system_sequence_number
    (    system_sequence_number: string ( * <= osc$max_name_size);
     VAR status: ost$status);

    VAR
      candidate_name: jmt$name,
      valid_name: jmt$name;

    status.normal := TRUE;

    osp$verify_system_privilege;
    candidate_name.kind := jmc$system_supplied_name;
    candidate_name.system_supplied_name := system_sequence_number;
    jmp$validate_name (candidate_name, valid_name, status);
    IF status.normal THEN
      jmp$update_ssn_sequence (valid_name.system_supplied_name);
    IFEND;
  PROCEND jmp$set_system_sequence_number;
?? OLDTITLE ??
MODEND jmm$name_manager;
