?? LEFT := 1, RIGHT := 110 ??
?? NEWTITLE := 'NAM/VE: Generic Transport Application Layer' ??
?? NEWTITLE := '  Global Declarations' ??
MODULE nam$gt_application_layer_r2;
*copyc nae$namve_conditions
*copyc nat$gt_job_connection
*copyc nat$gt_connection
*copyc nat$gt_job_sap
*copyc nat$gt_sap
*copyc nat$gt_sap_identifier
*copyc nlt$ta_event
*copyc oss$job_pageable
?? TITLE := '  External Procedures', EJECT ??
*copyc nlp$bm_release_message
*copyc osp$set_job_signature_lock
*copyc osp$clear_job_signature_lock
*copyc osp$executing_in_job_monitor
*copyc osp$set_status_condition
*copyc osp$test_sig_lock
*copyc syp$cycle
?? TITLE := '  Global Variables', EJECT ??
*copyc nav$network_paged_heap
*copyc osv$job_pageable_heap

  VAR
    nav$gt_job_connection_list: [XDCL, #GATE, oss$job_pageable] nat$gt_job_connection_list := [[0], 0,
          NIL];

  VAR
    nav$gt_job_sap_list: [XDCL, #GATE, oss$job_pageable] nat$gt_job_sap_list := [[0], NIL];
?? TITLE := '  [XDCL, #GATE] nap$gt_get_exclusive_to_clist', EJECT ??

  PROCEDURE [XDCL, #GATE] nap$gt_get_exclusive_to_clist;

*copy nah$gt_get_exclusive_to_clist

    osp$set_job_signature_lock (nav$gt_job_connection_list.lock);
  PROCEND nap$gt_get_exclusive_to_clist;
?? TITLE := '  [XDCL, #GATE] nap$gt_releas_exclusiv_to_clist', EJECT ??

  PROCEDURE [XDCL, #GATE] nap$gt_releas_exclusiv_to_clist;

*copy nah$gt_releas_exclusiv_to_clist

    osp$clear_job_signature_lock (nav$gt_job_connection_list.lock);
  PROCEND nap$gt_releas_exclusiv_to_clist;
?? TITLE := '  [XDCL, #GATE] nap$gt_clear_exclusive_to_clist', EJECT ??

  PROCEDURE [XDCL, #GATE] nap$gt_clear_exclusive_to_clist;

*copy nah$gt_clear_exclusive_to_clist
    VAR
      lock_status: ost$signature_lock_status;

    osp$test_sig_lock (nav$gt_job_connection_list.lock, lock_status);
    IF (lock_status = osc$sls_locked_by_current_task) THEN
      osp$clear_job_signature_lock (nav$gt_job_connection_list.lock);
    IFEND;
  PROCEND nap$gt_clear_exclusive_to_clist;
?? TITLE := '  [XDCL, #GATE] nap$gt_create_job_connection', EJECT ??

  PROCEDURE [XDCL, #GATE] nap$gt_create_job_connection (sap_id: nat$gt_sap_identifier;
        active_connection_id: nlt$cl_connection_id;
    VAR job_connection: ^nat$gt_job_connection);
*copy nah$gt_create_job_connection

    VAR
      connection: ^nat$gt_job_connection;

    REPEAT
      ALLOCATE connection IN osv$job_pageable_heap^;
      IF connection = NIL THEN
        syp$cycle;
      IFEND;
    UNTIL connection <> NIL;
    connection^.sap_id := sap_id;
    connection^.active := TRUE;
    connection^.active_connection_id := active_connection_id;
    connection^.connection_id := nav$gt_job_connection_list.connection_id_seed + 1;
    nav$gt_job_connection_list.connection_id_seed := nav$gt_job_connection_list.connection_id_seed + 1;
    connection^.next_connection := nav$gt_job_connection_list.first_connection;
    nav$gt_job_connection_list.first_connection := connection;
    job_connection := connection;
  PROCEND nap$gt_create_job_connection;
?? TITLE := '  [XDCL, #GATE] nap$gt_deactivate_job_connect', EJECT ??

  PROCEDURE [XDCL, #GATE] nap$gt_deactivate_job_connect (termination_state: nat$gt_connection_state;
      termination_event: nlt$ta_event;
      data_length: nat$data_length;
      job_connection: ^nat$gt_job_connection);
*copy nah$gt_deactivate_job_connect

    VAR
      jobb_connection: ^nat$gt_job_connection;

    jobb_connection := #ADDRESS (1, #SEGMENT (job_connection), #OFFSET (job_connection));
    jobb_connection^.active := FALSE;
    jobb_connection^.termination_state := termination_state;
    CASE jobb_connection^.termination_state OF
    = nac$gt_peer_reject, nac$gt_peer_disconnect =
      jobb_connection^.data_length := data_length;
      jobb_connection^.termination_event := termination_event;
    = nac$gt_connection_failed =
      ;
    CASEND;
  PROCEND nap$gt_deactivate_job_connect;
?? TITLE := '  [XDCL, #GATE] nap$gt_delete_job_connection', EJECT ??

  PROCEDURE [XDCL, #GATE] nap$gt_delete_job_connection (connection_id: nat$gt_connection_id);
*copy nah$gt_delete_job_connection

  VAR
    job_connection: ^^nat$gt_job_connection,
    job_connection_to_free: ^nat$gt_job_connection;

    job_connection := ^nav$gt_job_connection_list.first_connection;
    WHILE ((job_connection^ <> NIL) AND (job_connection^^.connection_id <> connection_id)) DO
      job_connection := ^job_connection^^.next_connection;
    WHILEND;
    CASE job_connection^^.termination_state OF
    = nac$gt_peer_disconnect =
      nlp$bm_release_message (job_connection^^.termination_event.osi_disconnect.data);
    ELSE
    CASEND;
    job_connection_to_free := job_connection^;
    job_connection^ := job_connection^^.next_connection;
    FREE job_connection_to_free IN osv$job_pageable_heap^;
  PROCEND nap$gt_delete_job_connection;
?? TITLE := '  [XDCL, #GATE] nap$gt_get_exclusive_to_slist', EJECT ??

  PROCEDURE [XDCL, #GATE] nap$gt_get_exclusive_to_slist;

*copy nah$gt_get_exclusive_to_slist

    osp$set_job_signature_lock (nav$gt_job_sap_list.lock);
  PROCEND nap$gt_get_exclusive_to_slist;
?? TITLE := '  [XDCL, #GATE] nap$gt_releas_exclusiv_to_slist', EJECT ??

  PROCEDURE [XDCL, #GATE] nap$gt_releas_exclusiv_to_slist;

*copy nah$gt_releas_exclusiv_to_slist

    osp$clear_job_signature_lock (nav$gt_job_sap_list.lock);
  PROCEND nap$gt_releas_exclusiv_to_slist;
?? TITLE := '  [XDCL, #GATE] nap$gt_clear_exclusive_to_slist', EJECT ??

  PROCEDURE [XDCL, #GATE] nap$gt_clear_exclusive_to_slist;

*copy nah$gt_clear_exclusive_to_slist
    VAR
      lock_status: ost$signature_lock_status;

    osp$test_sig_lock (nav$gt_job_sap_list.lock, lock_status);
    IF (lock_status = osc$sls_locked_by_current_task) THEN
      osp$clear_job_signature_lock (nav$gt_job_sap_list.lock);
    IFEND;
  PROCEND nap$gt_clear_exclusive_to_slist;
?? TITLE := '  [XDCL, #GATE] nap$gt_add_job_sap', EJECT ??

  PROCEDURE [XDCL, #GATE] nap$gt_add_job_sap (sap: ^nat$gt_job_sap);
*copy nah$gt_add_job_sap

    osp$set_job_signature_lock (nav$gt_job_sap_list.lock);
    sap^.next_sap := nav$gt_job_sap_list.first_sap;
    nav$gt_job_sap_list.first_sap := sap;
    osp$clear_job_signature_lock (nav$gt_job_sap_list.lock);
  PROCEND nap$gt_add_job_sap;
?? TITLE := '  [XDCL, #GATE] nap$gt_delete_job_sap', EJECT ??

  PROCEDURE [XDCL, #GATE] nap$gt_delete_job_sap (sap_id: nat$gt_sap_identifier);
*copy nah$gt_delete_job_sap

  VAR
    job_sap: ^^nat$gt_job_sap;

    job_sap := ^nav$gt_job_sap_list.first_sap;
    WHILE ((job_sap^ <> NIL) AND (job_sap^^.sap_id <> sap_id)) DO
      job_sap := ^job_sap^^.next_sap;
    WHILEND;
    job_sap^ := job_sap^^.next_sap;
  PROCEND nap$gt_delete_job_sap;
?? TITLE := '  [XDCL, #GATE] nap$gt_close_job_connections', EJECT ??

  PROCEDURE [XDCL, #GATE] nap$gt_close_job_connections (VAR status: ost$status);
*copy nah$gt_close_job_connections

    VAR
      job_connection: ^^nat$gt_job_connection,
      lock_status: ost$signature_lock_status;

    status.normal := TRUE;
    osp$test_sig_lock (nav$gt_job_connection_list.lock, lock_status);
    IF (lock_status = osc$sls_not_locked) OR
          ((lock_status = osc$sls_locked_by_another_task) AND (NOT osp$executing_in_job_monitor())) THEN
      osp$set_job_signature_lock (nav$gt_job_connection_list.lock);
      job_connection := ^nav$gt_job_connection_list.first_connection;
      WHILE (job_connection^ <> NIL) DO
        IF job_connection^^.active  THEN
          job_connection^^.active := FALSE;
          job_connection^^.termination_state := nac$gt_connection_failed;
        IFEND;
        job_connection := ^job_connection^^.next_connection;
      WHILEND;
      osp$clear_job_signature_lock (nav$gt_job_connection_list.lock);
    ELSE
      osp$set_status_condition(nae$job_recovery,status);
    IFEND;
  PROCEND nap$gt_close_job_connections;
?? TITLE := '  [XDCL, #GATE] nap$gt_delete_job_saps', EJECT ??

  PROCEDURE [XDCL, #GATE] nap$gt_delete_job_saps;
*copy nah$gt_delete_job_saps

    VAR
      job_sap: ^^nat$gt_job_sap,
      sap_to_free: ^nat$gt_job_sap,
      lock_status: ost$signature_lock_status;

    osp$test_sig_lock (nav$gt_job_sap_list.lock, lock_status);
    IF ((lock_status = osc$sls_not_locked) OR (lock_status = osc$sls_locked_by_another_task)) THEN
      osp$set_job_signature_lock (nav$gt_job_sap_list.lock);
    IFEND;
    nav$gt_job_sap_list.first_sap := NIL;
    osp$clear_job_signature_lock (nav$gt_job_sap_list.lock);
  PROCEND nap$gt_delete_job_saps;
MODEND nam$gt_application_layer_r2;
