?? RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE:  Job Management Miscellaineous Services' ??
MODULE jmm$job_mgmt_misc_services;
?? RIGHT := 110 ??

{ PURPOSE:
{   This module contains routines that are of a specific nature, unrelated to
{   other routines in a specific part of job management.

?? NEWTITLE := 'Global Declarations Referenced by This Module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc oss$job_paged_literal
*copyc oss$task_private
*copyc oss$task_shared
*copyc jmc$get_input_attributes
*copyc jmc$get_job_status
*copyc jmc$get_output_attributes
*copyc jmc$get_output_status
*copyc jmc$get_qfile_attributes
*copyc jmc$get_qfile_status
*copyc jmc$job_management_id
*copyc jmd$job_resource_condition
*copyc osd$integer_limits
*copyc osd$virtual_address
*copyc cle$ecc_lexical
*copyc jme$duplicate_attribute_key
*copyc jme$invalid_parameter
*copyc jme$qfile_state_is_null
*copyc jme$unknown_requestor
*copyc jme$work_area_too_small
*copyc jmt$attribute_keys_set
*copyc jmt$attribute_values
*copyc jmt$full_job_category_list
*copyc jmt$job_status_count
*copyc jmt$qfile_application_attrs
*copyc jmt$results
*copyc jmt$results_keys
*copyc jmt$work_area
*copyc ost$status
*copyc ost$user_identification
?? POP ??
*copyc clp$validate_name
*copyc jmp$get_attribute_name
*copyc jmp$validate_name
*copyc mmp$create_user_segment
*copyc osp$append_status_parameter
*copyc osp$force_access_violation
*copyc osp$set_status_abnormal
*copyc osp$set_status_condition
*copyc i#move
?? OLDTITLE ??
?? NEWTITLE := 'Global Declarations Declared by This Module', EJECT ??

  VAR
    jmv$job_management_work_area_p: [XDCL, STATIC, oss$task_private] ^jmt$work_area := NIL,
    jmv$job_resource_condition: [XDCL, #GATE, oss$task_shared] jmt$job_resource_condition;

?? OLDTITLE ??
?? NEWTITLE := '[XDCL] jmp$copy_seq_to_result_array', EJECT ??

{ PURPOSE:
{   The purpose of this request is to copy the data in the results sequence
{   to the results array.

  PROCEDURE [XDCL] jmp$copy_seq_to_result_array
    (    number_of_keys: ost$positive_integers;
         number_of_packets_in_sequence: ost$non_negative_integers,
         results_keys_p: ^jmt$results_keys;
     VAR jm_work_area_p: ^jmt$work_area;
     VAR user_work_area_p: ^jmt$work_area;
     VAR status: ost$status);

    VAR
      application_attribute_size_p: ^jmt$qfile_appl_attr_size,
      application_attribute_dest_p: ^SEQ ( * ),
      application_attribute_source_p: ^SEQ ( * ),
      boolean_p: ^boolean,
      copies_p: ^jmt$output_copy_count,
      cpu_time_limit_p: ^jmt$cpu_time_limit,
      cpu_time_used_p: ^jmt$cpu_time_used,
      data_mode_p: ^jmt$data_mode,
      date_time_p: ^jmt$date_time,
      device_type_p: ^jmt$output_device_type,
      display_message_p: ^jmt$display_message,
      external_characteristics_p: ^jmt$external_characteristics,
      file_position_p: ^jmt$output_file_position,
      file_size_p: ^jmt$output_file_size,
      forms_code_p: ^jmt$forms_code,
      input_file_location_p: ^jmt$input_file_location,
      internal_index_p: ^integer,
      job_abort_disposition_p: ^jmt$job_abort_disposition,
      job_category_count_p: ^jmt$job_category_count,
      job_category_index: jmt$job_category_count,
      job_category_list_p: ^jmt$full_job_category_list,
      job_class_position_p: ^jmt$job_status_count,
      job_initiation_time_p: ^jmt$date_time,
      job_mode_p: ^jmt$job_mode,
      job_qualifier_list_p: ^jmt$job_qualifier_list,
      job_recovery_disposition_p: ^jmt$job_recovery_disposition,
      job_size_p: ^jmt$job_size,
      job_state_p: ^jmt$job_state,
      magnetic_tape_limit_p: ^jmt$magnetic_tape_limit,
      mainframe_id_p: ^pmt$mainframe_id,
      maximum_working_set_p: ^jmt$working_set_size,
      message_column: integer,
      name_value_p: ^ost$name,
      operator_action_posted_p: ^boolean,
      os_date_time_p: ^ost$date_time,
      output_disposition_key_p: ^jmt$output_disposition_keys,
      output_disposition_path_p: ^fst$path,
      output_state_p: ^jmt$output_state,
      packet_number: ost$positive_integers,
      page_faults_p: ^jmt$page_faults,
      qfile_state_p: ^jmt$qfile_state,
      remote_host_directive_p: ^jmt$remote_host_directive,
      result_index: ost$positive_integers,
      results_p: ^jmt$results,
      result_p: ^jmt$attribute_value,
      ring_p: ^ost$ring,
      site_information_p: ^jmt$site_information,
      sru_limit_p: ^jmt$sru_limit,
      status_p: ^ost$status,
      system_file_name_p: ^jmt$system_supplied_name,
      system_job_name_p: ^jmt$system_supplied_name,
      time_increment_p: ^jmt$time_increment,
      user_information_p: ^jmt$user_information,
      vertical_print_density_p: ^jmt$vertical_print_density;


    status.normal := TRUE;

    NEXT results_p: [1 .. number_of_packets_in_sequence] IN user_work_area_p;
    IF results_p = NIL THEN
      osp$set_status_condition (jme$work_area_too_small, status);
      RETURN; {----->
    IFEND;

{copy_the_data_for_each_packet
    FOR packet_number := 1 TO number_of_packets_in_sequence DO
      NEXT results_p^ [packet_number]: [1 .. number_of_keys] IN user_work_area_p;
      IF results_p^ [packet_number] = NIL THEN
        osp$set_status_condition (jme$work_area_too_small, status);
        RETURN; {----->
      IFEND;

{  fill_in_each_result_field
      FOR result_index := 1 TO number_of_keys DO
        result_p := ^results_p^ [packet_number]^ [result_index];
        result_p^.key := results_keys_p^ [result_index];
        CASE results_keys_p^ [result_index] OF

        = jmc$application_attributes_1 .. jmc$application_attributes_10 =
          NEXT application_attribute_size_p IN jm_work_area_p;
          IF application_attribute_size_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.application_attributes.size := application_attribute_size_p^;
          IF application_attribute_size_p^ > 0 THEN
            NEXT application_attribute_source_p: [[REP application_attribute_size_p^ OF cell]] IN
                  jm_work_area_p;
            IF application_attribute_source_p = NIL THEN
              osp$set_status_condition (jme$work_area_too_small, status);
              RETURN; {----->
            IFEND;
            NEXT application_attribute_dest_p: [[REP application_attribute_size_p^ OF cell]] IN
                  user_work_area_p;
            ;
            IF application_attribute_dest_p = NIL THEN
              osp$set_status_condition (jme$work_area_too_small, status);
              RETURN; {----->
            IFEND;

            result_p^.application_attributes.attributes_p := application_attribute_dest_p;
            i#move (application_attribute_source_p, application_attribute_dest_p,
                  application_attribute_size_p^);
          IFEND;

        = jmc$application_name =
          NEXT name_value_p IN jm_work_area_p;
          IF name_value_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.application_name := name_value_p^;

        = jmc$application_status =
          NEXT status_p IN jm_work_area_p;
          IF status_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          NEXT result_p^.application_status IN user_work_area_p;
          IF result_p^.application_status = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.application_status^ := status_p^;

        = jmc$client_mainframe_id =
          NEXT mainframe_id_p IN jm_work_area_p;
          IF mainframe_id_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.client_mainframe_id := mainframe_id_p^;

        = jmc$comment_banner =
          NEXT name_value_p IN jm_work_area_p;
          IF name_value_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.comment_banner := name_value_p^;

        = jmc$control_family =
          NEXT name_value_p IN jm_work_area_p;
          IF name_value_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.control_family := name_value_p^;

        = jmc$control_user =
          NEXT name_value_p IN jm_work_area_p;
          IF name_value_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.control_user := name_value_p^;

        = jmc$copies =
          NEXT copies_p IN jm_work_area_p;
          IF copies_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.copies := copies_p^;

        = jmc$copies_printed =
          NEXT copies_p IN jm_work_area_p;
          IF copies_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.copies_printed := copies_p^;

        = jmc$cpu_time_limit =
          NEXT cpu_time_limit_p IN jm_work_area_p;
          IF cpu_time_limit_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.cpu_time_limit := cpu_time_limit_p^;

        = jmc$cpu_time_used =
          NEXT cpu_time_used_p IN jm_work_area_p;
          IF cpu_time_used_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.cpu_time_used := cpu_time_used_p^;

        = jmc$data_mode =
          NEXT data_mode_p IN jm_work_area_p;
          IF data_mode_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.data_mode := data_mode_p^;

        = jmc$deferred_by_application =
          NEXT boolean_p IN jm_work_area_p;
          IF boolean_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.deferred_by_application := boolean_p^;

        = jmc$deferred_by_operator =
          NEXT boolean_p IN jm_work_area_p;
          IF boolean_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.deferred_by_operator := boolean_p^;

        = jmc$deferred_by_user =
          NEXT boolean_p IN jm_work_area_p;
          IF boolean_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.deferred_by_user := boolean_p^;

        = jmc$destination =
          NEXT name_value_p IN jm_work_area_p;
          IF name_value_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.destination := name_value_p^;

        = jmc$device =
          NEXT name_value_p IN jm_work_area_p;
          IF name_value_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.device := name_value_p^;

        = jmc$device_type =
          NEXT device_type_p IN jm_work_area_p;
          IF device_type_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.device_type := device_type_p^;

        = jmc$display_message =
          NEXT display_message_p IN jm_work_area_p;
          IF display_message_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          FOR message_column := 1 TO display_message_p^.size DO
            CASE display_message_p^.value (message_column) OF
            = $CHAR (0) .. $CHAR (31), $CHAR (127) =
              display_message_p^.value (message_column) := '?';
            ELSE
              ;
            CASEND;
          FOREND;
          NEXT result_p^.display_message IN user_work_area_p;
          IF result_p^.display_message = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.display_message^ := display_message_p^;

        = jmc$earliest_print_time =
          NEXT date_time_p IN jm_work_area_p;
          IF date_time_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.earliest_print_time := date_time_p^;

        = jmc$earliest_run_time =
          NEXT date_time_p IN jm_work_area_p;
          IF date_time_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.earliest_run_time := date_time_p^;

        = jmc$external_characteristics =
          NEXT external_characteristics_p IN jm_work_area_p;
          IF external_characteristics_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.external_characteristics := external_characteristics_p^;

        = jmc$file_position =
          NEXT file_position_p IN jm_work_area_p;
          IF file_position_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.file_position := file_position_p^;

        = jmc$file_size =
          NEXT file_size_p IN jm_work_area_p;
          IF file_size_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.file_size := file_size_p^;

        = jmc$forms_code =
          NEXT forms_code_p IN jm_work_area_p;
          IF forms_code_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.forms_code := forms_code_p^;

        = jmc$input_file_location =
          NEXT input_file_location_p IN jm_work_area_p;
          IF input_file_location_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.input_file_location := input_file_location_p^;

        = jmc$internal_index =
          NEXT internal_index_p IN jm_work_area_p;
          IF internal_index_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.internal_index := internal_index_p^;

        = jmc$job_abort_disposition =
          NEXT job_abort_disposition_p IN jm_work_area_p;
          IF job_abort_disposition_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.job_abort_disposition := job_abort_disposition_p^;

        = jmc$job_category_list =
          NEXT job_category_count_p IN jm_work_area_p;
          IF job_category_count_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          NEXT job_category_list_p IN jm_work_area_p;
          IF job_category_list_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.job_category_list.category_count := job_category_count_p^;
          IF job_category_count_p^ > 0 THEN
            NEXT result_p^.job_category_list.category_list: [1 .. job_category_count_p^] IN user_work_area_p;
            IF result_p^.job_category_list.category_list = NIL THEN
              osp$set_status_condition (jme$work_area_too_small, status);
              RETURN; {----->
            IFEND;
            FOR job_category_index := 1 TO job_category_count_p^ DO
              result_p^.job_category_list.category_list^ [job_category_index] :=
                    job_category_list_p^ [job_category_index];
            FOREND;
          IFEND;

        = jmc$job_class =
          NEXT name_value_p IN jm_work_area_p;
          IF name_value_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.job_class := name_value_p^;

        = jmc$job_class_position =
          NEXT job_class_position_p IN jm_work_area_p;
          IF job_class_position_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.job_class_position := job_class_position_p^;

        = jmc$job_deferred_by_operator =
          NEXT boolean_p IN jm_work_area_p;
          IF boolean_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.job_deferred_by_operator := boolean_p^;

        = jmc$job_deferred_by_user =
          NEXT boolean_p IN jm_work_area_p;
          IF boolean_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.job_deferred_by_user := boolean_p^;

        = jmc$job_destination_family =
          NEXT name_value_p IN jm_work_area_p;
          IF name_value_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.job_destination_family := name_value_p^;

        = jmc$job_destination_usage =
          NEXT name_value_p IN jm_work_area_p;
          IF name_value_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.job_destination_usage := name_value_p^;

        = jmc$job_execution_ring =
          NEXT ring_p IN jm_work_area_p;
          IF ring_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.job_execution_ring := ring_p^;

        = jmc$job_initiation_time =
          NEXT job_initiation_time_p IN jm_work_area_p;
          IF job_initiation_time_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.job_initiation_time := job_initiation_time_p^;

        = jmc$job_mode =
          NEXT job_mode_p IN jm_work_area_p;
          IF job_mode_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.job_mode := job_mode_p^;

        = jmc$job_qualifier_list =
          NEXT job_qualifier_list_p: [1 .. jmc$maximum_job_qualifiers] IN jm_work_area_p;
          IF job_qualifier_list_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          NEXT result_p^.job_qualifier_list: [1 .. jmc$maximum_job_qualifiers] IN user_work_area_p;
          IF result_p^.job_qualifier_list = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.job_qualifier_list^ := job_qualifier_list_p^;

        = jmc$job_recovery_disposition =
          NEXT job_recovery_disposition_p IN jm_work_area_p;
          IF job_recovery_disposition_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.job_recovery_disposition := job_recovery_disposition_p^;

        = jmc$job_state =
          NEXT job_state_p IN jm_work_area_p;
          IF job_state_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.job_state := job_state_p^;

        = jmc$job_size =
          NEXT job_size_p IN jm_work_area_p;
          IF job_size_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.job_size := job_size_p^;

        = jmc$job_submission_time =
          NEXT os_date_time_p IN jm_work_area_p;
          IF os_date_time_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.job_submission_time := os_date_time_p^;

        = jmc$latest_print_time =
          NEXT date_time_p IN jm_work_area_p;
          IF date_time_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.latest_print_time := date_time_p^;

        = jmc$latest_run_time =
          NEXT date_time_p IN jm_work_area_p;
          IF date_time_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.latest_run_time := date_time_p^;

        = jmc$login_account =
          NEXT name_value_p IN jm_work_area_p;
          IF name_value_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.login_account := name_value_p^;

        = jmc$login_family =
          NEXT name_value_p IN jm_work_area_p;
          IF name_value_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.login_family := name_value_p^;

        = jmc$login_project =
          NEXT name_value_p IN jm_work_area_p;
          IF name_value_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.login_project := name_value_p^;

        = jmc$login_user =
          NEXT name_value_p IN jm_work_area_p;
          IF name_value_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.login_user := name_value_p^;

        = jmc$magnetic_tape_limit =
          NEXT magnetic_tape_limit_p IN jm_work_area_p;
          IF magnetic_tape_limit_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.magnetic_tape_limit := magnetic_tape_limit_p^;

        = jmc$maximum_working_set =
          NEXT maximum_working_set_p IN jm_work_area_p;
          IF maximum_working_set_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.maximum_working_set := maximum_working_set_p^;

        = jmc$null_attribute =
          ;

        = jmc$operator_action_posted =
          NEXT operator_action_posted_p IN jm_work_area_p;
          IF operator_action_posted_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.operator_action_posted := operator_action_posted_p^;

        = jmc$origin_application_name =
          NEXT name_value_p IN jm_work_area_p;
          IF name_value_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.origin_application_name := name_value_p^;

        = jmc$output_class =
          NEXT name_value_p IN jm_work_area_p;
          IF name_value_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.output_class := name_value_p^;

        = jmc$output_deferred_by_operator =
          NEXT boolean_p IN jm_work_area_p;
          IF boolean_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.output_deferred_by_operator := boolean_p^;

        = jmc$output_deferred_by_user =
          NEXT boolean_p IN jm_work_area_p;
          IF boolean_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.output_deferred_by_user := boolean_p^;

        = jmc$output_destination =
          NEXT name_value_p IN jm_work_area_p;
          IF name_value_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.output_destination := name_value_p^;

        = jmc$output_destination_family = { operator_family
          NEXT name_value_p IN jm_work_area_p;
          IF name_value_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.output_destination_family := name_value_p^;

        = jmc$output_destination_usage =
          NEXT name_value_p IN jm_work_area_p;
          IF name_value_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.output_destination_usage := name_value_p^;

        = jmc$output_disposition =
          NEXT output_disposition_key_p IN jm_work_area_p;
          IF output_disposition_key_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          NEXT output_disposition_path_p IN jm_work_area_p;
          IF output_disposition_path_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.output_disposition.key := output_disposition_key_p^;
          IF output_disposition_key_p^ = jmc$standard_output_path THEN
            NEXT result_p^.output_disposition.standard_output_path IN user_work_area_p;
            IF result_p^.output_disposition.standard_output_path = NIL THEN
              osp$set_status_condition (jme$work_area_too_small, status);
              RETURN; {----->
            IFEND;
            result_p^.output_disposition.standard_output_path^ := output_disposition_path_p^;
          ELSEIF output_disposition_key_p^ = jmc$wait_queue_path THEN
            result_p^.output_disposition.wait_queue_path := NIL;
          IFEND;

        = jmc$output_priority =
          NEXT name_value_p IN jm_work_area_p;
          IF name_value_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.output_priority := name_value_p^;

        = jmc$output_state =
          NEXT output_state_p IN jm_work_area_p;
          IF output_state_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.output_state := output_state_p^;

        = jmc$output_submission_time =
          NEXT os_date_time_p IN jm_work_area_p;
          IF os_date_time_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.output_submission_time := os_date_time_p^;

        = jmc$page_faults =
          NEXT page_faults_p IN jm_work_area_p;
          IF page_faults_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.page_faults := page_faults_p^;

        = jmc$purge_delay =
          NEXT time_increment_p IN jm_work_area_p;
          IF time_increment_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          NEXT result_p^.purge_delay IN user_work_area_p;
          IF result_p^.purge_delay = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.purge_delay^ := time_increment_p^;

        = jmc$qfile_state =
          NEXT qfile_state_p IN jm_work_area_p;
          IF qfile_state_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.qfile_state := qfile_state_p^;

        = jmc$remote_host_directive =
          NEXT remote_host_directive_p IN jm_work_area_p;
          IF remote_host_directive_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          NEXT result_p^.remote_host_directive IN user_work_area_p;
          IF result_p^.remote_host_directive = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.remote_host_directive^ := remote_host_directive_p^;

        = jmc$routing_banner =
          NEXT name_value_p IN jm_work_area_p;
          IF name_value_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.routing_banner := name_value_p^;

        = jmc$server_mainframe_id =
          NEXT mainframe_id_p IN jm_work_area_p;
          IF mainframe_id_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.server_mainframe_id := mainframe_id_p^;

        = jmc$site_information =
          NEXT site_information_p IN jm_work_area_p;
          IF site_information_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          NEXT result_p^.site_information IN user_work_area_p;
          IF result_p^.site_information = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.site_information^ := site_information_p^;

        = jmc$sru_limit =
          NEXT sru_limit_p IN jm_work_area_p;
          IF sru_limit_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.sru_limit := sru_limit_p^;

        = jmc$station =
          NEXT name_value_p IN jm_work_area_p;
          IF name_value_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.station := name_value_p^;

        = jmc$station_operator = { operator_user
          NEXT name_value_p IN jm_work_area_p;
          IF name_value_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.station_operator := name_value_p^;

        = jmc$system_file_name =
          NEXT system_file_name_p IN jm_work_area_p;
          IF system_file_name_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.system_file_name := system_file_name_p^;

        = jmc$system_job_name =
          NEXT system_job_name_p IN jm_work_area_p;
          IF system_job_name_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.system_job_name := system_job_name_p^;

        = jmc$user_file_name =
          NEXT name_value_p IN jm_work_area_p;
          IF name_value_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.user_file_name := name_value_p^;

        = jmc$user_information =
          NEXT user_information_p IN jm_work_area_p;
          IF user_information_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          NEXT result_p^.user_information IN user_work_area_p;
          IF result_p^.user_information = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.user_information^ := user_information_p^;

        = jmc$user_job_name =
          NEXT name_value_p IN jm_work_area_p;
          IF name_value_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.user_job_name := name_value_p^;

        = jmc$vertical_print_density =
          NEXT vertical_print_density_p IN jm_work_area_p;
          IF vertical_print_density_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.vertical_print_density := vertical_print_density_p^;

        = jmc$vfu_load_procedure =
          NEXT name_value_p IN jm_work_area_p;
          IF name_value_p = NIL THEN
            osp$set_status_condition (jme$work_area_too_small, status);
            RETURN; {----->
          IFEND;
          result_p^.vfu_load_procedure := name_value_p^;

        ELSE
        CASEND;
      FOREND;
    FOREND;

  PROCEND jmp$copy_seq_to_result_array;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL] jmp$get_data_packet_size', EJECT ??

{ PURPOSE:
{   The purpose of this request is to get the size of a group of result keys.
{   The result keys are input or output queue file attributes.

  PROCEDURE [XDCL] jmp$get_data_packet_size
    (    results_keys_p: ^jmt$results_keys;
     VAR data_packet_size: ost$segment_length;
     VAR status: ost$status);

    VAR
      application_attributes_found: boolean,
      result_index: ost$non_negative_integers,
      scl_name: ost$name;

    status.normal := TRUE;
    data_packet_size := 0;
    application_attributes_found := FALSE;

    FOR result_index := 1 TO UPPERBOUND (results_keys_p^) DO
      CASE results_keys_p^ [result_index] OF
      = jmc$application_attributes_1, jmc$application_attributes_2, jmc$application_attributes_3,
            jmc$application_attributes_4, jmc$application_attributes_5, jmc$application_attributes_6,
            jmc$application_attributes_7, jmc$application_attributes_8, jmc$application_attributes_9,
            jmc$application_attributes_10 =
        data_packet_size := data_packet_size + #SIZE (jmt$qfile_appl_attr_size);
        IF NOT application_attributes_found THEN
          data_packet_size := data_packet_size + jmc$max_qfile_appl_attr_size;
          application_attributes_found := TRUE;
        IFEND;
      = jmc$application_name, jmc$control_family, jmc$control_user, jmc$job_destination_family,
            jmc$login_account, jmc$login_family, jmc$login_project, jmc$login_user,
            jmc$origin_application_name, jmc$output_destination, jmc$output_destination_family
            { operator_family } , jmc$destination =
        data_packet_size := data_packet_size + #SIZE (ost$name);
      = jmc$application_status =
        data_packet_size := data_packet_size + #SIZE (ost$status);
      = jmc$client_mainframe_id, jmc$server_mainframe_id =
        data_packet_size := data_packet_size + #SIZE (pmt$mainframe_id);
      = jmc$comment_banner =
        data_packet_size := data_packet_size + #SIZE (jmt$output_comment_banner);
      = jmc$copies, jmc$copies_printed =
        data_packet_size := data_packet_size + #SIZE (jmt$output_copy_count);
      = jmc$cpu_time_limit =
        data_packet_size := data_packet_size + #SIZE (jmt$cpu_time_limit);
      = jmc$cpu_time_used =
        data_packet_size := data_packet_size + #SIZE (jmt$cpu_time_used);
      = jmc$data_mode =
        data_packet_size := data_packet_size + #SIZE (jmt$data_mode);
      = jmc$device =
        data_packet_size := data_packet_size + #SIZE (jmt$output_device);
      = jmc$device_type =
        data_packet_size := data_packet_size + #SIZE (jmt$output_device_type);
      = jmc$display_message =
        data_packet_size := data_packet_size + #SIZE (jmt$display_message);
      = jmc$earliest_print_time, jmc$earliest_run_time, jmc$job_initiation_time, jmc$latest_print_time,
            jmc$latest_run_time =
        data_packet_size := data_packet_size + #SIZE (jmt$date_time);
      = jmc$external_characteristics =
        data_packet_size := data_packet_size + #SIZE (jmt$external_characteristics);
      = jmc$file_position =
        data_packet_size := data_packet_size + #SIZE (jmt$output_file_position);
      = jmc$file_size =
        data_packet_size := data_packet_size + #SIZE (jmt$output_file_size);
      = jmc$forms_code =
        data_packet_size := data_packet_size + #SIZE (jmt$forms_code);
      = jmc$input_file_location =
        data_packet_size := data_packet_size + #SIZE (jmt$input_file_location);
      = jmc$internal_index =
        data_packet_size := data_packet_size + #SIZE (integer);
      = jmc$job_abort_disposition =
        data_packet_size := data_packet_size + #SIZE (jmt$job_abort_disposition);
      = jmc$job_category_list =
        data_packet_size := data_packet_size + #SIZE (jmt$job_category_count) +
              #SIZE (jmt$full_job_category_list);
      = jmc$job_class =
        data_packet_size := data_packet_size + #SIZE (jmt$job_class_name);
      = jmc$job_class_position =
        data_packet_size := data_packet_size + #SIZE (jmt$job_count_range);
      = jmc$job_deferred_by_operator, jmc$job_deferred_by_user, jmc$operator_action_posted,
            jmc$output_deferred_by_operator, jmc$output_deferred_by_user, jmc$deferred_by_operator,
            jmc$deferred_by_application, jmc$deferred_by_user =
        data_packet_size := data_packet_size + #SIZE (boolean);
      = jmc$job_destination_usage, jmc$output_destination_usage =
        data_packet_size := data_packet_size + #SIZE (jmt$destination_usage);
      = jmc$job_execution_ring =
        data_packet_size := data_packet_size + #SIZE (ost$ring);
      = jmc$job_mode =
        data_packet_size := data_packet_size + #SIZE (jmt$job_mode);
      = jmc$job_qualifier_list =
        data_packet_size := data_packet_size + #SIZE (jmt$job_qualifier_list:
              [1 .. jmc$maximum_job_qualifiers]);
      = jmc$job_recovery_disposition =
        data_packet_size := data_packet_size + #SIZE (jmt$job_recovery_disposition);
      = jmc$job_state =
        data_packet_size := data_packet_size + #SIZE (jmt$job_state);
      = jmc$job_size =
        data_packet_size := data_packet_size + #SIZE (jmt$job_size);
      = jmc$job_submission_time, jmc$output_submission_time =
        data_packet_size := data_packet_size + #SIZE (ost$date_time);
      = jmc$magnetic_tape_limit =
        data_packet_size := data_packet_size + #SIZE (jmt$magnetic_tape_limit);
      = jmc$maximum_working_set =
        data_packet_size := data_packet_size + #SIZE (jmt$working_set_size);
      = jmc$null_attribute =
        ;
      = jmc$output_class =
        data_packet_size := data_packet_size + #SIZE (jmt$output_class_name);
      = jmc$output_disposition =
        data_packet_size := data_packet_size + #SIZE (jmt$output_disposition_keys) + #SIZE (fst$path);
      = jmc$output_priority =
        data_packet_size := data_packet_size + #SIZE (jmt$output_priority);
      = jmc$output_state =
        data_packet_size := data_packet_size + #SIZE (jmt$output_state);
      = jmc$page_faults =
        data_packet_size := data_packet_size + #SIZE (jmt$page_faults);
      = jmc$purge_delay =
        data_packet_size := data_packet_size + #SIZE (jmt$time_increment);
      = jmc$qfile_state =
        data_packet_size := data_packet_size + #SIZE (jmt$qfile_state);
      = jmc$remote_host_directive =
        data_packet_size := data_packet_size + #SIZE (jmt$remote_host_directive);
      = jmc$routing_banner =
        data_packet_size := data_packet_size + #SIZE (jmt$output_routing_banner);
      = jmc$site_information =
        data_packet_size := data_packet_size + #SIZE (jmt$site_information);
      = jmc$sru_limit =
        data_packet_size := data_packet_size + #SIZE (jmt$sru_limit);
      = jmc$station =
        data_packet_size := data_packet_size + #SIZE (jmt$station);
      = jmc$station_operator = { operator_user
        data_packet_size := data_packet_size + #SIZE (jmt$station_operator);
      = jmc$system_file_name, jmc$system_job_name =
        data_packet_size := data_packet_size + #SIZE (jmt$system_supplied_name);
      = jmc$user_file_name, jmc$user_job_name =
        data_packet_size := data_packet_size + #SIZE (jmt$user_supplied_name);
      = jmc$user_information =
        data_packet_size := data_packet_size + #SIZE (jmt$user_information);
      = jmc$vertical_print_density =
        data_packet_size := data_packet_size + #SIZE (jmt$vertical_print_density);
      = jmc$vfu_load_procedure =
        data_packet_size := data_packet_size + #SIZE (jmt$vfu_load_procedure);
      ELSE

{ Should never get here since the caller validates the result keys.

        jmp$get_attribute_name (results_keys_p^ [result_index], scl_name);
        osp$set_status_abnormal (jmc$job_management_id, jme$invalid_parameter, scl_name, status);
        osp$append_status_parameter (osc$status_parameter_delimiter, 'RESULTS_KEYS_P', status);
        osp$append_status_parameter (osc$status_parameter_delimiter, 'JMP$GET_DATA_PACKET_SIZE', status);
        RETURN; {----->
      CASEND;
    FOREND;

  PROCEND jmp$get_data_packet_size;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL] jmp$get_jm_work_area', EJECT ??
*copyc jmh$get_jm_work_area

  PROCEDURE [XDCL] jmp$get_jm_work_area
    (VAR jm_work_area_p: ^jmt$work_area;
     VAR status: ost$status);

    VAR
      segment_pointer: amt$segment_pointer,
      user_segment_attributes: array [1 .. 1] of mmt$user_attribute_descriptor;

    status.normal := TRUE;

    IF jmv$job_management_work_area_p = NIL THEN
      user_segment_attributes [1].keyword := mmc$ua_ring_numbers;
      user_segment_attributes [1].r1 := osc$tsrv_ring;
      user_segment_attributes [1].r2 := osc$tsrv_ring;
      mmp$create_user_segment (^user_segment_attributes, amc$sequence_pointer, mmc$as_sequential,
            segment_pointer, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;
      jmv$job_management_work_area_p := segment_pointer.sequence_pointer;
    IFEND;
    jm_work_area_p := jmv$job_management_work_area_p;

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

  PROCEDURE [XDCL, #GATE] jmp$set_job_resource_condition
    (    condition: jmt$job_resource_condition;
     VAR status: ost$status);

    status.normal := TRUE;
    jmv$job_resource_condition := condition;

  PROCEND jmp$set_job_resource_condition;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL] jmp$validate_status_options', EJECT ??

{ PURPOSE:
{   The purpose of this request is to validate input or output queue file
{   status options and their values and to reduce the set of options to only
{   those that are necesary.

  PROCEDURE [XDCL] jmp$validate_status_options
    (    request_name: string ( * );
         parameter_name: string ( * );
         options_seq_p: ^SEQ ( * );
         caller_privileged: boolean;
     VAR privileged_job: boolean;
     VAR user_identification: ost$user_identification;
     VAR continue_request_to_servers: boolean;
     VAR number_of_valid_options: ost$non_negative_integers;
     VAR target_options_seq_p: ^jmt$work_area;
     VAR status: ost$status);

    TYPE
      valid_requests = (jmp$get_job_status, jmp$get_output_status, jmp$get_qfile_status);

    VAR
      option_valid_for_request: [STATIC, READ, oss$job_paged_literal] array [valid_requests] of
            jmt$attribute_keys_set :=
{jmp$get_job_status}
      [$jmt$attribute_keys_set [jmc$continue_request_to_servers, jmc$control_family, jmc$control_user,
            jmc$job_deferred_by_operator, jmc$job_deferred_by_user, jmc$include_the_system_job,
            jmc$job_mode_set, jmc$job_state_set, jmc$login_family, jmc$login_user, jmc$name_list,
            jmc$null_attribute, jmc$privilege, jmc$user_identification],
{jmp$get_output_status}
      $jmt$attribute_keys_set [jmc$continue_request_to_servers, jmc$control_family, jmc$control_user,
            jmc$login_family, jmc$login_user, jmc$name_list, jmc$null_attribute,
            jmc$output_deferred_by_operator, jmc$output_deferred_by_user, jmc$output_destination_usage,
            jmc$output_state_set, jmc$privilege, jmc$system_job_name, jmc$user_identification,
            jmc$user_job_name],
{jmp$get_qfile_status}
      $jmt$attribute_keys_set [jmc$application_name, jmc$continue_request_to_servers, jmc$control_family,
            jmc$control_user, jmc$deferred_by_application, jmc$deferred_by_operator, jmc$deferred_by_user,
            jmc$login_family, jmc$login_user, jmc$null_attribute, jmc$privilege, jmc$qfile_state_set,
            jmc$system_supplied_name_list, jmc$user_identification]];

    VAR
      good_name: jmt$name,
      name_count_p: ^ost$non_negative_integers,
      name_index: ost$positive_integers,
      number_of_options: ost$non_negative_integers,
      option_index: ost$positive_integers,
      options_p: ^jmt$attribute_values,
      option_p: ^jmt$attribute_value,
      request: valid_requests,
      scl_name: ost$name,
      seq_p: ^SEQ ( * ),
      specified_keys: jmt$attribute_keys_set,
      valid_name: boolean,
      valid_option_index: ost$non_negative_integers,
      valid_options_p: ^jmt$attribute_values;

    status.normal := TRUE;
    continue_request_to_servers := FALSE;
    number_of_valid_options := 0;

    IF options_seq_p <> NIL THEN
      seq_p := options_seq_p;
      number_of_options := #SIZE (seq_p^) DIV #SIZE (jmt$attribute_values: [1 .. 1]);
      IF number_of_options > 0 THEN
        NEXT options_p: [1 .. number_of_options] IN seq_p;

        IF request_name = jmc$get_job_status THEN
          request := jmp$get_job_status;
        ELSEIF request_name = jmc$get_output_status THEN
          request := jmp$get_output_status;
        ELSEIF request_name = jmc$get_qfile_status THEN
          request := jmp$get_qfile_status;
        ELSE
          osp$set_status_abnormal (jmc$job_management_id, jme$unknown_requestor, request_name, status);
          osp$append_status_parameter (osc$status_parameter_delimiter, 'JMP$VALIDATE_STATUS_OPTIONS', status);
          RETURN; {----->
        IFEND;

        specified_keys := $jmt$attribute_keys_set [];

        FOR option_index := 1 TO UPPERBOUND (options_p^) DO
          option_p := ^options_p^ [option_index];
          IF option_p^.key IN specified_keys THEN
            jmp$get_attribute_name (option_p^.key, scl_name);
            osp$set_status_abnormal (jmc$job_management_id, jme$duplicate_attribute_key, scl_name, status);
            osp$append_status_parameter (osc$status_parameter_delimiter, parameter_name, status);
            osp$append_status_parameter (osc$status_parameter_delimiter, request_name, status);
            RETURN; {----->
          IFEND;

          IF option_p^.key <> jmc$null_attribute THEN
            IF NOT (option_p^.key IN option_valid_for_request [request]) THEN
              jmp$get_attribute_name (option_p^.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, parameter_name, status);
              osp$append_status_parameter (osc$status_parameter_delimiter, request_name, status);
              RETURN; {----->
            IFEND;

            specified_keys := specified_keys + $jmt$attribute_keys_set [option_p^.key];
            IF (option_p^.key = jmc$continue_request_to_servers) THEN
              continue_request_to_servers := option_p^.continue_request_to_servers;
            ELSEIF (option_p^.key = jmc$privilege) THEN
              IF caller_privileged THEN
                IF option_p^.privilege = jmc$privileged THEN
                  privileged_job := TRUE;
                ELSEIF option_p^.privilege = jmc$not_privileged THEN
                  privileged_job := FALSE;
                IFEND;
              IFEND;
            ELSEIF (option_p^.key = jmc$user_identification) THEN
              IF caller_privileged THEN
                user_identification := option_p^.user_identification^;
              ELSE
                osp$force_access_violation;
              IFEND;
            ELSE
              number_of_valid_options := number_of_valid_options + 1;
            IFEND;
          IFEND;
        FOREND;

        IF number_of_valid_options > 0 THEN
          NEXT valid_options_p: [1 .. number_of_valid_options] IN target_options_seq_p;
          valid_option_index := 0;
          FOR option_index := 1 TO UPPERBOUND (options_p^) DO
            option_p := ^options_p^ [option_index];
            CASE option_p^.key OF
            = jmc$application_name =
              clp$validate_name (option_p^.application_name, scl_name, valid_name);
              IF NOT valid_name THEN
                osp$set_status_abnormal ('CL', cle$improper_name, option_p^.application_name, status);
                RETURN; {----->
              IFEND;

              valid_option_index := valid_option_index + 1;
              valid_options_p^ [valid_option_index].key := option_p^.key;
              valid_options_p^ [valid_option_index].application_name := scl_name;

            = jmc$continue_request_to_servers, jmc$null_attribute, jmc$privilege, jmc$user_identification =
              ;

            = jmc$control_family =
              clp$validate_name (option_p^.control_family, scl_name, valid_name);
              IF NOT valid_name THEN
                osp$set_status_abnormal ('CL', cle$improper_name, option_p^.control_family, status);
                RETURN; {----->
              IFEND;

              valid_option_index := valid_option_index + 1;
              valid_options_p^ [valid_option_index].key := option_p^.key;
              valid_options_p^ [valid_option_index].control_family := scl_name;

            = jmc$control_user =
              clp$validate_name (option_p^.control_user, scl_name, valid_name);
              IF NOT valid_name THEN
                osp$set_status_abnormal ('CL', cle$improper_name, option_p^.control_user, status);
                RETURN; {----->
              IFEND;

              valid_option_index := valid_option_index + 1;
              valid_options_p^ [valid_option_index].key := option_p^.key;
              valid_options_p^ [valid_option_index].control_user := scl_name;

            = jmc$job_deferred_by_operator, jmc$job_deferred_by_user, jmc$include_the_system_job,
                  jmc$job_mode_set, jmc$job_state_set, jmc$output_deferred_by_operator,
                  jmc$output_deferred_by_user, jmc$output_state_set, jmc$deferred_by_application,
                  jmc$deferred_by_operator, jmc$deferred_by_user =
              valid_option_index := valid_option_index + 1;
              valid_options_p^ [valid_option_index] := option_p^;

            = jmc$login_family =
              clp$validate_name (option_p^.login_family, scl_name, valid_name);
              IF NOT valid_name THEN
                osp$set_status_abnormal ('CL', cle$improper_name, option_p^.login_family, status);
                RETURN; {----->
              IFEND;

              valid_option_index := valid_option_index + 1;
              valid_options_p^ [valid_option_index].key := option_p^.key;
              valid_options_p^ [valid_option_index].login_family := scl_name;

            = jmc$login_user =
              clp$validate_name (option_p^.login_user, scl_name, valid_name);
              IF NOT valid_name THEN
                osp$set_status_abnormal ('CL', cle$improper_name, option_p^.login_user, status);
                RETURN; {----->
              IFEND;

              valid_option_index := valid_option_index + 1;
              valid_options_p^ [valid_option_index].key := option_p^.key;
              valid_options_p^ [valid_option_index].login_user := scl_name;

            = jmc$name_list =
              valid_option_index := valid_option_index + 1;
              valid_options_p^ [valid_option_index].key := jmc$name_list;
              NEXT name_count_p IN target_options_seq_p;

              IF option_p^.name_list <> NIL THEN
                name_count_p^ := UPPERBOUND (options_p^ [option_index].name_list^);
                NEXT valid_options_p^ [valid_option_index].name_list: [1 .. name_count_p^] IN
                      target_options_seq_p;
                FOR name_index := 1 TO name_count_p^ DO
                  jmp$validate_name (option_p^.name_list^ [name_index], good_name, status);
                  IF NOT status.normal THEN
                    RETURN; {----->
                  IFEND;

                  valid_options_p^ [valid_option_index].name_list^ [name_index] := good_name;
                FOREND;
              ELSE
                name_count_p^ := 0;
              IFEND;

            = jmc$output_destination_usage =
              clp$validate_name (options_p^ [option_index].output_destination_usage, scl_name, valid_name);
              IF NOT valid_name THEN
                osp$set_status_abnormal ('CL', cle$improper_name, option_p^.output_destination_usage, status);
                RETURN; {----->
              IFEND;

              valid_option_index := valid_option_index + 1;
              valid_options_p^ [valid_option_index].key := option_p^.key;
              valid_options_p^ [valid_option_index].output_destination_usage := scl_name;

            = jmc$qfile_state_set =
              IF option_p^.qfile_state_set = $jmt$qfile_state_set [] THEN
                osp$set_status_condition (jme$qfile_state_is_null, status);
                RETURN; {----->
              IFEND;
              valid_option_index := valid_option_index + 1;
              valid_options_p^ [valid_option_index].key := option_p^.key;
              valid_options_p^ [valid_option_index].qfile_state_set := option_p^.qfile_state_set;

            = jmc$system_supplied_name_list =
              valid_option_index := valid_option_index + 1;
              valid_options_p^ [valid_option_index].key := jmc$system_supplied_name_list;
              NEXT name_count_p IN target_options_seq_p;

              IF option_p^.system_supplied_name_list <> NIL THEN
                name_count_p^ := UPPERBOUND (option_p^.system_supplied_name_list^);
                NEXT valid_options_p^ [valid_option_index].system_supplied_name_list: [1 .. name_count_p^] IN
                      target_options_seq_p;

                good_name.kind := jmc$system_supplied_name;
                FOR name_index := 1 TO name_count_p^ DO
                  good_name.system_supplied_name := option_p^.system_supplied_name_list^ [name_index];
                  jmp$validate_name (good_name, good_name, status);
                  IF NOT status.normal THEN
                    RETURN; {----->
                  IFEND;

                  valid_options_p^ [valid_option_index].system_supplied_name_list^ [name_index] :=
                        good_name.system_supplied_name;
                FOREND;
              ELSE
                name_count_p^ := 0;
              IFEND;

            = jmc$system_job_name =
              good_name.kind := jmc$system_supplied_name;
              good_name.system_supplied_name := option_p^.system_job_name;
              jmp$validate_name (good_name, good_name, status);
              IF NOT status.normal THEN
                RETURN; {----->
              IFEND;

              valid_option_index := valid_option_index + 1;
              valid_options_p^ [valid_option_index].key := option_p^.key;
              valid_options_p^ [valid_option_index].system_job_name := good_name.system_supplied_name;

            = jmc$user_job_name =
              clp$validate_name (option_p^.user_job_name, scl_name, valid_name);
              IF NOT valid_name THEN
                osp$set_status_abnormal ('CL', cle$improper_name, option_p^.user_job_name, status);
                RETURN; {----->
              IFEND;

              valid_option_index := valid_option_index + 1;
              valid_options_p^ [valid_option_index].key := option_p^.key;
              valid_options_p^ [valid_option_index].user_job_name := scl_name;

            ELSE
            CASEND
          FOREND;
        IFEND;
      IFEND;
    IFEND;

  PROCEND jmp$validate_status_options;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL] jmp$validate_attribute_options' ??
?? EJECT ??

{ PURPOSE:
{   The purpose of this request is to validate input or output queue file
{   attribute options and to reduce the set of options to only those that are
{   necessary.

  PROCEDURE [XDCL] jmp$validate_attribute_options
    (    request_name: string ( * );
         parameter_name: string ( * );
         options_seq_p: ^SEQ ( * );
         number_of_options_to_add: ost$non_negative_integers;
     VAR continue_request_to_servers: boolean;
     VAR number_of_valid_options: ost$non_negative_integers;
     VAR target_options_seq_p: ^jmt$work_area;
     VAR status: ost$status);

    TYPE
      valid_requests = (jmp$get_input_attributes, jmp$get_output_attributes, jmp$get_qfile_attributes);

    VAR
      option_valid_for_request: [STATIC, READ, oss$job_paged_literal] array [valid_requests] of
            jmt$attribute_keys_set := [
{jmp$get_input_attributes} $jmt$attribute_keys_set [jmc$continue_request_to_servers, jmc$control_family,
            jmc$control_user, jmc$job_deferred_by_operator, jmc$job_deferred_by_user, jmc$job_mode_set,
            jmc$job_state_set, jmc$login_family, jmc$login_user, jmc$name_list, jmc$null_attribute],
{jmp$get_output_attributes} $jmt$attribute_keys_set [jmc$continue_request_to_servers, jmc$control_family,
            jmc$control_user, jmc$login_family, jmc$login_user, jmc$name_list, jmc$null_attribute,
            jmc$output_deferred_by_operator, jmc$output_deferred_by_user, jmc$output_destination_usage,
            jmc$output_state_set, jmc$system_job_name, jmc$user_job_name],
{jmp$get_qfile_attributes} $jmt$attribute_keys_set [jmc$application_name, jmc$continue_request_to_servers,
            jmc$null_attribute, jmc$control_family, jmc$control_user, jmc$deferred_by_application,
            jmc$deferred_by_operator, jmc$deferred_by_user, jmc$login_family, jmc$login_user,
            jmc$qfile_state_set, jmc$system_supplied_name_list]];

    VAR
      name_count_p: ^ost$non_negative_integers,
      number_of_options: ost$non_negative_integers,
      option_index: ost$positive_integers,
      options_p: ^jmt$attribute_values,
      option_p: ^jmt$attribute_value,
      request: valid_requests,
      scl_name: ost$name,
      seq_p: ^SEQ ( * ),
      specified_keys: jmt$attribute_keys_set,
      status_options_p: ^jmt$attribute_values,
      valid_option_index: ost$non_negative_integers,
      valid_options_p: ^jmt$attribute_values;

    status.normal := TRUE;
    continue_request_to_servers := FALSE;
    number_of_valid_options := 0;

    IF options_seq_p <> NIL THEN
      seq_p := options_seq_p;
      number_of_options := #SIZE (seq_p^) DIV #SIZE (jmt$attribute_values: [1 .. 1]);
      IF number_of_options > 0 THEN
        NEXT options_p: [1 .. number_of_options] IN seq_p;

        IF request_name = jmc$get_input_attributes THEN
          request := jmp$get_input_attributes;
        ELSEIF request_name = jmc$get_output_attributes THEN
          request := jmp$get_output_attributes;
        ELSEIF request_name = jmc$get_qfile_attributes THEN
          request := jmp$get_qfile_attributes;
        ELSE
          osp$set_status_abnormal (jmc$job_management_id, jme$unknown_requestor, request_name, status);
          osp$append_status_parameter (osc$status_parameter_delimiter, 'JMP$VALIDATE_ATTRIBUTE_OPTIONS',
                status);
          RETURN; {----->
        IFEND;

        specified_keys := $jmt$attribute_keys_set [];

        FOR option_index := 1 TO UPPERBOUND (options_p^) DO
          option_p := ^options_p^ [option_index];
          IF option_p^.key IN specified_keys THEN
            jmp$get_attribute_name (option_p^.key, scl_name);
            osp$set_status_abnormal (jmc$job_management_id, jme$duplicate_attribute_key, scl_name, status);
            osp$append_status_parameter (osc$status_parameter_delimiter, parameter_name, status);
            osp$append_status_parameter (osc$status_parameter_delimiter, request_name, status);
            RETURN; {----->
          IFEND;

          IF option_p^.key <> jmc$null_attribute THEN
            IF NOT (option_p^.key IN option_valid_for_request [request]) THEN
              jmp$get_attribute_name (option_p^.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, parameter_name, status);
              osp$append_status_parameter (osc$status_parameter_delimiter, request_name, status);
              RETURN; {----->
            IFEND;

            specified_keys := specified_keys + $jmt$attribute_keys_set [option_p^.key];
            IF (option_p^.key = jmc$continue_request_to_servers) THEN
              continue_request_to_servers := option_p^.continue_request_to_servers;
            ELSE
              number_of_valid_options := number_of_valid_options + 1;
            IFEND;
          IFEND;
        FOREND;
      IFEND;
    IFEND;

    IF number_of_valid_options + number_of_options_to_add > 0 THEN
      NEXT valid_options_p: [1 .. number_of_valid_options + number_of_options_to_add] IN target_options_seq_p;
      valid_option_index := 0;
      IF number_of_valid_options > 0 THEN
        FOR option_index := 1 TO UPPERBOUND (options_p^) DO
          option_p := ^options_p^ [option_index];
          CASE option_p^.key OF
          = jmc$continue_request_to_servers, jmc$null_attribute =
            ;

          = jmc$name_list =
            valid_option_index := valid_option_index + 1;
            valid_options_p^ [valid_option_index].key := jmc$name_list;
            NEXT name_count_p IN target_options_seq_p;
            IF option_p^.name_list <> NIL THEN
              name_count_p^ := UPPERBOUND (option_p^.name_list^);
              NEXT valid_options_p^ [valid_option_index].name_list: [1 .. name_count_p^] IN
                    target_options_seq_p;
              valid_options_p^ [valid_option_index].name_list^ := option_p^.name_list^;
            ELSE
              name_count_p^ := 0;
            IFEND;

          = jmc$system_supplied_name_list =
            valid_option_index := valid_option_index + 1;
            valid_options_p^ [valid_option_index].key := jmc$system_supplied_name_list;
            NEXT name_count_p IN target_options_seq_p;

            IF option_p^.system_supplied_name_list <> NIL THEN
              name_count_p^ := UPPERBOUND (option_p^.system_supplied_name_list^);
              NEXT valid_options_p^ [valid_option_index].system_supplied_name_list: [1 .. name_count_p^] IN
                    target_options_seq_p;
              valid_options_p^ [valid_option_index].system_supplied_name_list^ :=
                    option_p^.system_supplied_name_list^;
            ELSE
              name_count_p^ := 0;
            IFEND;

          ELSE
            valid_option_index := valid_option_index + 1;
            valid_options_p^ [valid_option_index] := option_p^;
          CASEND;
        FOREND;
      IFEND;

      number_of_valid_options := number_of_valid_options + number_of_options_to_add;
    IFEND;

  PROCEND jmp$validate_attribute_options;
?? OLDTITLE ??
MODEND jmm$job_mgmt_misc_services;
