.bm 8
.fm 4
.bt $Copyright by SAP AG, 2003$$Page %$
.tm 12
.hm 6
.hs 3
.tt 1 $SQL$Project Distributed Database System$VAK93$
.tt 2 $$$
.tt 3 $ElkeZ$DBS_Commands$2000-11-24$
***********************************************************
.nf
 
 
    ========== licence begin  GPL
    Copyright (C) 2000 SAP AG
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License
    as published by the Free Software Foundation; either version 2
    of the License, or (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
    ========== licence end
 
.fo
.nf
.sp
Module  : DBS_Commands
=========
.sp
Purpose : This module gets the SQL_PACKETs from the
          run-time environment, takes care of their processing
          and passes the results to the run-time environment.
.CM *-END-* purpose -------------------------------------
.sp
.cp 3
Define  :
 
        PROCEDURE
              a93_sending (VAR acv  : tak_all_command_glob;
                    start_time_sec  : tsp_int4;
                    start_time_msec : tsp_int4;
                    VAR retcode     : tsp1_comm_error);
 
        PROCEDURE
              a93_user_commands (VAR acv : tak_all_command_glob;
                    VAR alloc_ok   : boolean;
                    VAR do_release : boolean);
 
        FUNCTION
              a93cancelled (acv_addr : tak_acv_address) : boolean;
 
        PROCEDURE
              a93init_caches (VAR acv : tak_all_command_glob);
 
        PROCEDURE
              a93packet_vtrace (VAR t : tgg00_TransContext;
                    trace_object      : tgg_vtrace_type;
                    packet_ptr        : tsp1_packet_ptr);
 
        PROCEDURE
              a93receive (acv_addr : tak_acv_address;
                    VAR out_packet_ptr : tsp1_packet_ptr);
 
        PROCEDURE
              a93request (acv_addr  : tak_acv_address;
                    sql_packet_ptr  : tsp1_packet_ptr;
                    out_packet      : tsp1_packet_ptr;
                    out_packet_size : tsp00_Int4;
                    VAR returncode  : tsp1_comm_error);
              (* Change request 1001193, T.A. 23.10.1998 *)
 
        PROCEDURE
              a93swap_to_application (VAR packet : tsp1_packet_ptr;
                    a_mess_code      : tsp00_CodeType;
                    a_basic_code     : tsp00_CodeType;
                    a_mess_swap      : tsp00_SwapKind;
                    a_parameter_spec : tak_param_list);
 
        PROCEDURE
              a93swap_from_application (VAR acv : tak_all_command_glob);
 
        PROCEDURE
              a93swap_packet_header (VAR packet_header : tsp1_packet_header;
                    kernel_is_dest : boolean;
                    kernel_swap    : tsp_swap_kind;
                    host_swap      : tsp_swap_kind);
 
        PROCEDURE
              a93vreceive (VAR acv   : tak_all_command_glob;
                    timeout          : tsp_int4;
                    VAR alloc_ok     : boolean;
                    VAR sql_comm_err : tsp1_comm_error);
 
.CM *-END-* define --------------------------------------
.sp;.cp 3
Use     :
 
        FROM
              Scanner : VAK01;
 
        VAR
              a01_i_oldpacket      : tsp_knl_identifier;
              a01_il_b_identifier  : tsp_knl_identifier;
 
        FUNCTION
              a01swap_int2 (old : tsp_int2) : tsp_int2;
 
        FUNCTION
              a01aligned_cmd_len (len : tsp_int4) : tsp_int4;
 
        PROCEDURE
              a01swap_cmd_part (client_swap : tsp_swap_kind;
                    VAR cmd_part : tsp1_part_header);
 
      ------------------------------ 
 
        FROM
              AK_byteswap_and_locset : VAK04;
 
        PROCEDURE
              a04_info_byteswap_codetype (a_mess_swap : tsp00_SwapKind;
                    desc_cnt   : integer;
                    params_ptr : tak_parinfarr_ptr);
 
      ------------------------------ 
 
        FROM
              AK_error_handling : VAK07;
 
        PROCEDURE
              a07_b_put_error (VAR acv : tak_all_command_glob;
                    b_err   : tgg_basis_error;
                    err_code : tsp_int4);
 
        PROCEDURE
              a07_nb_put_error (VAR acv : tak_all_command_glob;
                    b_err    : tgg_basis_error;
                    err_code : tsp_int4;
                    VAR n    : tsp_knl_identifier);
 
        FUNCTION
              a07_return_code (b_err : tgg_basis_error;
                    sqlmode : tsp_sqlmode) : tsp_int2;
 
        PROCEDURE
              a07_intern_error_put (VAR acv : tak_all_command_glob);
 
      ------------------------------ 
 
        FROM
              AK_BD_procedure_interface : VAK09;
 
        PROCEDURE
              a09exec_load (VAR acv : tak_all_command_glob);
 
        PROCEDURE
              a09unload (VAR acv : tak_all_command_glob);
 
        PROCEDURE
              a09rollback (VAR acv : tak_all_command_glob;
                    VAR b_err : tgg_basis_error);
 
      ------------------------------ 
 
        FROM
              Systeminfo_cache : VAK10;
 
        PROCEDURE
              a10_cache_delete  (VAR acv : tak_all_command_glob;
                    is_rollback : boolean);
 
        PROCEDURE
              a10dispose (VAR acv : tak_all_command_glob;
                    VAR p : tsp1_part_ptr);
 
        PROCEDURE
              a10_init_cache (VAR acv : tak_all_command_glob);
 
        PROCEDURE
              a10new (VAR acv : tak_all_command_glob;
                    obj_size : tsp_int4;
                    VAR p    : tak_ap_max_tree_ptr);
 
      ------------------------------ 
 
        FROM
              AK_Data_Type_Options : VAK14;
 
        PROCEDURE
              a14create_tab_as_select (VAR acv : tak_all_command_glob;
                    VAR tableid : tgg_surrogate;
                    parsk       : tak_parskey);
 
      ------------------------------ 
 
        FROM
              AK_dialog_tools : VAK260;
 
        PROCEDURE
              a260exec_dialog (VAR acv : tak_all_command_glob);
 
        PROCEDURE
              a260internal_proc_call (VAR acv : tak_all_command_glob);
 
      ------------------------------ 
 
        FROM
              AK_Trigger : VAK262;
 
        PROCEDURE
              a262execute_trigger (VAR acv : tak_all_command_glob);
 
      ------------------------------ 
 
        FROM
              Executing_finish : VAK507;
 
        PROCEDURE
              a507_putval (VAR acv : tak_all_command_glob;
                    startpos    : integer;
                    intern_call : boolean);
 
      ------------------------------ 
 
        FROM
              Long-Support-Getval: VAK508;
 
        PROCEDURE
              a508_getval (VAR acv : tak_all_command_glob);
 
      ------------------------------ 
 
        FROM
              AK_Lock_Commit_Rollback : VAK52;
 
        PROCEDURE
              a52end_rollback_subtrans (VAR acv : tak_all_command_glob;
                    VAR subtrans_name : tsp_knl_identifier;
                    m_type            : tgg_message_type);
 
        PROCEDURE
              a52free_caches (VAR acv : tak_all_command_glob);
 
        PROCEDURE
              a52_ex_commit_rollback (VAR acv : tak_all_command_glob;
                    m_type         : tgg_message_type;
                    n_rel          : boolean;
                    normal_release : boolean);
 
      ------------------------------ 
 
        FROM
              DML_Help_Procedures : VAK542;
 
        PROCEDURE
              a542reset_packet (VAR acv : tak_all_command_glob);
 
      ------------------------------ 
 
        FROM
              Resultname_handling : VAK663;
 
        PROCEDURE
              a663_drop_parsid (VAR acv : tak_all_command_glob;
                    VAR p       : tak_parskey;
                    VAR del_cnt : integer);
 
      ------------------------------ 
 
        FROM
              Deal-With-User-Commands : VAK92;
 
        PROCEDURE
              a92find_return_part (VAR acv : tak_all_command_glob;
                    part_kind    : tsp1_part_kind;
                    VAR part_ptr : tsp1_part_ptr);
 
        PROCEDURE
              a92_next_part_get (VAR acv : tak_all_command_glob;
                    VAR curr_part : tsp1_part_ptr);
 
        PROCEDURE
              a92_reject (VAR acv : tak_all_command_glob;
                    s : boolean);
 
        PROCEDURE
              a92_mode_analyzer (VAR acv : tak_all_command_glob;
                    ddl         : tak_ddl_descriptor;
                    corr_select : boolean);
 
        PROCEDURE
              a92next_pcount (VAR acv : tak_all_command_glob;
                    VAR parsk : tak_parskey);
 
        PROCEDURE
              a92_resname_to_varpart(VAR acv : tak_all_command_glob);
 
      ------------------------------ 
 
        FROM
              Utilityprocess : VAK94;
 
        VAR
              a94mode : tgg_usemode;
 
      ------------------------------ 
 
        FROM
              KB_locklist : VKB51;
 
        FUNCTION
              k51shutdown_wanted (TaskId : tsp00_TaskId) : boolean;
 
      ------------------------------ 
 
        FROM
              error_text_handling : VBD06;
 
        PROCEDURE
              b06get_errtxt (VAR t : tgg00_TransContext;
                    VAR errlen   : integer;
                    VAR err_type : tgg00_ErrorText;
                    VAR b_error  : tgg00_BasisError;
                    VAR errtxt   : tsp00_C256);
 
      ------------------------------ 
 
        FROM
              Trace : VBD120;
 
        PROCEDURE
              b120InsertTrace (
                    VAR Trans  : tgg00_TransContext;
                    TraceLayer : tgg00_Debug;
                    TraceType  : tgg00_VtraceType;
                    BodyLen    : tsp00_Int2;
                    pEntry     : tgg11_VtraceBodyPtr);
 
        PROCEDURE
              b120MoveObjectTrace (
                    VAR Trans  : tgg00_TransContext;
                    TraceLayer : tgg00_Debug;
                    TraceType  : tgg00_VtraceType;
                    Length     : tsp00_Int4;
                    pEntry     : tsp00_BytePtr);
 
      ------------------------------ 
 
        FROM
              ref_statistic  : VBD73;
 
        PROCEDURE
              b73cmd_count (statement_kind : tgg00_RefInfoIndex);
 
      ------------------------------ 
 
        FROM
              Configuration_Parameter : VGG01;
 
        VAR
              g01code          : tgg_code_globals;
              g01vtrace        : tgg_vtrace_state;
              g01unicode       : boolean;
 
        PROCEDURE
              g01vtr_init;
 
        PROCEDURE
              g01opmsg (msg_prio : tsp3_priority;
                    msg_type  : tsp3_msg_type;
                    msg_no    : tsp_int4;
                    msg_label : tsp_c8;
                    msg_text  : tsp_c24;
                    msg_value : tsp_int4);
 
      ------------------------------ 
 
        FROM
              Codetransformation_and_Coding : VGG02;
 
        VAR
              g02codetables : tgg_code_tables;
 
        PROCEDURE
              g02gettermsetdesc (VAR termset_name : tsp_knl_identifier;
                    VAR messcode : tsp_code_type;
                    VAR code     : tsp_code_type;
                    VAR found    : boolean);
 
        PROCEDURE
              g02totermchar (
                    messcode   : tsp_code_type;
                    VAR object : tsp_moveobj;
                    pos        : tsp_int4;
                    length     : tsp_int4);
 
        PROCEDURE
              g02tebcdic_to_ascii (VAR source : tsp_moveobj;
                    VAR dest : tsp_moveobj;
                    length   : tsp_int4);
 
        PROCEDURE
              g02tascii_to_ebcdic (VAR source : tsp_moveobj;
                    VAR dest : tsp_moveobj;
                    length   : tsp_int4);
 
      ------------------------------ 
 
        FROM
              Kernel_move_and_fill : VGG10;
 
&       ifdef STACKCHK
        PROCEDURE
              g10mv11 (mod_id      : tsp_c6;
                    mod_intern_num : tsp_int4;
                    source_upb     : tsp_int4;    destin_upb : tsp_int4;
                    VAR source     : tsp_c20;     source_pos : tsp_int4;
                    VAR destin     : tsp_line;    destin_pos : tsp_int4;
                    length         : tsp_int4;
                    VAR e          : tgg_basis_error);
&       endif
&       ifdef STACKCHK
 
      ------------------------------ 
 
        FROM
              GG_edit_routines : VGG17;
 
        PROCEDURE
              g17int4to_line (int : tsp_int4;
                    with_zero : boolean;
                    int_len   : integer;
                    ln_pos    : integer;
                    VAR ln    : tsp_line);
&       endif
 
      ------------------------------ 
 
        FROM
              RTE_kernel : VEN101;
 
        PROCEDURE
              vclock (VAR sec : tsp_int4;
                    VAR microsec : tsp_int4);
 
        PROCEDURE
              vreceive (pid              : tsp_process_id;
                    timeout              : tsp_int4;
                    VAR rcv_packet_ptr   : tsp1_packet_ptr;
                    VAR rcv_packet_len   : tsp_int4;
                    VAR reply_packet_ptr : tsp1_packet_ptr;
                    VAR reply_packet_len : tsp_int4;
                    VAR returncode       : tsp1_comm_error);
 
        PROCEDURE
              vreply (pid            : tsp_process_id;
                    reply_packet_ptr : tsp1_packet_ptr;
                    reply_packet_len : tsp_int4;
                    VAR returncode   : tsp1_comm_error);
&       ifdef TRACE
 
        PROCEDURE
              vscheck (VAR maxstacksize : tsp_int4);
 
        PROCEDURE
              vsResetCmdMax(pid : tsp_process_id);
 
        PROCEDURE
              vsGetCmdMax (pid : tsp_process_id;
                    VAR max_used : tsp_int4);
&       endif
&       ifdef STACKCHK
 
        PROCEDURE
              vsReinit(pid : tsp_process_id;
                    max_used : tsp_int4);
 
        PROCEDURE
              vsscan (VAR maxstacksize : tsp_int4);
&       endif
 
      ------------------------------ 
 
        FROM
              SQLSTATEs : VSP03;
 
        PROCEDURE
              s03getsqlstate (returncode : tsp_int2;
                    warnings     : tsp_warningset;
                    VAR sqlstate : tsp_sqlstate);
 
      ------------------------------ 
 
        FROM
              RTE-Extension-10 : VSP10;
 
        PROCEDURE
              s10fil2 (size  : tsp_int4;
                    VAR m    : tsp_c12;
                    pos      : tsp_int4;
                    len      : tsp_int4;
                    fillchar : char);
 
        PROCEDURE
              s10mv (size1 : tsp_int4;
                    size2    : tsp_int4;
                    VAR val1 : tsp1_packet;
                    p1       : tsp_int4;
                    VAR val2 : t_old_packet;
                    p2       : tsp_int4;
                    cnt      : tsp_int4);
 
        PROCEDURE
              s10mv1 (size1 : tsp_int4;
                    size2    : tsp_int4;
                    VAR val1 : t_old_packet;
                    p1       : tsp_int4;
                    VAR val2 : tsp1_packet;
                    p2       : tsp_int4;
                    cnt      : tsp_int4);
 
      ------------------------------ 
 
        FROM
              RTE-Extension-20 : VSP20;
 
        PROCEDURE
              s20ch4 (val    : tsp_int4;
                    VAR dest : tsp_line;
                    di       : tsp_int4);
 
        PROCEDURE
              s20ch4sw (val    : tsp_int4;
                    sourceswap : tsp_swap_kind;
                    VAR dest   : tsp_int4;
                    di         : tsp_int4;
                    destswap   : tsp_swap_kind);
 
        FUNCTION
              s20or4sw (VAR source : tsp_int4;
                    si             : tsp_int4;
                    sourceswap     : tsp_swap_kind;
                    destswap       : tsp_swap_kind) : tsp_int4;
 
      ------------------------------ 
 
        FROM
              Packet_handling: VSP26;
 
        PROCEDURE
              s26find_part (VAR segm : tsp1_segment;
                    part_kind        : tsp1_part_kind;
                    VAR part_ptr     : tsp1_part_ptr);
 
        PROCEDURE
              s26first_segment_init (packet_ptr : tsp1_packet_ptr;
                    segm_kind                   : tsp1_segment_kind;
                    VAR first_segm_ptr          : tsp1_segment_ptr);
 
        PROCEDURE
              s26new_segment_init (packet_ptr : tsp1_packet_ptr;
                    segm_kind                 : tsp1_segment_kind;
                    VAR new_segm_ptr          : tsp1_segment_ptr;
                    VAR first_part_ptr        : tsp1_part_ptr);
 
        PROCEDURE
              s26next_segment (VAR segm_ptr : tsp1_segment_ptr);
 
        PROCEDURE
              s26nextpart (VAR part_ptr : tsp1_part_ptr);
 
        FUNCTION
              s26packet_len (packet_ptr : tsp1_packet_ptr) : tsp_int4;
 
        FUNCTION
              s26partlen (VAR part : tsp1_part) : tsp_int4;
 
      ------------------------------ 
 
        FROM
              RTE-Extension-30 : VSP30;
 
        FUNCTION
              s30eq (VAR a,b : tsp_c3; bi,cnt : tsp_int4) : boolean;
 
        PROCEDURE
              s30map (VAR code_t : tsp_ctable;
                    VAR source   : tsp_c3;
                    spos         : tsp_int4;
                    VAR dest     : tsp_c3;
                    dpos         : tsp_int4;
                    length       : tsp_int4);
 
      ------------------------------ 
 
        FROM
              RTE-Extension-80 : VSP80;
 
        PROCEDURE
              s80uni_trans
                    (src_ptr        : tsp_moveobj_ptr;
                    src_len         : tsp_int4;
                    src_codeset     : tsp_int2;
                    dest_ptr        : tsp_moveobj_ptr;
                    VAR dest_len    : tsp_int4;
                    dest_codeset    : tsp_int2;
                    trans_options   : tsp8_uni_opt_set;
                    VAR rc          : tsp8_uni_error;
                    VAR err_char_no : tsp_int4);
&       ifdef TRACE
 
      ------------------------------ 
 
        FROM
              Test_Procedures : VTA01;
 
        PROCEDURE
              t01addr (debug : tgg00_Debug;
                    nam      : tsp00_Sname;
                    bufaddr  : tak_acv_address);
 
        PROCEDURE
              t01int4 (level : tgg00_Debug;
                    nam : tsp00_Sname;
                    val : tsp00_Int4);
 
        PROCEDURE
              t01name1 (debug : tgg00_Debug;
                    nam       : tsp00_Sname;
                    n         : tsp_c5);
 
        PROCEDURE
              t01packet (debug : tgg00_Debug;
                    nam        : tsp00_Sname;
                    packet_ptr : tsp1_packet_ptr);
&       endif
 
      ------------------------------ 
 
        FROM
              AK_universal_semantic_tools: VAK06;
 
        PROCEDURE
              a06init_curr_retpart (VAR acv : tak_all_command_glob);
 
        PROCEDURE
              a06finish_curr_retpart (VAR acv : tak_all_command_glob;
                    part_kind : tsp1_part_kind;
                    arg_count : tsp_int2);
 
        PROCEDURE
              a06retpart_move (VAR acv : tak_all_command_glob;
                    moveobj_ptr : tsp_moveobj_ptr;
                    move_len    : tsp_int4);
 
.CM *-END-* use -----------------------------------------
.sp;.cp 3
Synonym :
 
        PROCEDURE
              a10new;
 
              tak_sysbufferaddress tak_ap_max_tree_ptr
 
        PROCEDURE
              a10dispose;
 
              tak_sysbufferaddress tsp1_part_ptr
 
        PROCEDURE
              t01name1;
 
              tsp00_Name tsp_c5
 
        PROCEDURE
              s10fil2;
 
              tsp_moveobj tsp_c12
 
        PROCEDURE
              s10mv;
 
              tsp_moveobj tsp1_packet
              tsp_moveobj t_old_packet
 
        PROCEDURE
              s10mv1;
 
              tsp_moveobj t_old_packet
              tsp_moveobj tsp1_packet
&             ifdef STACKCHK
 
        PROCEDURE
              g10mv11;
 
              tsp_moveobj tsp_c20
              tsp_moveobj tsp_line
&             endif
 
        PROCEDURE
              s20ch4;
 
              tsp_moveobj tsp_line
 
        PROCEDURE
              s20ch4sw;
 
              tsp_moveobj tsp_int4
 
        FUNCTION
              s20or4sw;
 
              tsp_moveobj tsp_int4
 
        FUNCTION
              s30eq;
 
              tsp_moveobj tsp_c3
 
        PROCEDURE
              s30map;
 
              tsp_moveobj tsp_c3
&             ifdef TRACE
 
        PROCEDURE
              t01addr;
 
              tsp00_BufAddr tak_acv_address
&             endif
 
.CM *-END-* synonym -------------------------------------
.sp;.cp 3
Author  : ElkeZ
.sp
.cp 3
Created : 1983-07-29
.sp
.cp 3
.sp
.cp 3
Release :      Date : 2000-11-24
.sp
***********************************************************
.sp
.cp 10
.fo
.oc _/1
Specification:
.CM *-END-* specification -------------------------------
.sp 2
***********************************************************
.sp
.cp 10
.fo
.oc _/1
Description:
.sp 2
A93_SENDING
.sp
If an error has occurred that cannot be assigned to a special class (e_released
is converted again to Returncode 0, e_use_fetch_rest signifies that,
nevertheless, the part has long infos in it), the 80-byte-long error text is
taken to the SQL_PACKET.
.br;If only parsing was to be performed, a special parse id is entered in the
SQL_PACKET for the commands that cannot be parsed (DDL and SHOW).
.br;A Vtrace entry is built, if necessary, which, depending on which Vtrace is
activated, comprises the entire answer of the kernel
or only the first approximately 130
characters.
.br;If necessary, the integer values (Returncode etc ] are byte-swapped.
.br;Only for 8832 is an entry made in the SQL_PACKET also in the case of
error 700 (Command Timeout). Under no circumstances, however, may it be sent
with VREPLY as answer (without having received an inquiry) to the user.
.sp 2;A93_SWAP_INT
.sp 2;This function simply serves to obtain an int2, byte-swapped, as the result
(High-Byte and Low-Byte are swapped).
.sp 2;IMPLICIT_RELEASE
.sp
This procedure releases the user from the kernel
process without the user having
given a command to that effect.
.br;This is necessary in to cases :
.in +2;.un 2
- after a certain waiting time, a user process does not
receive any more user commands and must assume that the application
process is no longer active
.un 2;- in communications with the user (receiving of commands, sending
of answers), there are problems that are detected in the run-time environment
and that are reported to the kernel.
.in -2;.sp 2;A93_USER_COMMANDS
.sp
This procedure always processes a command.
.br;If there has been no stack relocation, it is checked whether, in the
meantime, a shutdown has been made (A94_MODE = UM_UTILITY) and whether,
therefore, no further commands may be processed.
.br;For a defined time, a new SQL_PACKET is waited for. This time depends on
whether the process belongs to a user or not (in_session = true/false).
.br
If it is still entered for this process that its command is to be cancelled,
this entry is deleted.
.br
If there is no new command or if there have been problems with communication
between user process and kernel process
(ret_code <> sp1ce_ok), an implicit Release is
initiated and the process is released.
.br;If the  Command Timeout has taken effect, error 700 is entered in the
SQL_PACKET (see A93_SENDING), but this SQL_PACKET is not sent to the
user.
.br
If there is a command, the number of commands is increased for Accounting and,
if necessary, the low and high bytes of the integers are swapped.
.br;If the lengths and also the entries in the message code are allowable,
then, for most message types, the command is code-converted and switched from
lower-case to upper-case letters in order to facilitate access to keywords and
names. (Strings, of course, are only code-converted ]
.br;A Vtrace entry is built, if necessary, which, depending on which Vtrace is
activated, comprises the entire command or only the first approximately 130
characters.
.br;A92_MODE_ANALYZER is called for the further analysis and, if applicable,
processing of the command.
.br;The special message types 500-504, which are available only in the test
version of the kernel,
lead always, when the kernel is cold, to the kernel process
being released.
.br;If no user is connected to this kernel process (NOT in_session) and an error
has occurred, the kernel process must also be released.
.br;The error messages e_roll_released, e_released are for internal use in the
kernel only. They merely indicate that the process must be released, but
are not sent to the user.
.br;If error -904 occurs (space_table_for_result_sets_exhausted, i.e. there is
not sufficient free, temporary space in the database or only for this user (if
he has a TEMPLIMIT)), the user who has received it is implicitly released, with
the result that he releases his occupied temporary memory space and, at least,
the other users can continue to work normally.
.br;By means of A93_SENDING, the answer to a request is sent back to the user;
the process can, if applicable, be identified to the run-time environment as
being freely available again (3rd parameter = true).
.br;If there are problems in communication (ret_code <> sp1ce_ok),
further working
is no longer practical. The user is implicitly released and the process if
released.
.br;Release also means that the cache is deleted.
.br;If the process has not already been marked as free to the
run-time environment by means of
A93_SENDING and by the run-time environment routine used therein, this is done
by the routine VRELEASE.
.CM *-END-* description ---------------------------------
.sp 2
***********************************************************
.sp
.cp 10
.nf
.oc _/1
Structure:
 
.CM *-END-* structure -----------------------------------
.sp 2
**********************************************************
.sp
.cp 10
.nf
.oc _/1
.CM -lll-
Code    :
 
 
CONST
      c_intern_call    = true  (* a507_putval *);
      c_n_rel          = true  (* a52_ex_commit_rollback *);
      c_normal_release = true  (* a52_ex_commit_rollback *);
      c_utilityprocess = true  (* a92_reject *);
      c_corr_select    = true  (* a92_mode_analyzer *);
      c_kernel_is_dest = true  (* a93swap_packet_header *);
      c_user_cmd       = true  (* ak93one_command *);
      (* ------------------------------------------------------------ *)
      (* Constants used for a packet returned to a pre6.2 application *)
      (* ------------------------------------------------------------ *)
      (* A special defined_byte was used for resultcounts. *)
      c_is_rollback    = true;
 
TYPE
 
      t_old_packet = RECORD
            rte_header      : tsp_c20;
            mess_code_type  : tsp_code_type;
            mess_swap_kind  : tsp_swap_kind;
            mess_type       : tsp_int2;
            senderid        : tsp_c8;
            part1_length    : tsp_int2;
            part2_length    : tsp_int2;
            return_code     : tsp_int2;
            error_code      : tsp_int2;
            var_part        : tsp_c70;
      END;
 
      (* PTS 1105744 E.Z. *)
 
 
(*------------------------------*) 
 
PROCEDURE
      ak93get_appl_and_vers (VAR acv : tak_all_command_glob;
            VAR useful       : boolean;
            VAR sql_comm_err : tsp1_comm_error);
 
CONST
      c_version_628    = '62080';
      c_version_80     = '80000';
 
VAR
      cmpstr  : tsp_c3;
 
BEGIN
WITH acv, a_in_packet^.sp1_header DO
    BEGIN
    useful := true;
    IF  g01code.ctype = csp_ascii
    THEN
        s30map (g02codetables.tables [cgg_up_ascii],
              sp1h_application, 1, sp1h_application, 1,
              sizeof (sp1h_application))
    ELSE
        s30map (g02codetables.tables [cgg_to_up_ebcdic],
              sp1h_application, 1, sp1h_application, 1,
              sizeof (sp1h_application));
    (*ENDIF*) 
    a_comp_type := at_unknown;
    (* PTS 1115025 E.Z. *)
    CASE sp1h_application [1] OF
        'C' :
            BEGIN
            cmpstr := csp_comp_cpc;
            IF  s30eq (sp1h_application, cmpstr, 1,
                sizeof (sp1h_application))
            THEN
                a_comp_type := at_cpc
            ELSE
                BEGIN   (* PTS 1112481 FF *)
                cmpstr := csp_comp_cpp;
                IF  s30eq (sp1h_application, cmpstr, 1,
                    sizeof (sp1h_application))
                THEN
                    a_comp_type := at_cpp;
                (*ENDIF*) 
                END;
            (*ENDIF*) 
            END;
        'D' :
            BEGIN
            cmpstr := csp_comp_db_manager;
            IF  s30eq (sp1h_application, cmpstr, 1,
                sizeof (sp1h_application))
            THEN
                a_comp_type := at_db_manager
            ELSE
                BEGIN
                (* old Python used DOM --> drop with version >= 7.5 *)
                cmpstr := 'DOM';
                IF  s30eq (sp1h_application, cmpstr, 1,
                    sizeof (sp1h_application))
                THEN
                    a_comp_type := at_gpc;
                (*ENDIF*) 
                END;
            (*ENDIF*) 
            END;
        'G' :
            BEGIN
            cmpstr := csp_comp_gpc;
            IF  s30eq (sp1h_application, cmpstr, 1,
                sizeof (sp1h_application))
            THEN
                a_comp_type := at_gpc
            (*ENDIF*) 
            END;
        'J' :
            BEGIN
            cmpstr := csp_comp_jdbc;
            IF  s30eq (sp1h_application, cmpstr, 1,
                sizeof (sp1h_application))
            THEN
                a_comp_type := at_jdbc
            (*ENDIF*) 
            END;
        'L' :
            BEGIN
            cmpstr := csp_comp_load;
            IF  s30eq (sp1h_application, cmpstr, 1,
                sizeof (sp1h_application))
            THEN
                a_comp_type := at_load;
            (*ENDIF*) 
            END;
        'O' :
            BEGIN
            cmpstr := csp_comp_odbc;
            IF  s30eq (sp1h_application, cmpstr, 1,
                sizeof (sp1h_application))
            THEN
                a_comp_type := at_odbc;
            (*ENDIF*) 
            END;
        'U' :
            BEGIN
            cmpstr := csp_comp_util;
            IF  s30eq (sp1h_application, cmpstr, 1,
                sizeof (sp1h_application))
            THEN
                a_comp_type := at_util;
            (*ENDIF*) 
            END;
        'X' :
            BEGIN
            cmpstr := csp_comp_xci;
            IF  s30eq (sp1h_application, cmpstr, 1,
                sizeof (sp1h_application))
            THEN
                a_comp_type := at_xci;
            (*ENDIF*) 
            END;
        OTHERWISE
            BEGIN
            END;
        END;
    (*ENDCASE*) 
    IF  a_comp_type = at_unknown
    THEN
        a_comp_vers := bsp_c5
    ELSE
        a_comp_vers := sp1h_appl_version;
    (*ENDIF*) 
    (* PTS 1107282 E.Z. *)
    (* PTS 1116801 E.Z. *)
    IF  a_comp_vers >= c_version_80
    THEN
        BEGIN
        useful := false;
        (* PTS 1105744 E.Z. *)
        IF  (a_comp_vers < c_version_628) OR
            (a_comp_type = at_unknown)
        THEN
            sql_comm_err := sp1ce_notok
        (*ENDIF*) 
        END;
    (* h.b. PTS 1106804 *)
    (*ENDIF*) 
    IF  (a_comp_vers >= c_version_80)
    THEN
        g01opmsg (sp3p_console, sp3m_info,
              csp3_ak_msg, csp3_n_order, 'UNEXPECTED TOOL VERSION ', 0);
&   ifdef TRACE
    (*ENDIF*) 
    t01name1 (ak_syn, 'a_comp_vers ', a_comp_vers);
    t01int4  (ak_syn, 'a_comp_type ', ord(a_comp_type));
&   endif
    END;
(*ENDWITH*) 
END;
 
(* PTS 1111575 E.Z. *)
(*------------------------------*) 
 
PROCEDURE
      a93swap_from_application (VAR acv : tak_all_command_glob);
 
VAR
      act_para            : integer;
      part                : integer;
      cmd_segm            : integer;
      curr_cmd_segm_ptr   : tsp1_segment_ptr;
      curr_part_ptr       : tsp1_part_ptr;
 
BEGIN
(* Change request 1001193, T.A. 23.10.1998 *)
WITH acv.a_in_packet^.sp1_header DO
    BEGIN
    a93swap_packet_header (acv.a_in_packet^.sp1_header,
          c_kernel_is_dest, g01code.kernel_swap,
          sp1h_mess_swap);
    (* integer swap in header, cmd_segment_headers and *)
    (* part_headers                                    *)
    (* PTS 1108262 E.Z. *)
    IF  sp1h_varpart_size < sp1h_varpart_len
    THEN
        (* a07_b_put_error is not possible because out_packet does not exist *)
        (* before length of inpacket is swapped and readable    -->          *)
        sp1h_no_of_segm := 0
    ELSE
        IF  (sp1h_no_of_segm < 1) OR
            (sp1h_no_of_segm > sp1h_varpart_len DIV sizeof(tsp1_segment_header))
        THEN
            sp1h_no_of_segm := 0
        ELSE
            BEGIN
            curr_cmd_segm_ptr := @acv.a_in_packet^.sp1_segm;
            FOR cmd_segm := 1 TO sp1h_no_of_segm DO
                WITH curr_cmd_segm_ptr^ DO
                    BEGIN
                    (* swap integers of curr cmd segment *)
                    s20ch4sw (sp1s_segm_len, sp1h_mess_swap,
                          sp1s_segm_len, 1, g01code.kernel_swap);
                    s20ch4sw (sp1s_segm_offset, sp1h_mess_swap,
                          sp1s_segm_offset, 1, g01code.kernel_swap);
                    (* PTS 1108262 E.Z. *)
                    IF  sp1h_mess_swap <> g01code.kernel_swap
                    THEN
                        sp1s_no_of_parts := a01swap_int2 (sp1s_no_of_parts);
                    (*ENDIF*) 
                    IF  (sp1s_segm_offset > sp1h_varpart_len) OR
                        (sp1s_no_of_parts > (sp1s_segm_len - sizeof(tsp1_segment_header)) DIV
                        sizeof(tsp1_part_header))
                    THEN
                        sp1h_no_of_segm := 0;
                    (*ENDIF*) 
                    IF  sp1h_mess_swap <> g01code.kernel_swap
                    THEN
                        BEGIN
                        (* PTS 1108262 E.Z. *)
                        sp1s_own_index := a01swap_int2 (sp1s_own_index);
                        curr_part_ptr := @sp1p_part_header;
                        (* swap integers of all parts of current *)
                        (* cmd segment                           *)
                        FOR part := 1 TO sp1s_no_of_parts DO
                            WITH curr_part_ptr^ DO
                                BEGIN
                                sp1p_arg_count :=
                                      a01swap_int2 (sp1p_arg_count);
                                s20ch4sw (sp1p_segm_offset,
                                      sp1h_mess_swap,
                                      sp1p_segm_offset, 1,
                                      g01code.kernel_swap);
                                s20ch4sw (sp1p_buf_len, sp1h_mess_swap,
                                      sp1p_buf_len, 1,
                                      g01code.kernel_swap);
                                s20ch4sw (sp1p_buf_size, sp1h_mess_swap,
                                      sp1p_buf_size, 1,
                                      g01code.kernel_swap);
                                CASE curr_part_ptr^.sp1p_part_kind OF
                                    sp1pk_appl_parameter_description :
                                        WITH curr_part_ptr^, acv.a_parameter_spec DO
                                            BEGIN
                                            param_spec_ptr := @sp1p_buf[ 1 ];
                                            param_counter  := sp1p_arg_count;
                                            FOR act_para := 1 TO param_counter DO
                                                WITH param_spec_ptr^[ act_para ] DO
                                                    para_length :=
                                                       a01swap_int2 (para_length);
                                                (*ENDWITH*) 
                                            (*ENDFOR*) 
                                            param_spec_ptr := NIL;
                                            END;
                                        (*ENDWITH*) 
                                    (* PTS 1111575 E.Z. *)
                                    OTHERWISE
                                        BEGIN
                                        END
                                    END;
                                (*ENDCASE*) 
                                curr_part_ptr := @curr_part_ptr^.
                                      sp1p_buf[1 + a01aligned_cmd_len (
                                      curr_part_ptr^.sp1p_buf_len)]
                                END;
                            (*ENDWITH*) 
                        (*ENDFOR*) 
                        END;
                    (*ENDIF*) 
                    curr_cmd_segm_ptr := @acv.a_in_packet^.sp1_varpart[
                          sp1s_segm_offset + sp1s_segm_len + 1]
                    END;
                (*ENDWITH*) 
            (*ENDFOR*) 
            END
        (*ENDIF*) 
    (*ENDIF*) 
    END;
(*ENDWITH*) 
END;
 
(*------------------------------*) 
 
PROCEDURE
      a93swap_to_application (VAR packet : tsp1_packet_ptr;
            a_mess_code      : tsp00_CodeType;
            a_basic_code     : tsp00_CodeType;
            a_mess_swap      : tsp00_SwapKind;
            a_parameter_spec : tak_param_list);
 
VAR
      curr_cmd_segm_ptr   : tsp1_segment_ptr;
      next_cmd_segm_ptr   : tsp1_segment_ptr;
      curr_part_ptr       : tsp1_part_ptr;
      next_part_ptr       : tsp1_part_ptr;
      cmd_segm            : integer;
      part                : integer;
      act_para            : integer;
 
BEGIN
WITH packet^.sp1_header DO
    BEGIN
    (* PTS 1102371 E.Z. *)
    IF  g01code.ctype <> a_mess_code
    THEN
        BEGIN
        curr_cmd_segm_ptr := @packet^.sp1_segm;
        FOR cmd_segm := 1 TO sp1h_no_of_segm DO
            WITH curr_cmd_segm_ptr^ DO
                BEGIN
                curr_part_ptr := @sp1p_part_header;
                FOR part := 1 TO sp1s_no_of_parts DO
                    WITH curr_part_ptr^ DO
                        BEGIN
                        CASE sp1p_part_kind OF
                            sp1pk_command,
                            sp1pk_errortext, sp1pk_resulttablename,
                            sp1pk_tablename, sp1pk_user_info_returned :
                                IF  a_basic_code <= cgg_end_termsets
                                THEN
                                    BEGIN
                                    (* not in case of multibyte_sets *)
                                    IF  g01code.ctype <> a_basic_code
                                    THEN
                                        IF  g01code.ctype = csp_ascii
                                        THEN
                                            g02tascii_to_ebcdic (sp1p_buf,
                                                  sp1p_buf, sp1p_buf_len)
                                        ELSE
                                            g02tebcdic_to_ascii (sp1p_buf,
                                                  sp1p_buf, sp1p_buf_len);
                                        (*ENDIF*) 
                                    (*ENDIF*) 
                                    IF  a_basic_code <> a_mess_code
                                    THEN
                                        g02totermchar (a_mess_code, sp1p_buf, 1, sp1p_buf_len)
                                    (*ENDIF*) 
                                    END;
                                (*ENDIF*) 
                            OTHERWISE ;
                            END;
                        (*ENDCASE*) 
                        next_part_ptr := @curr_part_ptr^.
                              sp1p_buf[1 + a01aligned_cmd_len (
                              curr_part_ptr^.sp1p_buf_len)];
                        curr_part_ptr := next_part_ptr;
                        END;
                    (*ENDWITH*) 
                (*ENDFOR*) 
                next_cmd_segm_ptr := @packet^.sp1_varpart[
                      sp1s_segm_offset + sp1s_segm_len + 1];
                curr_cmd_segm_ptr := next_cmd_segm_ptr;
                END;
            (*ENDWITH*) 
        (*ENDFOR*) 
        END;
    (*ENDIF*) 
    IF  packet^.sp1_header.sp1h_mess_swap <> g01code.kernel_swap
    THEN
        BEGIN
        (* integer swap in header, cmd_segment_headers and *)
        (* part_headers                                    *)
        curr_cmd_segm_ptr := @packet^.sp1_segm;
        FOR cmd_segm := 1 TO sp1h_no_of_segm DO
            WITH curr_cmd_segm_ptr^ DO
                BEGIN
                curr_part_ptr := @sp1p_part_header;
                (* swap integers of all parts of current *)
                (* cmd segment                           *)
                FOR part := 1 TO sp1s_no_of_parts DO
                    WITH curr_part_ptr^ DO
                        BEGIN
                        (* For finishing the current return part we first of all *)
                        (* do some transformations with the buffer according to  *)
                        (* the given part kind.                                  *)
                        CASE sp1p_part_kind OF
                            sp1pk_appl_parameter_description :
                                WITH a_parameter_spec DO
                                    BEGIN
                                    param_spec_ptr := @sp1p_buf[ 1 ];
                                    param_counter  := sp1p_arg_count;
                                    FOR act_para := 1 TO param_counter DO
                                        WITH param_spec_ptr^[ act_para ] DO
                                            para_length :=
                                                  a01swap_int2 (para_length);
                                        (*ENDWITH*) 
                                    (*ENDFOR*) 
                                    END;
                                (*ENDWITH*) 
                            (* PTS 1111575 E.Z. *)
                            sp1pk_shortinfo, sp1pk_output_cols_no_parameter :
                                IF  a_mess_swap <> g01code.kernel_swap
                                THEN
                                    a04_info_byteswap_codetype (a_mess_swap,
                                          sp1p_arg_count, @sp1p_buf[ 1 ]);
                                (*ENDIF*) 
                            OTHERWISE ;
                            END;
                        (*ENDCASE*) 
                        next_part_ptr := @curr_part_ptr^.
                              sp1p_buf[1 + a01aligned_cmd_len (
                              curr_part_ptr^.sp1p_buf_len)];
                        IF  a_mess_swap <> g01code.kernel_swap
                        THEN (* Now (at last!) swap the header of the finished return part. *)
                            a01swap_cmd_part (a_mess_swap,
                                  sp1p_part_header);
                        (*ENDIF*) 
                        curr_part_ptr := next_part_ptr;
                        END;
                    (*ENDWITH*) 
                (*ENDFOR*) 
                next_cmd_segm_ptr := @packet^.sp1_varpart[
                      sp1s_segm_offset + sp1s_segm_len + 1];
                (* swap integers of curr cmd segment *)
                s20ch4sw (sp1s_segm_len, sp1h_mess_swap,
                      sp1s_segm_len, 1, g01code.kernel_swap);
                s20ch4sw (sp1s_segm_offset, sp1h_mess_swap,
                      sp1s_segm_offset, 1, g01code.kernel_swap);
                sp1s_no_of_parts :=
                      a01swap_int2 (sp1s_no_of_parts);
                sp1s_own_index :=
                      a01swap_int2 (sp1s_own_index);
                IF  sp1s_segm_kind = sp1sk_return
                THEN
                    BEGIN
                    sp1r_function_code  := a01swap_int2 (sp1r_function_code);
                    sp1r_returncode     := a01swap_int2 (sp1r_returncode);
                    s20ch4sw (sp1r_errorpos, sp1h_mess_swap,
                          sp1r_errorpos, 1, g01code.kernel_swap);
                    END;
                (*ENDIF*) 
                curr_cmd_segm_ptr := next_cmd_segm_ptr;
                END;
            (*ENDWITH*) 
        (*ENDFOR*) 
        a93swap_packet_header (packet^.sp1_header,
              NOT c_kernel_is_dest, g01code.kernel_swap,
              sp1h_mess_swap);
        END
    (*ENDIF*) 
    END
(*ENDWITH*) 
END;
 
(*------------------------------*) 
 
PROCEDURE
      a93_sending (VAR acv : tak_all_command_glob;
            start_time_sec  : tsp_int4;
            start_time_msec : tsp_int4;
            VAR retcode     : tsp1_comm_error);
 
VAR
      dummy_txttype    : tgg_errortext;
      i                : integer;
      m_return_code    : integer;
      dummy_errlen     : integer;
      reply_length     : tsp_int4;
      dummy_error      : tgg_basis_error;
      stop_time_sec    : tsp_int4;
      stop_time_msec   : tsp_int4;
      diff_sec         : tsp_int4;
      diff_msec        : tsp_int4;
      dummy_text       : tsp_c256;
      tr               : tsp_line;
 
      i_map_c4         : RECORD
            CASE integer OF
                1 :
                    (i : tsp_int4);
                2 :
                    (c : tsp_c4);
                3 :
                    (i2_1 : tsp_int2;
                    i2_2  : tsp_int2);
                END;
            (*ENDCASE*) 
 
 
BEGIN
WITH acv DO
    BEGIN
    m_return_code := a_return_segm^.sp1r_returncode;
    reply_length := s26packet_len (a_out_packet);
    a_out_packet^.sp1_header.sp1h_varpart_len := reply_length
          - sizeof (a_out_packet^.sp1_header);
    IF  g01vtrace.vtrAny_gg00
    THEN
        a93packet_vtrace (a_transinf.tri_trans,
              ak_send, a_out_packet);
    (* PTS 1102371 E.Z. *)
    (*ENDIF*) 
    a93swap_to_application (a_in_packet,
          a_mess_code, a_basic_code,
          a_out_packet^.sp1_header.sp1h_mess_swap,
          a_parameter_spec);
    (* PTS 1116801 E.Z. *)
    a93swap_to_application (a_out_packet,
          a_mess_code, a_basic_code,
          a_out_packet^.sp1_header.sp1h_mess_swap,
          a_parameter_spec);
    retcode := sp1ce_ok;
    IF  (start_time_sec <> 0) AND (start_time_msec <> 0)
    THEN
        BEGIN
        vclock (stop_time_sec, stop_time_msec);
        diff_sec  := stop_time_sec - start_time_sec;
        diff_msec :=  (stop_time_msec - start_time_msec);
        IF  stop_time_msec < start_time_msec
        THEN
            BEGIN
            diff_sec := diff_sec - 1;
            diff_msec := diff_msec + 1000000 ;
            END  ;
        (*ENDIF*) 
        s20ch4 (diff_sec, tr, 1);
        s20ch4 (diff_msec, tr, 5);
        s20ch4 (0, tr, 9);
        b120InsertTrace (acv.a_transinf.tri_trans, gg_time, td_none, 12, @tr)
        END;
    (* PTS 1107485 E.Z. *)
    (*ENDIF*) 
    IF  NOT a_abap_tab_comm_ok
    THEN
        retcode := sp1ce_notok
    ELSE
        IF  (m_return_code <> a07_return_code (e_command_timeout, a_sqlmode))
            AND
            (a_dbproc_level  = 0)
            AND
            (a_trigger_level = 0)
        THEN
            BEGIN
&           ifdef trace
            t01int4 (ak_sem, 'vreply      ', 1);
&           endif
            vreply (acv.a_transinf.tri_trans.trTaskId_gg00, acv.a_out_packet,
                  reply_length, retcode)
            END;
        (*ENDIF*) 
    (*ENDIF*) 
    IF  g01vtrace.vtrRetcodeCheck_gg00
    THEN
        IF  g01vtrace.vtrStopRetcode_gg00 = m_return_code
        THEN
            g01vtr_init;
        (*ENDIF*) 
    (*ENDIF*) 
    IF  tsErrTextExist_egg00 in a_transinf.tri_trans.trState_gg00
    THEN
        BEGIN
        (* Discard Error Text : *)
        (* PTS 1116837 E.Z. *)
        dummy_error := e_ok;
        b06get_errtxt (a_transinf.tri_trans, dummy_errlen,
              dummy_txttype, dummy_error, dummy_text);
        a_transinf.tri_trans.trState_gg00 :=
              a_transinf.tri_trans.trState_gg00 - [ tsErrTextExist_egg00 ];
        END;
    (*ENDIF*) 
    END
(*ENDWITH*) 
END;
 
(*------------------------------*) 
 
PROCEDURE
      a93_user_commands (VAR acv : tak_all_command_glob;
            VAR alloc_ok   : boolean;
            VAR do_release : boolean);
 
CONST
      time_not_in_trans =   0;
 
VAR
      found             : boolean;
      commit_error      : boolean;
      sql_comm_err      : tsp1_comm_error;
      timeout_value     : tsp_int4;
      cmd_index         : integer;
      i                 : integer;
      start_time_sec    : tsp_int4;
      start_time_msec   : tsp_int4;
      cmd_segm_pos      : tsp_int4;
      full_varpart_size : tsp_int4;
      curr_part         : integer;
      part_ptr          : tsp1_part_ptr;
      blank_identifier  : tsp_knl_identifier;
      parsk             : tak_parskey;
&     ifdef STACKCHK
      maxstack          : tsp_int4;
      tr                : tsp_line;
      c20               : tsp_c20;
      dummy             : tsp_int2;
&     endif
 
BEGIN
WITH acv DO
    BEGIN
    do_release := false;
    (* PTS 1110953 E.Z. *)
&   ifdef STACKCHK
    IF  NOT a_in_session
    THEN
        vsReinit(acv.a_transinf.tri_trans.trTaskId_gg00, 0);
&   endif
    (*ENDIF*) 
    IF  (a_in_session AND a_use_timeout)
    THEN
        timeout_value := a_user_timeout
    ELSE
        timeout_value := time_not_in_trans;
    (*ENDIF*) 
    IF  ((a94mode = umUtility_egg00) AND a_in_session)
    THEN
        BEGIN
        s26first_segment_init (a_out_packet, sp1sk_return, a_return_segm);
        a_curr_retpart := NIL;
        a92_reject (acv, NOT c_utilityprocess);
        a_in_session := false;
        do_release   := true
        END
    ELSE
        BEGIN
        a_main_returncode := 0;
        a93vreceive (acv, timeout_value, alloc_ok, sql_comm_err);
        IF  g01vtrace.vtrTime_gg00
        THEN
            vclock (start_time_sec, start_time_msec)
        ELSE
            BEGIN
            start_time_sec  := 0;
            start_time_msec := 0
            END;
        (*ENDIF*) 
        a_transinf.tri_trans.trError_gg00                 := e_ok;
        a_transinf.tri_trans.trRowLocksPerSqlCmd_gg00     := 0;
        (* PTS 1112223 E.Z. *)
        a_user_defined_error                              := false;
        IF  sql_comm_err <> sp1ce_ok
        THEN
            ak93clear (acv, sql_comm_err,
                  start_time_sec, start_time_msec, do_release)
        ELSE
            IF  a_return_segm^.sp1r_returncode <> 0
            THEN
                BEGIN
                a93_sending (acv, start_time_sec, start_time_msec,
                      sql_comm_err);
                do_release := true
                END
            ELSE
                BEGIN
                IF  a_sysdir.ci_cache_p = NIL
                THEN
                    a93init_caches (acv);
                (* PTS 1112849 E.Z. *)
                (*ENDIF*) 
                IF  NOT a_in_session AND (a94mode = umUser_egg00)
                THEN
                    IF  k51shutdown_wanted (a_transinf.tri_trans.trTaskId_gg00)
                    THEN
                        a92_reject (acv, NOT c_utilityprocess);
                    (*ENDIF*) 
                (*ENDIF*) 
                IF  a_return_segm^.sp1r_returncode <> 0
                THEN
                    do_release := true
                ELSE
                    (* PTS 1107551 E.Z. *)
                    BEGIN
                    IF  g01vtrace.vtrAny_gg00
                    THEN
                        a93packet_vtrace (a_transinf.tri_trans,
                              ak_receive, a_in_packet);
                    (*ENDIF*) 
                    commit_error := false;
                    IF  (a_in_packet^.sp1_header.sp1h_no_of_segm < 1)
                        OR
                        (NOT (a_in_packet^.sp1_header.sp1h_mess_code in [ csp_ascii, csp_ebcdic,
                        cgg_begin_termsets..cgg_end_termsets ]) AND
                        ((a_in_packet^.sp1_header.sp1h_mess_code <  csp_unicode_swap) OR
                        ( a_in_packet^.sp1_header.sp1h_mess_code >= csp_unicode + csp8_encodings)))
                    THEN
                        a92_reject (acv, NOT c_utilityprocess)
                    ELSE
                        BEGIN
                        a_mess_code := a_in_packet^.sp1_header.sp1h_mess_code;
                        IF  a_mess_code <> a_session_mess_code
                        THEN
                            BEGIN
                            IF  a_mess_code < csp_unicode_swap
                            THEN
                                a_max_codewidth := 1
                            ELSE
                                IF  a_mess_code <= csp_unicode
                                THEN
                                    a_max_codewidth := 2
                                (*ENDIF*) 
                            (*ENDIF*) 
                            END
                        ELSE
                            a_max_codewidth := a_session_max_codewidth;
                        (*ENDIF*) 
                        IF  (a_mess_code >= cgg_begin_termsets) AND
                            (a_mess_code <= cgg_end_termsets)
                        THEN
                            BEGIN
                            blank_identifier := a01_il_b_identifier;
                            (* blank_identifier will be changed *)
                            (* by g02gettermsetdesc !!!         *)
                            g02gettermsetdesc (blank_identifier,
                                  a_mess_code,
                                  a_basic_code, found);
                            IF  NOT found
                            THEN
                                a07_b_put_error (acv,
                                      e_invalid_messcodetype, 1)
                            (*ENDIF*) 
                            END
                        ELSE
                            a_basic_code := a_mess_code;
                        (*ENDIF*) 
                        IF  NOT g01unicode AND
                            (a_mess_code in
                            [csp_unicode, csp_unicode_swap])
                        THEN
                            a07_b_put_error (acv, e_unknown_multibyte_set, 1);
&                       ifdef TRACE
                        (*ENDIF*) 
                        t01packet (ak_syn,
                              'USER-TO-KERN', a_in_packet);
&                       endif
                        cmd_index    := 1;
                        cmd_segm_pos := 1;
                        (* PTS 1110953 E.Z. *)
                        full_varpart_size := a_out_packet^.sp1_header.sp1h_varpart_size;
                        WHILE cmd_index <= a_in_packet^.sp1_header.sp1h_no_of_segm DO
                            BEGIN
                            a_out_packet^.sp1_header.sp1h_varpart_size :=
                                  full_varpart_size - csp1_min_reply_size_per_segment *
                                  (a_in_packet^.sp1_header.sp1h_no_of_segm - cmd_index);
                            IF  cmd_index > 1
                            THEN
                                BEGIN
                                s26new_segment_init (a_out_packet,
                                      sp1sk_return, a_return_segm,
                                      part_ptr);
                                a_curr_retpart   := NIL;
                                a_retpart_locked := false;
                                END;
                            (*ENDIF*) 
                            a_trigger_level := 0;
                            a_dbproc_level  := 0;
                            (* PTS 1112770 E.Z. *)
                            a_info_output   := false;
                            a_transinf.tri_trans.trRowLocksPerSqlCmd_gg00 := 0;
                            ak93one_command (acv, cmd_index,
                                  cmd_segm_pos, c_user_cmd, do_release);
                            (* PTS 1116917 E.Z. *)
                            part_ptr := @a_return_segm^.sp1p_part;
                            FOR curr_part := 1 TO a_return_segm^.sp1s_no_of_parts DO
                                BEGIN
                                IF  curr_part > 1
                                THEN
                                    s26nextpart (part_ptr);
                                (*ENDIF*) 
                                part_ptr^.sp1p_buf_size := part_ptr^.sp1p_buf_size +
                                      csp1_min_reply_size_per_segment *
                                      (a_in_packet^.sp1_header.sp1h_no_of_segm - cmd_index);
                                END;
                            (*ENDFOR*) 
                            cmd_index := cmd_index + 1;
                            IF  a_return_segm^.sp1r_returncode <> 0
                            THEN
                                IF  (a_return_segm^.sp1r_function_code = csp1_commit_fc)
                                    AND
                                    (a_cmd_segm^.sp1c_mess_type in [ sp1m_dbs, sp1m_execute ])
                                    AND
                                    (a_statement_kind <> iend_subtrans)
                                    AND
                                    (a_return_segm^.sp1r_returncode <>
                                    a07_return_code (e_not_implemented, a_sqlmode))
                                    AND
                                    (a_return_segm^.sp1r_returncode <>
                                    a07_return_code (e_wanted_keyword, a_sqlmode))
                                THEN
                                    BEGIN
                                    (* exit loop *)
                                    cmd_index := a_in_packet^.sp1_header.sp1h_no_of_segm + 1;
                                    commit_error := true
                                    END
                                ELSE
                                    IF  (a_return_segm^.sp1r_returncode =
                                        cak_e_released)
                                        OR
                                        (a_return_segm^.sp1r_returncode =
                                        cak_e_roll_released)
                                        OR
                                        (a_return_segm^.sp1r_returncode = -904)
                                        OR
                                        (a_return_segm^.sp1r_returncode =
                                        a07_return_code (
                                        e_release_caused_by_shutdown,
                                        a_sqlmode))
                                        OR
                                        (a_return_segm^.sp1r_returncode =
                                        a07_return_code (e_new_session_required,
                                        a_sqlmode))
                                        OR
                                        (a_return_segm^.sp1r_returncode = cak_e_receive_error)
                                        (* PTS 1109783 E.Z. *)
                                        OR
                                        (
                                        ((a_return_segm^.sp1r_function_code = csp1_commit_release_fc) OR
                                        ( a_return_segm^.sp1r_function_code = csp1_rollback_release_fc))
                                        AND
                                        (a_cmd_segm^.sp1c_mess_type in [ sp1m_dbs, sp1m_execute ])
                                        )
                                    THEN (* exit loop *)
                                        cmd_index := a_in_packet^.sp1_header.sp1h_no_of_segm + 1;
                                    (* PTS 1110953 E.Z. *)
&                                   ifdef STACKCHK
                                    (*ENDIF*) 
                                (*ENDIF*) 
                            (*ENDIF*) 
                            vsscan (maxstack);
                            c20 := 'maxstack :          ';
                            g10mv11 ('VAK93 ',   1,    
                                  sizeof(c20), sizeof(tr),
                                  c20, 1, tr, 1, 11, dummy);
                            g17int4to_line (maxstack, false, 6, 12, tr);
                            b120InsertTrace (acv.a_transinf.tri_trans, ta, td_none, 17, @tr);
                            vsReinit(acv.a_transinf.tri_trans.trTaskId_gg00, maxstack);
&                           endif
                            END;
                        (*ENDWHILE*) 
&                       ifdef TRACE
                        t01packet (ak_syn,
                              'KERN-TO-USER', a_out_packet);
&                       endif
                        END;
                    (*ENDIF*) 
                    IF  a_return_segm^.sp1r_returncode = cak_e_receive_error
                    THEN
                        sql_comm_err := sp1ce_notok
                    ELSE
                        BEGIN
                        IF  do_release
                        THEN
                            a_in_session := true;
                        (*ENDIF*) 
                        a93_sending (acv, start_time_sec, start_time_msec,
                              sql_comm_err)
                        END;
                    (*ENDIF*) 
                    IF  (sql_comm_err <> sp1ce_ok) OR commit_error
                    THEN
                        BEGIN
                        IF  a_in_session
                        THEN
                            BEGIN
                            a_transinf.tri_trans.trRteCommPtr_gg00^.to_cancel := false;
                            ak93implicit_release (acv);
                            a_in_session := false
                            END;
                        (*ENDIF*) 
                        do_release := true;
                        IF  a94mode <> umUser_egg00
                        THEN
                            a_restarted := false
                        (*ENDIF*) 
                        END;
                    (*ENDIF*) 
                    END
                (*ENDIF*) 
                END
            (*ENDIF*) 
        (*ENDIF*) 
        END;
    (*ENDIF*) 
    IF  do_release
    THEN
        BEGIN
        a_curr_user_name  := a01_il_b_identifier;
        a_in_session      := false;
        a_acc_user        := a01_il_b_identifier;
        (* PTS 1115978 E.Z. *)
        (* PTS 1114071 E.Z. *)
        a_max_used_pcount[1]    := csp_defined_byte;
        a_max_used_pcount[2]    := csp_defined_byte;
        a_max_used_pcount[3]    := csp_defined_byte;
        a_first_free_pcount     := 0;
        a_last_free_pcount      := cak_max_pcounts;
        FOR i := 1 TO cak_max_pcounts DO
            BEGIN
            a92next_pcount (acv, parsk);
            a_free_pcounts[i] := parsk.p_count;
            END;
        (*ENDFOR*) 
        a_first_free_pcount     := 1;
        a52free_caches (acv);
        a_transinf.tri_trans.trTransId_gg00.ci6_gg00 := cgg_zero_trans;
        a_sqlmode := sqlm_adabas
        END
    ELSE
        a_in_session := true
    (*ENDIF*) 
    END
(*ENDWITH*) 
END;
 
(*------------------------------*) 
 
FUNCTION
      a93cancelled (acv_addr : tak_acv_address) : boolean;
 
BEGIN
a93cancelled :=
      acv_addr^.a_transinf.tri_trans.trRteCommPtr_gg00^.to_cancel
END;
 
(*------------------------------*) 
 
PROCEDURE
      a93init_caches (VAR acv : tak_all_command_glob);
 
BEGIN
acv.a_dca.code_p     := NIL;
acv.a_dca.value_p    := NIL;
acv.a_dca.code_size  := 0;
acv.a_dca.value_size := 0;
acv.a_dialog_area    := NIL;
acv.a_transinf.tri_trans.trBdTcachePtr_gg00 := NIL;
acv.a_transinf.tri_trans.trSessionId_gg00.ci4_gg00 := cgg_nil_session;
a10_init_cache (acv);
IF  acv.a_return_segm^.sp1r_returncode = 0
THEN
    BEGIN (* reserve space for syntax tree *)
    a10new (acv, (cak_init_node + 2) * sizeof (tak_ap_node),
          acv.a_ap_tree);
    IF  acv.a_ap_tree <> NIL
    THEN
        WITH acv.a_ap_tree^[cak_init_node + 1] DO
            BEGIN
            n_proc     := a10;
            n_special  := [ni_skip_node];
            n_pos      := 0;
            n_subproc  := 0;
            n_sa_level := 0;
            n_lo_level := 0
            END;
        (*ENDWITH*) 
    (*ENDIF*) 
    acv.a_ap_max_node := cak_init_node
    END
(*ENDIF*) 
END;
 
(* PTS 1107617 E.Z. *)
(*------------------------------*) 
 
PROCEDURE
      a93packet_vtrace (VAR t : tgg00_TransContext;
            trace_object      : tgg_vtrace_type;
            packet_ptr        : tsp1_packet_ptr);
 
VAR
      curr_segm : integer;
      curr_part : integer;
      trace_len : tsp_int4;
      segm_ptr  : tsp1_segment_ptr;
      part_ptr  : tsp1_part_ptr;
 
BEGIN
IF  g01vtrace.vtrAkPacket_gg00
THEN
    b120MoveObjectTrace (t, ak_sqlpacket, trace_object,
          s26packet_len (packet_ptr), @packet_ptr^.sp1_header)
ELSE
    IF  g01vtrace.vtrAll_gg00             OR
        g01vtrace.vtrAkShortPacket_gg00 OR
        g01vtrace.vtrAk_gg00
    THEN
        WITH packet_ptr^ DO
            BEGIN
            trace_len := sizeof (sp1_header) + sizeof (sp1_segm.sp1s_segm_header);
            IF  trace_len > sizeof (tgg11_VtraceBody)
            THEN
                trace_len := sizeof (tgg11_VtraceBody);
            (*ENDIF*) 
            b120InsertTrace (t, ak_packet_head, trace_object, trace_len, @sp1_header);
            segm_ptr := @sp1_segm;
            FOR curr_segm := 1 TO sp1_header.sp1h_no_of_segm DO
                BEGIN
                IF  curr_segm > 1
                THEN
                    BEGIN
                    s26next_segment (segm_ptr);
                    trace_len := sizeof (segm_ptr^.sp1s_segm_header);
                    IF  trace_len > sizeof (tgg11_VtraceBody)
                    THEN
                        trace_len := sizeof (tgg11_VtraceBody);
                    (*ENDIF*) 
                    b120InsertTrace (t, ak_packet_segm, trace_object, trace_len, @segm_ptr^)
                    END;
                (*ENDIF*) 
                part_ptr := @segm_ptr^.sp1p_part;
                FOR curr_part := 1 TO segm_ptr^.sp1s_no_of_parts DO
                    BEGIN
                    IF  curr_part > 1
                    THEN
                        s26nextpart (part_ptr);
                    (*ENDIF*) 
                    trace_len := s26partlen (part_ptr^);
                    IF  trace_len > sizeof (tgg11_VtraceBody)
                    THEN
                        trace_len := sizeof (tgg11_VtraceBody);
                    (*ENDIF*) 
                    b120InsertTrace (t, ak_packet_part, trace_object, trace_len, @part_ptr^)
                    END
                (*ENDFOR*) 
                END
            (*ENDFOR*) 
            END
        (*ENDWITH*) 
    (*ENDIF*) 
(*ENDIF*) 
END;
 
(*------------------------------*) 
 
PROCEDURE
      a93receive (acv_addr : tak_acv_address;
            VAR out_packet_ptr : tsp1_packet_ptr);
 
BEGIN
(*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*)
(*       called by stored procedures   *)
(*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*)
out_packet_ptr          := acv_addr^.a_out_packet;
acv_addr^.a_out_packet  := @acv_addr^.a_dca.value_p^;
IF  out_packet_ptr = acv_addr^.a_out_packet
THEN
    BEGIN (* restore header, PTS 1110376 *)
    acv_addr^.a_out_packet^.sp1_header.sp1h_mess_code :=
          acv_addr^.a_in_packet^.sp1_header.sp1h_mess_code;
    acv_addr^.a_out_packet^.sp1_header.sp1h_mess_swap :=
          acv_addr^.a_in_packet^.sp1_header.sp1h_mess_swap;
    acv_addr^.a_out_packet^.sp1_header.sp1h_appl_version :=
          acv_addr^.a_in_packet^.sp1_header.sp1h_appl_version;
    acv_addr^.a_out_packet^.sp1_header.sp1h_varpart_size :=
          acv_addr^.a_in_packet^.sp1_header.sp1h_varpart_size;
    END;
(*ENDIF*) 
acv_addr^.a_return_segm := @acv_addr^.a_out_packet^.sp1_segm
END;
 
(*------------------------------*) 
 
PROCEDURE
      a93request (acv_addr  : tak_acv_address;
            sql_packet_ptr  : tsp1_packet_ptr;
            out_packet      : tsp1_packet_ptr;
            out_packet_size : tsp00_Int4;
            VAR returncode  : tsp1_comm_error);
 
VAR
      do_release         : boolean;
      appl_type          : tak_appl_type;
      start_time_sec     : tsp_int4;
      start_time_msec    : tsp_int4;
      comp_vers          : tsp_c5;
      init_cmd_ptr       : tsp1_packet_ptr;
      cmd_segm_pos       : integer;
      sql_comm_err       : tsp1_comm_error;
 
BEGIN
(*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*)
(*       called by stored procedures   *)
(*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*)
WITH acv_addr^, sql_packet_ptr^ DO
    BEGIN
&   ifdef trace
    t01addr (ak_sem, 'acv_addr    ', acv_addr);
&   endif
    (* PTS 1112223 E.Z. *)
    (* a_transinf.tri_trans.trRteCommPtr_gg00^.to_cancel := false; *)
    start_time_sec   := 0;
    start_time_msec  := 0;
    returncode       := sp1ce_ok;
    init_cmd_ptr     := a_in_packet;
    a_in_packet      := sql_packet_ptr;
    a_cmd_segm       := @a_in_packet^.sp1_segm;
    a_data_part      := NIL;
    IF  acv_addr^.a_dbproc_level + acv_addr^.a_trigger_level = 1
    THEN
        a_dca.value_p := @a_out_packet^;
    (*ENDIF*) 
    a_out_packet     := out_packet;
    a_out_packet^.sp1_header := a_in_packet^.sp1_header;
    a_out_packet^.sp1_header.sp1h_varpart_size := out_packet_size - sizeof (sp1_header);
    s26first_segment_init (a_out_packet, sp1sk_return, a_return_segm);
    a_curr_retpart := NIL;
    cmd_segm_pos   := 1;
    do_release     := false;
    a_main_returncode := 0;
    a_main_errorpos   := 0;
    IF  g01vtrace.vtrAny_gg00
    THEN
        a93packet_vtrace (a_transinf.tri_trans, ak_receive, a_in_packet);
    (*ENDIF*) 
    a_mess_code := a_in_packet^.sp1_header.sp1h_mess_code;
    IF  a_mess_code <> a_session_mess_code
    THEN
        BEGIN
        IF  a_mess_code < csp_unicode_swap
        THEN
            a_max_codewidth := 1
        ELSE
            IF  a_mess_code <= csp_unicode
            THEN
                a_max_codewidth := 2
            (*ENDIF*) 
        (*ENDIF*) 
        END
    ELSE
        a_max_codewidth := a_session_max_codewidth;
    (*ENDIF*) 
    comp_vers   := a_comp_vers;
    appl_type   := a_comp_type;
    a_comp_type := at_odbc;
    a_comp_vers := a_in_packet^.sp1_header.sp1h_appl_version;
    IF  a_sysdir.ci_cache_p = NIL
    THEN
        BEGIN
        a93init_caches (acv_addr^);
        IF  a_return_segm^.sp1r_returncode <> 0
        THEN
            returncode := sp1ce_notok;
        (*ENDIF*) 
        END;
    (*ENDIF*) 
    IF  returncode = sp1ce_ok
    THEN
        BEGIN
        ak93one_command (acv_addr^, 1, cmd_segm_pos, NOT c_user_cmd, do_release);
        a93_sending     (acv_addr^, start_time_sec, start_time_msec, sql_comm_err);
        a_comp_vers   := comp_vers;
        a_comp_type   := appl_type;
        a_dynamic_sql := false;
        a_in_packet   := init_cmd_ptr;
        (* The interpreter may have overwritten the mess_code*)
        a_out_packet^.sp1_header.sp1h_mess_code :=
              a_in_packet^.sp1_header.sp1h_mess_code
        END
    (*ENDIF*) 
    END;
(*ENDWITH*) 
END;
 
(*------------------------------*) 
 
PROCEDURE
      a93vreceive (VAR acv   : tak_all_command_glob;
            timeout          : tsp_int4;
            VAR alloc_ok     : boolean;
            VAR sql_comm_err : tsp1_comm_error);
 
VAR
      useful_version      : boolean;
      rcv_packet_len      : tsp_int4;
      reply_packet_size   : tsp_int4;
 
BEGIN
vreceive (acv.a_transinf.tri_trans.trTaskId_gg00, timeout,
      acv.a_in_packet, rcv_packet_len,
      acv.a_out_packet, reply_packet_size, sql_comm_err);
(* PTS 1105744 E.Z. *)
useful_version := true;
IF  (NOT acv.a_in_session)
    AND
    (sql_comm_err = sp1ce_ok)
THEN
    ak93get_appl_and_vers (acv, useful_version, sql_comm_err);
(* END OF PTS 1105744 E.Z. *)
(* PTS 1107485 E.Z. *)
(*ENDIF*) 
acv.a_abap_tab_comm_ok := (sql_comm_err = sp1ce_ok);
IF  sql_comm_err = sp1ce_ok
THEN
    WITH acv DO
        BEGIN
        IF  alloc_ok
        THEN
            BEGIN
            (* even if not useful_version it has to be done because *)
            (* of swapping and initializing everything*)
            (* PTS 1108262 E.Z. *)
            IF  (acv.a_in_packet^.sp1_header.sp1h_mess_swap <> g01code.kernel_swap)
                OR (NOT a_in_session)
            THEN (* Change request 1001193, T.A. 23.10.1998 *)
                a93swap_from_application (acv);
            (*ENDIF*) 
            END;
        (*ENDIF*) 
        a_cmd_segm  := @a_in_packet^.sp1_segm;
        a_data_part := NIL;
        WITH a_out_packet^ DO
            BEGIN
            sp1_header := a_in_packet^.sp1_header;
            sp1_header.sp1h_varpart_size := reply_packet_size -
                  sizeof (sp1_header);
            (* the following statement can be dropped when the rte *tsp_int4)
                  (* guarantees a properly aligned packet size !!! J.P.  *)
            sp1_header.sp1h_varpart_size := (sp1_header.sp1h_varpart_size DIV
                  csp1_part_align_length) * csp1_part_align_length;
            END;
        (*ENDWITH*) 
        s26first_segment_init (a_out_packet, sp1sk_return, a_return_segm);
        a_curr_retpart   := NIL;
        a_retpart_locked := false;
        IF  NOT alloc_ok
        THEN
            a07_nb_put_error (acv, e_no_more_memory, 1,
                  a01_i_oldpacket)
        ELSE
            IF  NOT useful_version
            THEN
                a07_b_put_error (acv, e_too_old_tool, 1)
            ELSE
                WITH a_in_packet^.sp1_header DO
                    IF  ((sp1h_mess_swap =  sw_normal) AND
                        ( sp1h_mess_code =  csp_unicode_swap))
                        OR
                        ((sp1h_mess_swap <> sw_normal) AND
                        ( sp1h_mess_code =  csp_unicode))
                    THEN
                        a07_b_put_error (acv,
                              e_invalid_messcodetype, 1);
                    (*ENDIF*) 
                (*ENDWITH*) 
            (*ENDIF*) 
        (*ENDIF*) 
        END
    (*ENDWITH*) 
(*ENDIF*) 
END;
 
(*------------------------------*) 
 
PROCEDURE
      ak93clear (VAR acv    : tak_all_command_glob;
            sql_comm_err    : tsp1_comm_error;
            start_time_sec  : tsp_int4;
            start_time_msec : tsp_int4;
            VAR do_release  : boolean);
 
VAR
      intern_command : tsp_page;
 
BEGIN
(* *** +++ voruebergehende Loesung +++ *** *)
acv.a_in_packet := @intern_command;
WITH acv DO
    BEGIN
    s26first_segment_init (a_in_packet, sp1sk_cmd, a_cmd_segm);
    WITH a_in_packet^, sp1_header DO
        BEGIN
        sp1h_mess_code := g01code.ctype;
        sp1h_mess_swap := g01code.kernel_swap;
        sp1h_varpart_size := sizeof (intern_command) -
              sizeof (sp1_header)
        END;
    (*ENDWITH*) 
    a_data_part    := NIL;
    a_curr_retpart := NIL;
    IF  a_out_packet = NIL
    THEN
        a_out_packet := @a_in_packet^.sp1_varpart[ 1 ];
    (*ENDIF*) 
    s26first_segment_init (a_out_packet, sp1sk_return, a_return_segm)
    END;
(*ENDWITH*) 
ak93receive_error (acv, sql_comm_err, start_time_sec, start_time_msec);
do_release := true
END;
 
(*------------------------------*) 
 
PROCEDURE
      ak93ddl_fct_code (VAR acv : tak_all_command_glob);
 
BEGIN
WITH acv, a_return_segm^ DO
    CASE a_init_ddl OF
        ddl_alter_password :
            sp1r_function_code := csp1_alter_password_fc;
        ddl_alter_tab_add, ddl_alter_tab_alter, ddl_alter_tab_drop,
        ddl_add_constraint, ddl_drop_constraint, ddl_alter_constraint,
        ddl_alter_key, ddl_alter_table :
            sp1r_function_code := csp1_alter_table_fc;
        ddl_alter_dbproc :
            sp1r_function_code := csp1_alter_procedure_fc;
        ddl_alter_trigger :
            sp1r_function_code := csp1_alter_trigger_fc;
        ddl_alter_user :
            sp1r_function_code := csp1_alter_user_fc;
        ddl_comment_on :
            sp1r_function_code := csp1_comment_fc;
        ddl_create_db_link :
            sp1r_function_code := csp1_create_dl_database_link;
        ddl_create_domain :
            sp1r_function_code := csp1_create_domain_fc;
        ddl_create_index :
            sp1r_function_code := csp1_create_index_fc;
        ddl_create_link :
            sp1r_function_code := csp1_link_fc;
        ddl_create_role :
            sp1r_function_code := csp1_create_role_fc;
        ddl_create_procedure :
            sp1r_function_code := csp1_create_procedure_fc;
        ddl_create_schema :
            sp1r_function_code := csp1_create_schema_fc;
        ddl_create_sequence :
            sp1r_function_code := csp1_create_sequence_fc;
        (* PTS 1111576 E.Z. *)
        ddl_create_synonym :
            sp1r_function_code := csp1_create_synonym_fc;
        ddl_create_table, ddl_create_as_select :
            sp1r_function_code := csp1_create_table_fc;
        ddl_create_trigger :
            sp1r_function_code := csp1_create_trigger_fc;
        ddl_create_user :
            sp1r_function_code := csp1_create_user_fc;
        ddl_create_view :
            sp1r_function_code := csp1_create_view_fc;
        ddl_drop_db_link :
            sp1r_function_code := csp1_drop_dl_database_link;
        ddl_drop_domain :
            sp1r_function_code := csp1_drop_domain_fc;
        ddl_drop_index :
            sp1r_function_code := csp1_drop_index_fc;
        ddl_drop_link :
            sp1r_function_code := csp1_link_fc;
        ddl_drop_package, ddl_drop_procedure : (* PTS 1115155 E.Z. *)
            sp1r_function_code := csp1_drop_procedure_fc;
        ddl_drop_role :
            sp1r_function_code := csp1_drop_role_fc;
        ddl_drop_sequence :
            sp1r_function_code := csp1_drop_sequence_fc;
        (* PTS 1111576 E.Z. *)
        ddl_drop_synonym :
            sp1r_function_code := csp1_drop_synonym_fc;
        ddl_drop_table :
            sp1r_function_code := csp1_drop_table_fc;
        ddl_drop_trigger :
            sp1r_function_code := csp1_drop_trigger_fc;
        ddl_drop_user :
            sp1r_function_code := csp1_drop_user_fc;
        ddl_drop_view :
            sp1r_function_code := csp1_drop_view_fc;
        ddl_grant_execute, ddl_grant_privilege, ddl_grant_user :
            sp1r_function_code := csp1_grant_fc;
        (* PTS 1111229 E.Z. *)
        ddl_rename_column, ddl_rename_index, ddl_rename_synonym,
        ddl_rename_table,  ddl_rename_view, ddl_rename_user :
            (* h.b. PTS 1001663 *)
            sp1r_function_code := csp1_rename_fc;
        ddl_revoke_execute, ddl_revoke_privilege :
            sp1r_function_code := csp1_revoke_fc;
        ddl_update_statistics :
            sp1r_function_code := csp1_analyze_table_fc;
        OTHERWISE :
            BEGIN
            sp1r_function_code := csp1_nil_fc;
&           ifdef TRACE
            t01int4 (ak_sem, 'ddl-Type    ', ord(a_is_ddl));
&           endif
            END;
        END;
    (*ENDCASE*) 
(*ENDWITH*) 
END;
 
(*------------------------------*) 
 
PROCEDURE
      ak93ddl_parseid (VAR acv : tak_all_command_glob);
 
VAR
      ix       : integer;
      parseid  : tak_parsid;
      part_ptr : tsp1_part_ptr;
 
BEGIN
IF  acv.a_return_segm^.sp1r_returncode = 0
THEN
    BEGIN
    a92find_return_part (acv, sp1pk_parsid, part_ptr);
    IF  part_ptr = NIL
    THEN
        BEGIN
        parseid.pid_session.ci4_gg00 := cgg_nil_session;
        FOR ix := 1 TO sizeof (parseid.pid_parsk.p_count) DO
            parseid.pid_parsk.p_count[ix] := chr(0);
        (*ENDFOR*) 
        parseid.pid_parsk.p_id    := chr (0);
        parseid.pid_parsk.p_kind  := m_nil;
        parseid.pid_parsk.p_no    := 0;
        parseid.pid_appl_info[1]  := chr (csp1_p_command_executed);
        parseid.pid_dtime_info[1] := chr (0);
        a06retpart_move (acv, @parseid, mxak_parsid);
        a06finish_curr_retpart (acv, sp1pk_parsid, 1);
        a06init_curr_retpart   (acv);
        a06finish_curr_retpart (acv, sp1pk_shortinfo, 0)
        END;
    (*ENDIF*) 
    END;
(*ENDIF*) 
END;
 
(*------------------------------*) 
 
PROCEDURE
      ak93implicit_release (VAR acv : tak_all_command_glob);
 
BEGIN
IF  ((NOT acv.a_restarted) AND (a94mode = umUser_egg00))
THEN
    acv.a_restarted := true;
(*ENDIF*) 
WITH acv DO
    BEGIN
    IF  a94mode = umUser_egg00
    THEN
        BEGIN
        a_ex_kind    := parsing_executing;
        a52_ex_commit_rollback (acv, m_rollback, c_n_rel,
              NOT c_normal_release );
        a_return_segm^.sp1r_returncode := cak_e_released;
        a_return_segm^.sp1r_errorpos   := 0;
        END
    ELSE
        a_curr_user_name := a01_il_b_identifier;
    (*ENDIF*) 
    END
(*ENDWITH*) 
END;
 
(*------------------------------*) 
 
PROCEDURE
      ak93one_command (VAR acv : tak_all_command_glob;
            cmd_index        : integer;
            VAR cmd_segm_pos : tsp_int4;
            user_command     : boolean;
            VAR do_release   : boolean);
 
VAR
      commit_command        : boolean;
      b_err                 : tgg_basis_error;
      m_return_code         : tsp_int2;
      start_subtrans        : tgg00_SubtransNo;
      start_transid         : tgg91_TransNo;
      dummy_surrogate       : tgg_surrogate;
      m_a_dt_format         : tgg_datetimeformat;
      part_count            : integer;
      del_cnt               : integer;
      part_desc_ptr         : tsp1_part_ptr;
      hparsid               : tsp_c12;
      hpart                 : tsp1_part_ptr;
      parsid                : tak_parsid;
      parsid_ptr            : ^tak_parsid;
&     ifdef TRACE
      startstack            : tsp_int4;
      maxstack              : tsp_int4;
&     endif
      curr_part_ptr       : tsp1_part_ptr;
      next_part_ptr       : tsp1_part_ptr;
      part                : integer;
      err_char_no         : tsp_int4;
      e                   : tsp8_uni_error;
 
BEGIN
WITH acv DO
    BEGIN
    m_a_dt_format := dtf_none;
&   ifdef TRACE
    vscheck (startstack);
    (* PTS 1110953 E.Z. *)
    vsResetCmdMax (acv.a_transinf.tri_trans.trTaskId_gg00);
&   endif
    IF  a_command_count < csp_maxint4
    THEN
        a_command_count := succ (a_command_count)
    ELSE
        BEGIN
        a10_cache_delete (acv, NOT c_is_rollback);
        a_command_count := 1
        END;
    (*ENDIF*) 
    a_cmd_segm := @a_in_packet^.sp1_varpart [ cmd_segm_pos ];
    WITH a_cmd_segm^ DO
        BEGIN
        IF  (sp1s_segm_len MOD csp1_part_align_length <> 0)              OR
            (* PTS 1112969 E.Z. *)
            ((sp1s_no_of_parts <  1) AND (sp1c_mess_type <> sp1m_hello)) OR
            ((sp1s_no_of_parts <> 0) AND (sp1c_mess_type =  sp1m_hello)) OR
            (sp1s_own_index <> cmd_index)
        THEN
            a92_reject (acv, NOT c_utilityprocess)
        ELSE
            BEGIN
            cmd_segm_pos := cmd_segm_pos + sp1s_segm_len;
            IF  a_in_session
            THEN
                BEGIN
                CASE sp1c_sqlmode OF
                    sp1sm_session_sqlmode :
                        a_sqlmode := a_session_sqlmode;
                    sp1sm_adabas :
                        a_sqlmode := sqlm_adabas;
                    sp1sm_ansi :
                        a_sqlmode := sqlm_ansi;
                    sp1sm_db2 :
                        a_sqlmode := sqlm_db2;
                    sp1sm_oracle :
                        BEGIN
                        a_sqlmode     := sqlm_oracle;
                        m_a_dt_format := a_dt_format;
                        (* PTS 1119051 E.Z. *)
                        IF  (a_comp_type <> at_odbc) AND
                            (a_comp_type <> at_jdbc)
                        THEN
                            a_dt_format := dtf_oracle_date
                        (*ENDIF*) 
                        END
                    OTHERWISE
                        a92_reject (acv, NOT c_utilityprocess)
                    END;
                (*ENDCASE*) 
                start_subtrans := a_transinf.tri_trans.trSubtransId_gg00;
                start_transid  := a_transinf.tri_trans.trTransId_gg00;
                END
            ELSE
                BEGIN
                start_subtrans         := cgg_zero_subtrans;
                start_transid.ci6_gg00 := cgg_nil_trans;
                END;
            (*ENDIF*) 
            a_rollback_info     := [  ];
            a_stored_proc_call  := false;
            a_internal_sql      := no_internal_sql;
            a_execute_trigger   := false;
            a_long_desc_pos     := 0;
            a_in_internal_subtr := false;
            a_init_ddl          := no_ddl;
            a_statement_kind    := isql_commands;
            a_fromsel_n         := 0;
            a_complex_key       := cgg_zero_id;
            a_recursive_state   := rs_no_recursive_select;
            IF  a_transinf.tri_trans.trTransId_gg00.ci6_gg00 = cgg_nil_trans
            THEN
                BEGIN
                a07_b_put_error (acv,
                      e_new_session_required, 1);
                commit_command := false;
                do_release := true;
                END
            ELSE
                (* PTS 1112223 E.Z. *)
                IF  a_release_instances
                THEN
                    BEGIN
                    a07_b_put_error (acv, e_release_caused_by_shutdown, 1);
                    commit_command := false;
                    do_release := false;
                    END
                ELSE
                    BEGIN
                    commit_command := sp1c_commit_immediately;
                    (* PTS 1112223 E.Z. *)
                    (* PTS 1112849 E.Z. *)
                    IF  (a94mode = umUser_egg00)
                        AND
                        (a_transinf.tri_trans.trRteCommPtr_gg00^.to_cancel)
                        AND
                        (cmd_index = 1)
                        AND
                        user_command
                    THEN
                        BEGIN
                        a_transinf.tri_trans.trRteCommPtr_gg00^.to_cancel := false;
                        IF  k51shutdown_wanted (a_transinf.tri_trans.trTaskId_gg00)
                        THEN
                            BEGIN
                            a07_b_put_error (acv, e_release_caused_by_shutdown, 1);
                            commit_command := false;
                            do_release := false;
                            END
                        (*ENDIF*) 
                        END;
                    (*ENDIF*) 
                    CASE sp1c_mess_type OF
                        (* PTS 1111575 E.Z. *)
                        sp1m_load :
                            BEGIN
                            part_desc_ptr := NIL;
                            part_count    := 0;
                            WHILE (part_count < a_cmd_segm^.sp1s_no_of_parts)
                                  AND  (a_return_segm^.sp1r_returncode = 0) DO
                                BEGIN
                                a92_next_part_get (acv, part_desc_ptr);
                                IF  a_return_segm^.sp1r_returncode = 0
                                THEN
                                    IF  part_desc_ptr^.sp1p_part_kind = sp1pk_page
                                    THEN
                                        BEGIN
                                        a_data_ptr    := @part_desc_ptr^.sp1p_buf;
                                        a_data_length := part_desc_ptr^.sp1p_buf_len
                                        END
                                    ELSE
                                        IF  part_desc_ptr^.sp1p_part_kind =
                                            sp1pk_bdinfo
                                        THEN
                                            a_cmd_part := part_desc_ptr;
                                        (*ENDIF*) 
                                    (*ENDIF*) 
                                (*ENDIF*) 
                                part_count := part_count + 1
                                END;
                            (*ENDWHILE*) 
                            IF  a_return_segm^.sp1r_returncode = 0
                            THEN
                                a09exec_load (acv)
                            (*ENDIF*) 
                            END;
                        sp1m_unload :
                            BEGIN
                            a_cmd_part := NIL;
                            a92_next_part_get (acv, a_cmd_part);
                            IF  a_return_segm^.sp1r_returncode = 0
                            THEN
                                BEGIN
                                a09unload (acv);
                                a_ex_kind := parsing_executing
                                END
                            (*ENDIF*) 
                            END;
                        sp1m_putval,
                        sp1m_getval :
                            BEGIN
                            a_ex_kind     := only_executing;
                            part_count    := 0;
                            part_desc_ptr := NIL;
                            WHILE (part_count < a_cmd_segm^.sp1s_no_of_parts)
                                  AND  (a_return_segm^.sp1r_returncode = 0) DO
                                BEGIN
                                a92_next_part_get (acv, part_desc_ptr);
                                IF  (a_return_segm^.sp1r_returncode = 0) AND
                                    (part_desc_ptr^.sp1p_part_kind=sp1pk_longdata)
                                THEN
                                    BEGIN
                                    WITH part_desc_ptr^ DO
                                        BEGIN
                                        a_data_ptr    := @sp1p_buf[ 1 ];
                                        a_data_length := sp1p_buf_len;
                                        a_data_part   := part_desc_ptr;
                                        END;
                                    (*ENDWITH*) 
                                    IF  sp1c_mess_type = sp1m_getval
                                    THEN
                                        BEGIN
                                        a508_getval (acv);
                                        a_return_segm^.sp1r_function_code :=
                                              csp1_getval_fc
                                        END
                                    ELSE
                                        BEGIN
                                        a507_putval (acv, 1,
                                              NOT c_intern_call);
                                        a_return_segm^.sp1r_function_code :=
                                              csp1_putval_fc
                                        END;
                                    (*ENDIF*) 
                                    END;
                                (*ENDIF*) 
                                part_count := succ (part_count);
                                END;
                            (*ENDWHILE*) 
                            END;
                        OTHERWISE
                            BEGIN
                            (* Reset pointer to already deleted *)
                            (* intern result of last select.    *)
                            a_resname_addr[cak_intern_pos] := NIL;
                            acv.a_uni_cmd_part := NIL;
                            a92_mode_analyzer (acv, no_ddl, NOT c_corr_select);
                            (* PTS 1112223 E.Z. *)
                            IF  (NOT a_transinf.tri_trans.trRteCommPtr_gg00^.to_cancel)
                                AND
                                (a_return_segm^.sp1r_returncode <>
                                a07_return_code ( e_cancelled, a_sqlmode))
                            THEN
                                BEGIN
                                IF  acv.a_stored_proc_call
                                THEN
                                    BEGIN
                                    acv.a_stored_proc_call := false;
                                    IF  a_return_segm^.sp1r_returncode = csp_use_new_pars_info
                                    THEN
                                        BEGIN (* PTS 1118883 *)
                                        a_return_segm^.sp1r_returncode := 0;
                                        a260exec_dialog (acv);
                                        IF  a_return_segm^.sp1r_returncode = 0
                                        THEN
                                            a_return_segm^.sp1r_returncode := csp_use_new_pars_info;
                                        (*ENDIF*) 
                                        END
                                    ELSE
                                        a260exec_dialog (acv)
                                    (*ENDIF*) 
                                    END
                                ELSE
                                    IF  (a_is_ddl = ddl_create_as_select) AND
                                        (a_init_ex_kind <> only_syntax  )
                                    THEN
                                        a14create_tab_as_select (acv,
                                              dummy_surrogate,
                                              a_pars_last_key);
                                    (* PTS 1112223 E.Z. *)
                                    (*ENDIF*) 
                                (*ENDIF*) 
                                END;
                            (*ENDIF*) 
                            IF  a_cmd_segm^.sp1c_producer = sp1pr_kernel
                            THEN
                                a542reset_packet (acv);
                            (*ENDIF*) 
                            IF  acv.a_uni_cmd_part <> NIL
                            THEN
                                BEGIN
                                (* release unicode part *)
                                a10dispose (acv, acv.a_uni_cmd_part);
                                acv.a_cmd_part := @acv.a_cmd_segm^.sp1p_part
                                END
                            (* PTS 1109070 E.Z. *)
                            ELSE
                                IF  (user_command                                AND
                                    (a_return_segm^.sp1r_returncode <> 0)        AND
                                    (a_cmd_segm^.sp1c_mess_type <> sp1m_execute) AND
                                    (a_in_packet^.sp1_header.sp1h_mess_code = csp_unicode_swap))
                                THEN
                                    BEGIN
                                    WITH a_cmd_segm^ DO
                                        BEGIN
                                        curr_part_ptr := @sp1p_part_header;
                                        part := 1;
                                        WHILE part <= sp1s_no_of_parts DO
                                            BEGIN
                                            WITH curr_part_ptr^ DO
                                                BEGIN
                                                IF  sp1p_part_kind = sp1pk_command
                                                THEN
                                                    BEGIN
                                                    s80uni_trans (@sp1p_buf[ 1 ], sp1p_buf_len,
                                                       csp_unicode,
                                                       @sp1p_buf[ 1 ], sp1p_buf_len,
                                                       csp_unicode_swap, [ ], e, err_char_no);
                                                    part := sp1s_no_of_parts;
                                                    END
                                                ELSE
                                                    BEGIN
                                                    next_part_ptr := @curr_part_ptr^.
                                                       sp1p_buf[1 + a01aligned_cmd_len (
                                                       curr_part_ptr^.sp1p_buf_len)];
                                                    curr_part_ptr := next_part_ptr;
                                                    END
                                                (*ENDIF*) 
                                                END;
                                            (*ENDWITH*) 
                                            part := succ(part);
                                            END;
                                        (*ENDWHILE*) 
                                        END
                                    (*ENDWITH*) 
                                    END;
                                (*ENDIF*) 
                            (*ENDIF*) 
                            IF  (a_return_segm^.sp1r_returncode = 0) AND
                                (sp1c_mess_type = sp1m_parse)
                            THEN
                                IF  a_input_data_pos >
                                    a_in_packet^.sp1_segm.sp1p_buf_size -
                                    sizeof(tsp1_part_header) -
                                    a01aligned_cmd_len (mxak_parsid + 1)
                                THEN
                                    BEGIN
                                    s26find_part (a_return_segm^,
                                          sp1pk_parsid, part_desc_ptr);
                                    parsid_ptr := @(part_desc_ptr^.sp1p_buf);
                                    parsid     := parsid_ptr^;
                                    (* PTS 1114071 E.Z. *)
                                    a663_drop_parsid (acv, parsid.pid_parsk, del_cnt);
                                    a07_b_put_error (acv,
                                          e_too_small_packet_size, 1);
                                    END;
                                (*ENDIF*) 
                            (*ENDIF*) 
                            END
                        END;
                    (*ENDCASE*) 
                    (* PTS 1112223 E.Z. *)
                    (* PTS 1112849 E.Z. *)
                    IF  (a94mode = umUser_egg00)
                        AND
                        (
                        (a_transinf.tri_trans.trRteCommPtr_gg00^.to_cancel)
                        OR
                        (a_return_segm^.sp1r_returncode =
                        a07_return_code ( e_cancelled, a_sqlmode))
                        )
                    THEN
                        IF  k51shutdown_wanted (a_transinf.tri_trans.trTaskId_gg00)
                        THEN
                            BEGIN
                            a_return_segm^.sp1r_returncode := 0;
                            a07_b_put_error (acv, e_release_caused_by_shutdown, 1);
                            a_release_instances := true;
                            END;
                        (*ENDIF*) 
                    (*ENDIF*) 
                    IF  a_init_ddl <> no_ddl
                    THEN
                        BEGIN
                        ak93ddl_fct_code (acv);
                        IF  a_cmd_segm^.sp1c_mess_type = sp1m_parse
                        THEN
                            ak93ddl_parseid (acv);
                        (*ENDIF*) 
                        IF  a_return_segm^.sp1r_returncode = 0
                        THEN
                            a260internal_proc_call (acv);
                        (*ENDIF*) 
                        IF  (a_sqlmode = sqlm_oracle) AND
                            NOT (a_progusage_add)
                        THEN
                            commit_command := true;
                        (* PTS 1112223 E.Z. *)
                        (*ENDIF*) 
                        IF  a_release_instances
                        THEN
                            BEGIN
                            a_return_segm^.sp1r_returncode := 0;
                            a07_b_put_error (acv, e_release_caused_by_shutdown, 1);
                            commit_command := false;
                            do_release := false;
                            END
                        (*ENDIF*) 
                        END;
                    (* PTS 1112223 E.Z. *)
                    (*ENDIF*) 
                    IF  NOT a_release_instances
                    THEN
                        BEGIN
                        IF  a_execute_trigger
                        THEN
                            a262execute_trigger (acv);
                        (* PTS 1112223 E.Z. *)
                        (*ENDIF*) 
                        IF  a_release_instances
                        THEN
                            BEGIN
                            a_return_segm^.sp1r_returncode := 0;
                            a07_b_put_error (acv, e_release_caused_by_shutdown, 1);
                            commit_command := false;
                            do_release := false;
                            END
                        ELSE
                            IF  a_rollback_info <> [  ]
                            THEN
                                a09rollback (acv, b_err)
                            ELSE
                                IF  a_in_internal_subtr
                                THEN
                                    BEGIN
                                    a52end_rollback_subtrans (acv,
                                          a01_il_b_identifier, m_end);
                                    (* we had the case that a52end_rollback_subtrans *)
                                    (* caused a severe error and the local rollback  *)
                                    (* was not called. The result: different values  *)
                                    (* for the same thing could exist in a           *)
                                    (* distributed database.                         *)
                                    IF  a_rollback_info <> [  ]
                                    THEN
                                        a09rollback (acv, b_err);
                                    (*ENDIF*) 
                                    IF  NOT (sp1c_mess_type IN [sp1m_putval, sp1m_getval])
                                        AND (start_transid = a_transinf.tri_trans.trTransId_gg00)
                                    THEN
                                        IF  (a_transinf.tri_trans.trSubtransId_gg00 <> start_subtrans)
                                        THEN
                                            a07_b_put_error (acv, e_invalid_subtrans_structure, 1)
                                        (*ENDIF*) 
                                    (*ENDIF*) 
                                    END;
                                (*ENDIF*) 
                            (*ENDIF*) 
                        (*ENDIF*) 
                        IF  commit_command AND
                            NOT ak93pending_putval ( acv )
                        THEN
                            BEGIN
                            (* PTS 1104822 E.Z. *)
                            IF  (a_return_segm^.sp1r_returncode = 0)
                                OR
                                (
                                (a_return_segm^.sp1r_returncode =
                                a07_return_code (e_row_not_found, a_sqlmode))
                                AND
                                (* PTS 1105304 E.Z. *)
                                (
                                (a_return_segm^.sp1r_function_code in
                                [ csp1_select_fc,
                                csp1_select_into_fc,
                                csp1_mselect_fc,
                                csp1_mselect_into_fc ])
                                OR
                                ((a_return_segm^.sp1r_function_code >= csp1_select_direct_fc) AND
                                ( a_return_segm^.sp1r_function_code <= csp1_fetch_same_fc))
                                OR
                                ((a_return_segm^.sp1r_function_code >= csp1_mfetch_first_fc) AND
                                ( a_return_segm^.sp1r_function_code <= csp1_mfetch_same_fc))
                                )
                                )
                            THEN
                                a52_ex_commit_rollback (acv,
                                      m_commit, NOT c_n_rel,
                                      c_normal_release)
                            ELSE
                                IF  (a_return_segm^.sp1r_returncode <>
                                    cak_e_roll_released) AND
                                    (a_return_segm^.sp1r_returncode <> cak_e_released)
                                    (* PTS 1109783 E.Z. *)
                                    AND NOT
                                    (
                                    ((a_return_segm^.sp1r_function_code = csp1_commit_release_fc) OR
                                    ( a_return_segm^.sp1r_function_code = csp1_rollback_release_fc))
                                    AND
                                    (a_cmd_segm^.sp1c_mess_type in [ sp1m_dbs, sp1m_execute ])
                                    )
                                THEN
                                    a52_ex_commit_rollback (acv,
                                          m_rollback, NOT c_n_rel,
                                          c_normal_release)
                                (*ENDIF*) 
                            (*ENDIF*) 
                            END;
                        (* PTS 1112223 E.Z. *)
                        (*ENDIF*) 
                        END;
                    (*ENDIF*) 
                    a_sysdir.ci_cmd_rollback_tree.fileRoot_gg00 :=
                          NIL_PAGE_NO_GG00;
&                   ifdef TRACE
                    IF  ((sp1c_mess_type > sp1m_specials_lower_bound) AND
                        ( sp1c_mess_type < sp1m_specials_upper_bound) AND
                        ((a94mode = umUtility_egg00) OR
                        NOT a_in_session))
                    THEN
                        do_release := true;
&                   else
                    (*ENDIF*) 
                    IF  (sp1c_mess_type = sp1m_state_utility) AND
                        (NOT a_in_session)
                    THEN
                        do_release := true;
&                   endif
                    (*ENDIF*) 
                    IF  (a_statement_kind <> icollisions)
                    THEN
                        b73cmd_count (a_statement_kind);
                    (*ENDIF*) 
                    END;
                (*ENDIF*) 
            (*ENDIF*) 
            IF  m_a_dt_format <> dtf_none
            THEN
                a_dt_format := m_a_dt_format;
            (*ENDIF*) 
            IF  NOT a_in_session
            THEN
                IF  a_return_segm^.sp1r_returncode <> 0
                THEN
                    do_release := true
                ELSE
                    IF  sp1c_mess_type = sp1m_dbs
                    THEN
                        IF  a94mode = umUtility_egg00
                        THEN (* cold vtrace *)
                            do_release := true
                        ELSE
                            (* PTS 1000813 E.Z. *)
                            IF  a_return_segm^.sp1r_function_code = csp1_connect_fc
                            THEN
                                a_in_session := true
                            ELSE
                                do_release := true;
                            (*ENDIF*) 
                        (*ENDIF*) 
                    (*ENDIF*) 
                (*ENDIF*) 
            (*ENDIF*) 
            END;
        (*ENDIF*) 
        IF  (a_return_segm^.sp1r_returncode = cak_e_released     ) OR
            (a_return_segm^.sp1r_returncode = cak_e_roll_released)
        THEN
            BEGIN
            a_return_segm^.sp1r_returncode  := 0;
            do_release   := true;
            a_in_session := false
            END
        (* PTS 1109783 E.Z. *)
        ELSE
            IF  (
                ((a_return_segm^.sp1r_function_code = csp1_commit_release_fc) OR
                ( a_return_segm^.sp1r_function_code = csp1_rollback_release_fc))
                AND
                (a_cmd_segm^.sp1c_mess_type in [ sp1m_dbs, sp1m_execute ])
                )
            THEN
                BEGIN
                do_release   := true;
                a_in_session := false
                END;
            (* PTS 1116801 E.Z. *)
            (*ENDIF*) 
        (*ENDIF*) 
        END;
    (*ENDWITH*) 
    IF  (a_return_segm^.sp1r_returncode <> 0)                     AND
        (a_return_segm^.sp1r_returncode <> csp_use_new_pars_info) AND
        (a_return_segm^.sp1r_returncode <> csp_splitted_commands) AND
        (* PTS 1116801 E.Z. *)
        (a_cmd_segm^.sp1c_mess_type <> sp1m_load)                 AND
        (a_cmd_segm^.sp1c_mess_type <> sp1m_unload)
    THEN
        IF  NOT (a_user_defined_error)
            (* PTS 1112223 E.Z. *)
            OR
            (a_return_segm^.sp1r_returncode =
            a07_return_code ( e_release_caused_by_shutdown, a_sqlmode))
            OR
            (a_return_segm^.sp1r_returncode = -904)
            OR
            (a_return_segm^.sp1r_returncode =
            a07_return_code (e_new_session_required, a_sqlmode))
        THEN
            BEGIN
            a07_intern_error_put (acv);
            IF  a_return_segm^.sp1r_returncode = 100
            THEN
                a92_resname_to_varpart (acv);
            (*ENDIF*) 
            IF  (a_cmd_segm^.sp1c_mess_type = sp1m_execute) AND
                (acv.a_precomp_info_byte >= csp1_p_mass_command)
            THEN
                BEGIN
                (* mass_cmd *)
                a06retpart_move (acv, @a_resultnum, sizeof(a_resultnum));
                a06finish_curr_retpart (acv, sp1pk_resultcount, 1);
                END;
            (* PTS 1112223 E.Z. *)
            (*ENDIF*) 
            IF  (acv.a_trigger_level = 0) AND
                (acv.a_dbproc_level  = 0)
            THEN
                IF  (a_return_segm^.sp1r_returncode =
                    a07_return_code ( e_release_caused_by_shutdown,
                    a_sqlmode))
                    OR
                    (a_return_segm^.sp1r_returncode = -904)
                    OR
                    (a_return_segm^.sp1r_returncode =
                    a07_return_code (e_new_session_required,
                    a_sqlmode))
                THEN
                    BEGIN
                    m_return_code := a_return_segm^.sp1r_returncode;
                    a_return_segm^.sp1r_returncode     := 0;
                    a_transinf.tri_trans.trRteCommPtr_gg00^.to_cancel := false;
                    a52_ex_commit_rollback (acv, m_rollback,
                          c_n_rel, NOT c_normal_release);
                    IF  a_return_segm^.sp1r_returncode = cak_e_released
                    THEN
                        BEGIN
                        a_return_segm^.sp1r_returncode   := m_return_code;
                        do_release    := true;
                        a_in_session  := false
                        END
                    (*ENDIF*) 
                    END;
                (*ENDIF*) 
            (*ENDIF*) 
            END
        ELSE
            BEGIN
            a92find_return_part (acv, sp1pk_parsid, hpart);
            IF  (a_ex_kind = only_parsing) AND (hpart = NIL)
            THEN
                BEGIN
                (* DDL or SHOW statement in the course of a *)
                (* precompiler compilation with check.      *)
                (* return a dummy parseid                   *)
                s10fil2 (mxak_parsid, hparsid, 1, mxak_parsid, chr (0));
                hparsid [mxak_parsid - 1] := chr(csp1_p_command_executed);
                a06retpart_move (acv, @hparsid, mxak_parsid);
                a06finish_curr_retpart (acv, sp1pk_parsid, 1);
                END;
            (*ENDIF*) 
            END;
        (*ENDIF*) 
    (*ENDIF*) 
    WITH a_return_segm^ DO
        BEGIN
        s03getsqlstate (sp1r_returncode,
              sp1r_extern_warning, sp1r_sqlstate);
        IF  a_size_ptr <> NIL
        THEN
            sp1r_tracelevel := a_size_ptr^.csz_tracelevel;
        (*ENDIF*) 
        END;
    (*ENDWITH*) 
&   ifdef TRACE
    (* PTS 1110953 E.Z. *)
    WITH acv.a_transinf.tri_trans DO
        BEGIN
        t01int4 (st_stack, 'pid         ', trTaskId_gg00);
        vsGetCmdMax(trTaskId_gg00, maxstack);
        t01int4 (st_stack, 'tdmaxstack  ', maxstack);
        t01int4 (st_stack, 'startstack  ', startstack);
        END;
    (*ENDWITH*) 
&   endif
    END
(*ENDWITH*) 
END;
 
(*------------------------------*) 
 
PROCEDURE
      ak93receive_error (VAR acv : tak_all_command_glob;
            sql_comm_err         : tsp1_comm_error;
            start_time_sec       : tsp_int4;
            start_time_msec      : tsp_int4);
 
VAR
      tr : tsp_c1;
 
BEGIN
WITH acv DO
    BEGIN
    IF  g01vtrace.vtrAny_gg00
    THEN
        BEGIN
        tr[ 1 ] := chr(ord(sql_comm_err));
        b120InsertTrace (a_transinf.tri_trans,
              ak_receive_error, td_none, 1, @tr);
        END;
    (*ENDIF*) 
    IF  a_in_session
    THEN
        BEGIN
        ak93implicit_release (acv);
        IF  (a_return_segm^.sp1r_returncode = cak_e_released) OR
            (a_return_segm^.sp1r_returncode =
            a07_return_code (e_user_not_connected,
            a_sqlmode))
            (* PTS 1109783 E.Z. *)
        THEN
            a_return_segm^.sp1r_returncode  := 0;
        (*ENDIF*) 
        a_in_session := false;
        IF  sql_comm_err = sp1ce_timeout
        THEN
            BEGIN
            a_return_segm^.sp1r_returncode := 0;
            a07_b_put_error (acv, e_command_timeout, 1);
            a93_sending (acv, start_time_sec, start_time_msec, sql_comm_err);
            END
        (*ENDIF*) 
        END;
    (*ENDIF*) 
    IF  a94mode <> umUser_egg00
    THEN
        a_restarted := false;
    (*ENDIF*) 
    END;
(*ENDWITH*) 
END;
 
(*------------------------------*) 
 
PROCEDURE
      a93swap_packet_header (VAR packet_header : tsp1_packet_header;
            kernel_is_dest : boolean;
            kernel_swap    : tsp_swap_kind;
            host_swap      : tsp_swap_kind);
 
BEGIN
IF  kernel_swap <> host_swap
THEN
    WITH packet_header DO
        BEGIN
        IF  kernel_is_dest
        THEN
            BEGIN
            sp1h_varpart_size := s20or4sw (sp1h_varpart_size, 1,
                  host_swap, kernel_swap);
            sp1h_varpart_len  := s20or4sw (sp1h_varpart_len, 1,
                  host_swap, kernel_swap)
            END
        ELSE
            BEGIN
            sp1h_varpart_size := s20or4sw (sp1h_varpart_size, 1,
                  kernel_swap, host_swap);
            sp1h_varpart_len  := s20or4sw (sp1h_varpart_len, 1,
                  kernel_swap, host_swap)
            END;
        (*ENDIF*) 
        sp1h_no_of_segm   := a01swap_int2 (sp1h_no_of_segm);
        END
    (*ENDWITH*) 
(*ENDIF*) 
END;
 
(*------------------------------*) 
 
FUNCTION
      ak93pending_putval (VAR acv : tak_all_command_glob) : boolean;
 
VAR
      part_ptr : tsp1_part_ptr;
 
BEGIN
WITH acv, a_return_segm^ DO
    BEGIN
    a92find_return_part (acv, sp1pk_longdata, part_ptr);
    ak93pending_putval :=
          (part_ptr <> NIL) AND
          (sp1r_function_code in [csp1_update_fc, csp1_insert_fc,
          csp1_mupdate_fc, csp1_minsert_fc, csp1_putval_fc]);
    END;
(*ENDWITH*) 
END;
 
(* PTS 1116801 E.Z. *)
 
.CM *-END-* code ----------------------------------------
.SP 2 
***********************************************************
.PA 
