.CM  SCRIPT , Version - 1.1 , last edited by peter
.ad 8
.bm 8
.fm 4
.tm 12
.hm 6
.hs 3
.tt 1 $SQL$Project Distributed Database System$VPC14$
.tt 2 $$$
.TT 3 $$Analyze_SQLDB_Commands$2000-11-17$
***********************************************************
.nf
 
 .nf


    ========== licence begin  GPL
    Copyright (c) 2000-2004 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

 
.fo
.nf
.sp
MODULE  : Analyse_SQLDB_Kommandos  with new structures
=========
.sp
Purpose : Analysed all SQLDB_Kommandos independent from languages
.CM *-END-* purpose -------------------------------------
.sp
.cp 3
Define  :
 
        PROCEDURE
              p14include   (
                    PROCEDURE next_symbol (VAR p1: tpc_globals;
                    VAR p2: tpc_partbuffer; p3: integer);
                    VAR apc : tpc_globals;
                    VAR keyind: integer;
                    VAR dclgen : boolean);
 
        PROCEDURE
              p14begin (
                    PROCEDURE next_symbol (VAR p1: tpc_globals;
                    VAR p2: tpc_partbuffer; p3: integer);
                    VAR apc : tpc_globals);
 
        PROCEDURE
              p14end (
                    PROCEDURE next_symbol (VAR p1: tpc_globals;
                    VAR p2: tpc_partbuffer; p3: integer);
                    VAR apc : tpc_globals);
 
        PROCEDURE
              p14prepare  (
                    PROCEDURE next_symbol (VAR p1: tpc_globals;
                    VAR p2: tpc_partbuffer; p3: integer);
                    VAR apc : tpc_globals);
 
        PROCEDURE
              p14command  (
                    PROCEDURE next_symbol (VAR p1: tpc_globals;
                    VAR p2: tpc_partbuffer; p3: integer);
                    VAR apc : tpc_globals);
 
        PROCEDURE
              p14cancel  (
                    PROCEDURE next_symbol (VAR p1: tpc_globals;
                    VAR p2: tpc_partbuffer; p3: integer);
                    VAR apc : tpc_globals);
 
PROCEDURE
      p14abortsession (
            PROCEDURE next_symbol (VAR p1: tpc_globals;
            VAR p2: tpc_partbuffer; p3: integer);
            VAR apc : tpc_globals);
 
        PROCEDURE
              p14version  (
                    PROCEDURE next_symbol (VAR p1: tpc_globals;
                    VAR p2: tpc_partbuffer; p3: integer);
                    VAR apc : tpc_globals);
 
        PROCEDURE
              p14execute  (
                    PROCEDURE next_symbol (VAR p1: tpc_globals;
                    VAR p2: tpc_partbuffer; p3: integer);
                    VAR apc : tpc_globals;
                    VAR statemno : integer;
                    VAR immediate: integer);
 
        PROCEDURE
              p14declare  (
                    PROCEDURE next_symbol (VAR p1: tpc_globals;
                    VAR p2: tpc_partbuffer; p3: integer);
                    VAR apc : tpc_globals;
                    VAR keyindex : integer;
                    VAR statemno : integer);
 
);
 
        PROCEDURE
              p14describe (
                    PROCEDURE next_symbol (VAR p1: tpc_globals;
                    VAR p2: tpc_partbuffer; p3: integer);
                    VAR apc : tpc_globals);
 
        PROCEDURE
              p14fetch  (
                    PROCEDURE next_symbol (VAR p1: tpc_globals;
                    VAR p2: tpc_partbuffer; p3: integer);
                    VAR apc : tpc_globals;
                    VAR keyind : integer;
                    VAR pos : tsp00_Int4;
                    VAR cursorparampos : tsp00_Int4);
 
        PROCEDURE
              p14close  (
                    PROCEDURE next_symbol (VAR p1: tpc_globals;
                    VAR p2: tpc_partbuffer; p3: integer);
                    VAR apc : tpc_globals);
 
        PROCEDURE
              p14forloop  (
                    PROCEDURE next_symbol (VAR p1: tpc_globals;
                    VAR p2: tpc_partbuffer; p3: integer);
                    VAR apc : tpc_globals);
 
        PROCEDURE
              p14open  (
                    PROCEDURE next_symbol (VAR p1: tpc_globals;
                    VAR p2: tpc_partbuffer; p3: integer);
                    VAR apc : tpc_globals;
                    VAR openno : integer);
 
        PROCEDURE
              p14whenever  (
                    PROCEDURE next_symbol (VAR p1: tpc_globals;
                    VAR p2: tpc_partbuffer; p3: integer);
                    VAR apc : tpc_globals);
 
        PROCEDURE
              p14option (
                    PROCEDURE next_symbol (VAR p1: tpc_globals;
                    VAR p2: tpc_partbuffer; p3: integer);
                    VAR apc : tpc_globals;
                    VAR statemno : integer);
 
        PROCEDURE
              p14nolog (
                    PROCEDURE next_symbol (VAR p1: tpc_globals;
                    VAR p2: tpc_partbuffer; p3: integer);
                    VAR apc : tpc_globals);
 
        PROCEDURE
              p14gdbsname (
                    PROCEDURE next_symbol (VAR p1: tpc_globals;
                    VAR p2: tpc_partbuffer; p3: integer);
                    VAR apc : tpc_globals;
                    VAR ind : integer;
                    VAR dbpos : integer;
                    VAR dblen : integer;
                    VAR dbnodepos : integer;
                    VAR dbnodelen : integer);
 
        PROCEDURE
              p14gtrace (
                    PROCEDURE next_symbol (VAR p1: tpc_globals;
                    VAR p2: tpc_partbuffer; p3: integer);
                    VAR apc : tpc_globals;
                    keyind: integer);
 
        PROCEDURE
              p14traceline (
                    PROCEDURE next_symbol (VAR p1: tpc_globals;
                    VAR p2: tpc_partbuffer; p3: integer);
            VAR apc : tpc_globals;
            VAR statemno : integer);
 
        PROCEDURE
              p14oracle (
                    PROCEDURE next_symbol (VAR p1: tpc_globals;
                    VAR p2: tpc_partbuffer; p3: integer);
                    VAR apc : tpc_globals);
 
        FUNCTION
              p14ifstbind   (VAR apc : tpc_globals;
                    kano : integer) : boolean;
 
        PROCEDURE
              p14kaentryinit (VAR apc : tpc_globals);
 
.CM *-END-* define --------------------------------------
.sp;.cp 3
Use     :
 
        FROM
              Analyse_ORACLE_Kommandos   : VPC14B;
 
        PROCEDURE
              p14batdatabase (VAR apc : tpc_globals;
                    VAR dbname : tsp00_KnlIdentifier);
 
        PROCEDURE
              p14bcudeclare ( VAR apc : tpc_globals;
                    VAR cursorn : tsp00_KnlIdentifier);
 
        PROCEDURE
              p14bcusearch (VAR apc : tpc_globals;
                    VAR buf : tpc_partbuffer;
                    blen : integer);
 
      ------------------------------ 
 
        FROM
              Analyse_SQLDB_Kommandos  : VPC14E;
 
        FUNCTION
              p14symb (
                    PROCEDURE next_symbol (VAR p1: tpc_globals;
                    VAR p2: tpc_partbuffer; p3: integer);
                    VAR apc : tpc_globals) : tpr_symbol;
 
        PROCEDURE
              p14binitsqlvan (VAR apc : tpc_globals);
 
        PROCEDURE
              p14ansqlstatement (
                    PROCEDURE next_symbol (VAR p1: tpc_globals;
                    VAR p2: tpc_partbuffer; p3: integer);
                    VAR apc : tpc_globals);
 
        PROCEDURE
              p14an1sqlstatement (
                    PROCEDURE next_symbol (VAR p1: tpc_globals;
                    VAR p2: tpc_partbuffer; p3: integer);
                    VAR apc : tpc_globals);
 
        PROCEDURE
              p14anaparameter (
                    PROCEDURE next_symbol (VAR p1: tpc_globals;
                    VAR p2: tpc_partbuffer; p3: integer);
                    VAR apc : tpc_globals;
                    VAR pos : tsp00_Int4;
                    VAR nextsa : boolean);
 
        PROCEDURE
              p14btypentget (
                    PROCEDURE next_symbol (VAR p1: tpc_globals;
                    VAR p2: tpc_partbuffer; p3: integer);
                    VAR apc : tpc_globals;
                    VAR typentix : tsp00_Int2;
                    VAR vatyp    : tsp00_Int2;
                    VAR lastvatyp: tsp00_Int2;
                    resolve      : tsp00_Int2);
 
        PROCEDURE
              p14putsqlstarea   (VAR apc : tpc_globals);
 
      ------------------------------ 
 
        FROM
              Check_Usage   : VPC16;
 
        PROCEDURE
              p16tabledclgen   (VAR apc : tpc_globals;
                    VAR dclgen : boolean);
 
      ------------------------------ 
 
        FROM
              Search-Const-Type-Var-Namen   : VPC19C;
 
        PROCEDURE
              p19sqlkaallocate (VAR index : tsp00_Int2);
 
        PROCEDURE
              p19sqlprallocate (VAR index : tsp00_Int2);
 
        PROCEDURE
              p19sqlfaallocate (VAR index : tsp00_Int2);
 
        PROCEDURE
              p19sqlstallocate (VAR index : tsp00_Int2);
 
        PROCEDURE
              p19sqlfnallocate (VAR index : tsp00_Int2);
 
        PROCEDURE
              p19setprsqlindex (VAR index : tsp00_Int2);
 
        PROCEDURE
              p19setsqlstindex (VAR index : tsp00_Int2);
 
        PROCEDURE
              p19cparentry  (VAR apc : tpc_globals;
                    kindentry: tsp00_Int2;
                    parm2 : tsp00_Int4;
                    parm3 : tsp00_Int4;
                    parm4 : tsp00_Int4);
 
      ------------------------------ 
 
        FROM
              Search-Const-Type-Var-Namen   : VPC19;
 
        PROCEDURE
              p19getname (VAR apc : tpc_globals;
                    VAR  nam  : tsp00_KnlIdentifier;
                    VAR  len  : integer);
 
        PROCEDURE
              p19sprepareprname (VAR apc : tpc_globals;
                    VAR  nam  : tsp00_KnlIdentifier;
                    VAR  ind  : integer);
 
        PROCEDURE
              p19sstatementprname (VAR apc : tpc_globals;
                    VAR  nam  : tsp00_KnlIdentifier;
                    VAR  ind  : integer);
 
        PROCEDURE
              p19scursorprname (VAR apc : tpc_globals;
                    VAR  nam  : tsp00_KnlIdentifier;
                    VAR  ind  : integer);
 
        PROCEDURE
              p19snextsubchar (VAR apc : tpc_globals;
                    anf : integer;
                    VAR pos : integer;
                    VAR subchr : char);
 
        PROCEDURE
              p19gmacronumber  (VAR apc : tpc_globals;
                    mpos  : integer;
                    VAR mind : integer;
                    VAR nextpos : integer);
 
      ------------------------------ 
 
        FROM
              Precompiler_Syntax_Erkennung  : VPC10;
 
        PROCEDURE
              p10getkeyword (VAR apc : tpc_globals;
                    VAR buf : tpc_partbuffer;
                    VAR index : integer);
 
        PROCEDURE
              p10stringliteralget (VAR apc : tpc_globals;
                    VAR buf : tpc_partbuffer);
 
        PROCEDURE
              p10int2unsignedget (VAR apc : tpc_globals;
                    VAR buf : tpc_partbuffer;
                    VAR int : tsp00_Int2);
 
        PROCEDURE
              p10rmspace (VAR buf : tpc_partbuffer;
                    cpr_quotsym, escsym : char;
                    ind, inplen : tsp00_Int4;
                    VAR  maxbuf, outlen : tsp00_Int4);
 
      ------------------------------ 
 
        FROM
              Kommunikation mit Ein-Ausgabeger?ate : VPC11;
 
        PROCEDURE
              p11vfopen  (VAR apc : tpc_globals;
                    ind  :  integer);
 
        PROCEDURE
              p11precomerror (VAR apc : tpc_globals;
                    error : tpc_pre_errors);
 
        PROCEDURE
              p11wrerrorlisting  (VAR apc : tpc_globals;
                    error : tpc_pre_errors);
 
        PROCEDURE
              p11nerrorlisting  (VAR apc : tpc_globals;
                    VAR nam : tsp00_Lname;
                    naml  : tsp00_Int2;
                    index : tsp00_Int2);
 
      ------------------------------ 
 
        FROM
              SQL_runtime_routinen_init   : VPR01e;

        PROCEDURE
              pr01eInitFileName(VAR filename : tsp00_VFilename);

        FROM
              C-Type-Checker-Module : VPR102;
 
        PROCEDURE
              p14putval (
                    PROCEDURE next_symbol (VAR p1: tpc_globals;
                    VAR p2: tpc_partbuffer; p3: integer);
                    VAR apc : tpc_globals;
                    VAR keyind : integer;
                    VAR pos : tsp00_Int4);
 
        PROCEDURE
              p14getval (
                    PROCEDURE next_symbol (VAR p1: tpc_globals;
                    VAR p2: tpc_partbuffer; p3: integer);
                    VAR apc : tpc_globals;
                    VAR keyind : integer;
                    VAR pos : tsp00_Int4);
 
&       ifdef TRACE
 
        PROCEDURE
              m90c30 (
                    layer : tsp00_ToolLayer;
                    str30 : tsp00_C30);
 
        PROCEDURE
              m90int (layer : tsp00_ToolLayer;
                    nam : tsp00_Sname;
                    int : integer);
 
        PROCEDURE
              m90int4 (layer : tsp00_ToolLayer;
                    nam : tsp00_Sname;
                    int  : tsp00_Int4);
 
        PROCEDURE
              m90int2 (layer : tsp00_ToolLayer;
                    nam : tsp00_Sname;
                    int  : tsp00_Int2);
 
        PROCEDURE
              m90name (layer : tsp00_ToolLayer;
                    nam : tsp00_Name);
 
        PROCEDURE
              m90lname (layer : tsp00_ToolLayer;
                    nam : tsp00_Lname);
 
        PROCEDURE
              m90identifier  (
                    layer : tsp00_ToolLayer;
                    nam   : tsp00_KnlIdentifier);
 
        PROCEDURE
              m90buf (layer : tsp00_ToolLayer;
                    VAR buf : char;
                    pos_anf : integer;
                    pos_end : integer);
&       endif
 
      ------------------------------ 
 
        FROM
              Runtime-Stringroutinen   : VPR05;
 
        PROCEDURE
              p05up1casebuf (VAR buf : tsp00_C132;
                    lwb : tsp00_Int4;
                    upb : tsp00_Int4);
 
        PROCEDURE
              p05up2casebuf (VAR buf : tsp00_KnlIdentifier;
                    lwb : tsp00_Int4;
                    upb : tsp00_Int4);
 
        PROCEDURE
              p05searchword  (VAR buf : tpc_partbuffer;
                    lwb : integer;
                    upb : integer;
                    word : tsp00_Sname;
                    lw   : integer;
                    VAR pos : integer);
 
        PROCEDURE
              p05inttochr12 (int : integer;
                    VAR chr12 : tsp00_C12);
 
      ------------------------------ 
 
        FROM
              Kernel_move_and_fill   : VGG101;
 
        PROCEDURE
              SAPDB_PascalForcedFill (
                    size        : tsp00_Int4;
                    m           : tsp00_MoveObjPtr;
                    pos         : tsp00_Int4;
                    len         : tsp00_Int4;
                    fillchar    : char);
 
        PROCEDURE
              SAPDB_PascalForcedMove (
                    source_upb  : tsp00_Int4;
                    destin_upb  : tsp00_Int4;
                    source      : tsp00_MoveObjPtr;
                    source_pos  : tsp00_Int4;
                    destin      : tsp00_MoveObjPtr;
                    destin_pos  : tsp00_Int4;
                    length      : tsp00_Int4);
 
        PROCEDURE
              s10mv (
                    source_upb  : tsp00_Int4;       
                    destin_upb  : tsp00_Int4;
                    source      : tsp00_MoveObjPtr;    
                    source_pos  : tsp00_Int4;
                    destin      : tsp00_MoveObjPtr;    
                    destin_pos  : tsp00_Int4;
                    length      : tsp00_Int4);
 
      ------------------------------ 
 
        FROM
              RTE-Extension-30    : VSP30;
 
        FUNCTION
              s30eq (VAR a : tsp00_Sname;
                    VAR b : tpc_partbuffer;
                    bi,cnt : tsp00_Int4) : boolean;
 
        FUNCTION
              s30len (VAR str : tsp00_VFilename;
                    val : char; cnt : tsp00_Int4) : tsp00_Int4;
 
        FUNCTION
              s30len1 (VAR str : tsp00_KnlIdentifier;
                    val : char; cnt : tsp00_Int4) : tsp00_Int4;
 
        FUNCTION
              s30lnr (VAR str : tsp00_C132;
                    val : char;
                    start : tsp00_Int4;
                    cnt : tsp00_Int4) : tsp00_Int4;
 
.CM *-END-* use -----------------------------------------
.sp;.cp 3
Synonym :
 
        PROCEDURE
              m90buf;
 
              tsp00_Buf   char
 
        PROCEDURE
              p10int2unsignedget;
 
              tsp00_Buf   tpc_partbuffer
 
        PROCEDURE
              p05up1casebuf;
 
              tsp00_MoveObj  tsp00_C132
 
        PROCEDURE
              p05up2casebuf;
 
              tsp00_MoveObj  tsp00_KnlIdentifier
 
        PROCEDURE
              p05searchword;
 
              tsp00_MoveObj  tpc_partbuffer
 
        PROCEDURE
              s30eq;
 
              tsp00_MoveObj  tpc_partbuffer
              tsp00_MoveObj  tsp00_Sname
 
        PROCEDURE
              s30lnr;
 
              tsp00_MoveObj  tsp00_C132
 
        PROCEDURE
              s30len;
 
              tsp00_MoveObj  tsp00_VFilename
 
        PROCEDURE
              s30len1;
 
              tsp00_MoveObj  tsp00_KnlIdentifier
 
.CM *-END-* synonym -------------------------------------
.sp;.cp 3
Author  :
.sp
.cp 3
Created : 1986-07-07
.sp
.cp 3
Version : 2002-06-14
.sp
.cp 3
Release :      Date : 2000-11-17
.sp
***********************************************************
.sp
.cp 10
.fo
.oc _/1
Specification:
.sp 2
PROCEDURE  P14B_INIT_SQLVAN:
.sp 2
The vartable, typetable, cmdtable sqlva1, sqlva2 and sqlva3 will
be written in a slow version into the protfile.
.sp 4
.cp 6
PROCEDURE  P14_INCLUDE:
.sp 2
.fo
If an include identifier is found,
it switches over to the next output file
in the case of 'sqlconst' and 'sqlproc'.
.sp
If an include file is found, switchover
is to the include file acting as an input file.
If an include file has already been opened, the
file is not read.
.sp
The syntax after <filename> will be analised (p14_dclgen)
and stored into pcdclgen.
.br
If the include file does not exist and the statement has to
expand the table structure the sqlda-area  will be initialiesed
with the tableinformation of "select * from tablename"
(p16_dclgen).
The command syntax will be stored into the partbuf and
if no error was found the boolen value dclgen is true (p14_put_dclgen).
.sp 4
PROCEDURE  P14_BEGIN:
.sp 2
Determines which section is now beginning and
sets the corresponding identifier after
 pcan.ansection for the subsequent analyses.
.sp 4
PROCEDURE  P14_END:
.sp 2
Determines which section is now being completed and
converts the corresponding identifier pcan.ansection.
.sp 4
PROCEDURE  P14_COMMAND :
.sp 2
Analyzes a 'command' statement with the following
 syntax :  EXEC COMMAND  / <mode> /  <command> RESULT :resultparameter ;
  or    :  EXEC COMMAND    ASYNC     <command>;
 with <mode>    :: SYNC | NEWSYNC    default :: SYNC
 with <command> :: <parameter> | <stringconst>
In the sqlka-area is stored the command with information in the
sqlpr-area.
An entry is made in the SQLPR area,
where prname = blankname, prarea = specification of the area
in which the SQLEXEC command is stored (cpr_in_sqlva or cpr_in_sqlst).
Kast_count and kastindex  comtains the information of prarea
for the command.
The result parameter index of sqlva1 entry is stored in prkaindex;
In prstate is stored which mode is used (cpr_state_sync_exec,
 cpr_state_newsync_exec, cpr_state_async_exec).
.sp 4
PROCEDURE  P14_PREPARE:
.sp 2
Analyzes a 'prepare' statement.
An entry is made in the SQLKA area and
an entry is made in the SQLPR area,
where prname = statement name, prarea = specification of the area
in which the SQL command is stored (cpr_in_sqlva or cpr_in_sqlst).
If the statement is specified as a string constant, it is determined
whether only cpr_preparechr '??'  are specified in the string.
.sp
If the statement used a descriptor, in sqlxa.xakano the statement number
is stored, in xadescpos the position of the descriptor name and
in xadesclen the length of the descriptorname is stored.
This information will be used to expand the descriptor address.
.sp
In prkaindex is stored the index to sqlka_area-entry.
.sp 4
PROCEDURE  P14_EXECUTE:
.sp 2
Analyzes an 'execute' statement.
If 'immediate' is not specified, checks whether
a 'prepare' already exists for this statement otherwise error.
If so, and no SQLka_entry exeist,
an SQLka entry is made with the associated
entries in the SQLSA and SQLPA areas.
The index to the SQLPR entry is sent to kaprindex.
.sp
If an SQLka_entry exist and no 'into or using' is specified
all ok.
.sp
If 'into or using' is specified a new SQLka-entry will copy from
the sqlpr_entry index prka-index, and in kadiindex will stored
the index fom which is copied the kaentry. Also in the sqlpr-area
the index of this new kaentry will stored into prkaindex.
So you can get over the kadiindex all kaentries which belong
to the same prepare-statement.
.sp 2
If 'immediate' is specified,
a new entry is made in the SQLPR area,
where prname = blank name, prarea = specification of the area
in which the SQL command is stored (cpr_in_sqlva or cpr_in_sqlst).
Reference to the SQLPR entry is made in the SQLKA entry
(kaprindex).
Parameters must not be specified.
If the statement is specified as a string constant, it is
determined whether macros are specified and kamacro is set.
.sp
The index to the SQLKA entry is sent back in
statemno (kano).
.nf
.sp
Immediate includes a specification of what kind of
command was found.
   immediate :  cpc_imm_no            without  'immediate'
                cpc_imm_variable      immediate  <variable>
                cpc_imm_string        immediate  <string const>
.sp
If the statement used a descriptor, in sqlxa.xakano the statement number
is stored, in xadescpos the position of the descriptor name and
in xadesclen the length of the descriptorname is stored.
This information will be used to expand the descriptor address.
.sp 4
.fo
.cp 6
PROCEDURE  P14_DECLARE:
.sp 2
Analyzes a 'declare' statement.
An entry is made in the SQLPR area.
If the statement is specified as a string constant, it is
determined whether macros or parameters are specified in the string.
If so, an SQLKA entry is initiated and prkaindex
receives the index to the entry.
With the subsequent 'open', then, there must be no further
'using' specification and the 'open' gets this kano.
The string is stored in the SQLST area.
.br
If not, a 'prepare' statement has already been issued beforehand.
A new entry is made in the SQLPR area where prname
equals cursor name.
.sp
If 'for <statementname>' is specified a new SQLka-entry will copy from
the sqlpr_entry index prka-index, and in kadiindex will stored
the index fom which is copied the kaentry. Also in the sqlpr-area
the index of this new kaentry will stored into prkaindex.
So you can get over the kadiindex all kaentries which belong
to the same prepare-statement.
.sp 4
PROCEDURE  P14_OPEN:
.sp 2
Searches for the cursor name of the 'declare' definition
backwards in the SQLPR area, i.e. double names may
be defined if 'declare' and 'open' follow on from each
other statically.
If no SQLKA entry has yet been made with the 'declare', this
is initiated now. If an entry has already been made, no further
'using' specification may be issued.
.sp
The kaindex of the command is sent back in openno.
If openno = 0, a normal SQL statement has been
found and analyzed.
.sp
If the statement used a descriptor, in sqlxa.xakano the statement number
is stored, in xadescpos the position of the descriptor name and
in xadesclen the length of the descriptorname is stored.
This information will be used to expand the descriptor address.
.sp 4
PROCEDURE  P14_DESCRIBE:
.sp 2
Checks whether a prepare already exists for this command.
If not, error, if yes, if no SQLKA entry exists yet a new
one is created, otherwise kapacount is set to -3,.
and kapaindex to 0.
.sp
If the statement used a descriptor, in sqlxa.xakano the statement number
is stored, in xadescpos the position of the descriptor name and
in xadesclen the length of the descriptorname is stored.
This information will be used to expand the descriptor address.
.sp
If pr-entry exist a new SQLka-entry will copy from
the sqlpr_entry index prka-index, and in kadiindex will stored
the index fom which is copied the kaentry. Also in the sqlpr-area
the index of this new kaentry will stored into prkaindex.
So you can get over the kadiindex all kaentries which belong
to the same prepare-statement.
.sp 4
PROCEDURE  P14_WHENEVER:
.sp 2
Determines which whenever statement has been specified and
inserts the corresponding specifications in the global
record pc_whenever. A string of maximum length = 50
can be stored for each whenever statement.
String length = 0 means that
'continue' has been specified.
In the case of a 'call' sqlaction, pc_wh.whstr contains the specified
call without 'call' and line end tpr_symbol, and in the case of 'goto',
'goto' with in whstr without line end tpr_symbol.
With every 'set whenever', pcwheset is set to cpr_is_true.
.sp 4
.cp 6
PROCEDURE  P14_GET_ACTION:
.sp 2
Analyzes the whenever specification and writes the specifications
into the pcwhe area from the index ind.
.nf
  ind = 1 : warnings
  ind = 2 : error
  ind = 3 : exeption
  ind = 4 : not found
.fo
.sp 4
.cp 6
PROCEDURE  P14_G_MACRONO:
.sp 2
Recognizes the following syntax in the argline:
  '&nn = macro string'
.br
The macro number is sent back as a parameter.
The macro string and length of the strings is stored in the
SQLMA area.
.sp 4
PROCEDURE  P14_G-TRACEFILE:
.sp 2
Get_trace_file_name
recognizes a string and stores it in
 sqlca.sqlgap^.oamodtracefn.
.sp 4
PROCEDURE  P14_G_DBSNAME:
.sp 2
Get_dbsname
Get  'serverdb'  and  'servernode'
Serverdb recognizes a string and stores it in
 sqlca.sqlgap^.gaentry [session]^ .ga_serverdb  or
as hostvariable the index is stored in gavaindex.
The paramter dbpos is the postion in the varpart of the serverdb string.
The paramter dblen is the length of the serverdb string.
Servernode  recognizes a string and stores it in
 sqlca.sqlgap^.gaentry [session]^ .ga_servernode or .
as hostvariable the index is stored in ganodeindex.
The paramter dbnodepos is the postion in the varpart of the servernode string.
The paramter dbnodelen is the length of the servernode string.
.sp
DB names can be specified via 'xuser' for all session
or via option for
the first session.
A serverdb and servernode  can be defined
before each 'connect'.
.sp 4
PROCEDURE  P14_DCLGEN:
.sp 2
The syntax after <filen name> will be stored into pcdclgen.
.sp
.nf
   Syntax of the command:
 
    INCLUDE <file name> /TABLE <table name>  <asclause> <indclause> /
 
    <asclause> ::=  empty
                     AS VAR    / <attrib> /
                     AS TYPE   / <attrib> /
                     AS STRUCT / <attrib> /
                     AS RECORD / <attrib> /
    default f?ur Fortran    :=   AS RECORD <tablename>
    default sonst           :=   AS VAR <tablename>
 
    <indclause> ::=  empty
                      IND   / <iattrib> /
    default if not empty  <iattrib>    :=   I<tablename>
.fo
.sp 4
PROCEDURE  P14_DCLGEN:
.sp 2
The whole syntax of the include table command will be stored into
the pccmdpart.partbuf with part1len.
.sp 4
PROCEDURE  P14_HOSTV_GET:
.sp 2
Get the index into pa-area from the command string wich is in the varpart
.sp 4
PROCEDURE  P14_PRIND_GET:
.sp 2
Searches in the prarea if the index from the hostvariable is always defined.
if not it calls p14_add_prind to create a new prentry. the prentry poits to the
hostvariable who describe the statementname.
.sp 4
 
PROCEDURE p14getname:
.sp 2
Fuer 'declare <cursorname> ' wird der Curorname geholt.
Er kann als Name oder Macro angegeben werden.
Parameter macro gibt an, welche Definition gefunden wurde.
macro = cpr_is_true :: cursor ist als Macro angegeben.
Die Angabe wird in kamacro gesetzt.
.sp 4
 
.CM *-END-* specification -------------------------------
.sp 2
***********************************************************
.sp
.cp 10
.fo
.oc _/1
Description:
 
.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    :
 
 
&define PREPSTMT prepstmt
(*------------------------------*) 
 
PROCEDURE
      p14end (
            PROCEDURE next_symbol (VAR p1: tpc_globals;
            VAR p2: tpc_partbuffer; p3: integer);
            VAR apc : tpc_globals);
 
VAR
      keyind : integer;
&     ifdef TRACE
      i      : integer;
&     endif
 
BEGIN
WITH apc, pcscan, pccmdpart DO
    BEGIN
    IF   pcerror = cpc_pre_ok
    THEN
        BEGIN
        next_symbol (apc, partbufp^, part1len);
        p10getkeyword (apc, partbufp^, keyind);
        IF   keyind = cpc_i_declare
        THEN
            BEGIN
            next_symbol (apc, partbufp^, part1len);
            p10getkeyword (apc, partbufp^, keyind);
            CASE keyind OF
                cpc_i_const :
                    BEGIN
                    IF   pcan.ansection <> cpc_se_const
                    THEN
                        p11wrerrorlisting (apc, cpc_invalid_section_begin_or_end);
                    (*ENDIF*) 
                    pcan.ansection := cpc_se_off;
                    next_symbol (apc, partbufp^, part1len);
                    p10getkeyword (apc, partbufp^, keyind);
                    IF   keyind <> cpc_i_section
                    THEN
                        p11wrerrorlisting (apc,cpc_unknown_sql_command);
&                   ifdef TRACE
                    (*ENDIF*) 
                    FOR i := 1 TO pccse.ccnt DO
                        WITH pccse, csec^ [i]  DO
                            BEGIN
                            m90lname (pc, cname);
                            m90int4 (pc, 'cwert       ', cwert);
                            END;
                        (*ENDWITH*) 
                    (*ENDFOR*) 
&                   endif
                    END;
                cpc_i_type  :
                    BEGIN
                    IF   pcan.ansection <> cpc_se_type
                    THEN
                        p11wrerrorlisting (apc, cpc_invalid_section_begin_or_end);
                    (*ENDIF*) 
                    pcan.ansection := cpc_se_off;
                    next_symbol (apc, partbufp^, part1len);
                    p10getkeyword (apc, partbufp^, keyind);
                    IF   keyind <> cpc_i_section
                    THEN
                        p11wrerrorlisting (apc,cpc_unknown_sql_command);
                    (*ENDIF*) 
                    END;
                cpc_i_record   :
                    BEGIN
                    IF   pcan.ansection <> cpc_se_record
                    THEN
                        p11wrerrorlisting (apc, cpc_invalid_section_begin_or_end);
                    (*ENDIF*) 
                    pcan.ansection := cpc_se_declare;
                    END;
                cpc_i_section  :
                    BEGIN
                    IF   pcan.ansection <> cpc_se_var
                    THEN
                        p11wrerrorlisting (apc, cpc_invalid_section_begin_or_end);
                    (*ENDIF*) 
                    pcan.ansection := cpc_se_off;
                    END;
                OTHERWISE:
                    p11wrerrorlisting (apc, cpc_unknown_sql_command);
                END;
            (*ENDCASE*) 
            IF   pcerror = cpc_pre_ok
            THEN
                BEGIN
                next_symbol (apc, partbufp^, part1len);
                IF   (symb <> cpr_s_eof) AND (symb <> cpr_s_bufeof)
                THEN
                    p11wrerrorlisting (apc, cpc_invalid_sql_command);
                (*ENDIF*) 
                END;
            (*ENDIF*) 
            END
        ELSE
            p11wrerrorlisting (apc, cpc_unknown_sql_command);
        (*ENDIF*) 
        END;
    (*ENDIF*) 
    WHILE  (symb <> cpr_s_eof) AND (symb <> cpr_s_bufeof) DO
        next_symbol (apc, partbufp^, part1len);
    (*ENDWHILE*) 
    END;
(*ENDWITH*) 
&ifdef TRACE
m90name(xx, 'END p14end        ');
&endif
END;
 
(*------------------------------*) 
 
PROCEDURE
      p14sqlfn_areaput (VAR apc : tpc_globals);
 
VAR
      i   : integer;
      len : integer;
      pos : integer;
 
BEGIN
WITH apc, sqlxa, pcvf.vffn [cpc_includefile ] DO
    BEGIN
    p19sqlfnallocate (pcfn);
&   ifdef TRACE
    m90int2 (pc, 'pcfn        ', pcfn );
&   endif
    WITH sqlfnp^ [pcfn] DO
        BEGIN
        fnkanomin := pcka + 1;
        fnkanomax := csp_maxint2;
        fnfilen   := bsp_knl_identifier;
        fnincllno := pclno.lnosrc;
        len     := s30len (vffilen, bsp_c1, VFILENAME_MXSP00);
        pos     := 1;
&       ifdef TRACE
        m90int2 (pc, 'fnkanomin   ', fnkanomin);
        m90int2 (pc, 'fnkanomax   ', fnkanomax);
        m90int2 (pc, 'fnincllno   ', fnincllno);
        m90int2 (pc, 'len         ', len      );
        m90int2 (pc, 'pos         ', pos      );
&       endif
        FOR i := 1 TO len DO
            IF  vffilen [i] = '/'
            THEN
                pos := i + 1;
            (*ENDIF*) 
        (*ENDFOR*) 
        IF  len > mxsp_name
        THEN
            len := mxsp_name;
&       ifdef TRACE
        (*ENDIF*) 
        m90int2 (pc, 'len  n      ', len      );
        m90int2 (pc, 'pos  n      ', pos      );
&       endif
        s10mv (VFILENAME_MXSP00, sizeof(fnfilen), @vffilen, pos,
              @fnfilen, 1, len);
        END;
    (*ENDWITH*) 
    END;
(*ENDWITH*) 
END;
 
(*------------------------------*) 
 
PROCEDURE
      p14oracle  (
            PROCEDURE next_symbol (VAR p1: tpc_globals;
            VAR p2: tpc_partbuffer; p3: integer);
            VAR apc : tpc_globals);
 
VAR
      retpos    : tsp00_Int2;
 
BEGIN
WITH apc, pcscan, sqlca, sqlrap^, pccmdpart, sqlxa   DO
    BEGIN
    retpos := sypos;
    IF  ralang in [cpr_la_c, cpr_la_cobol]
    THEN
        (* if f?ur umstellung next_symbol *)
        WHILE  (symb <>cpr_s_eof) AND (symb <> cpr_s_bufeof) DO
            next_symbol (apc, partbufp^, part1len);
        (*ENDWHILE*) 
    (*ENDIF*) 
    IF  ralang = cpr_la_cobol
    THEN
        BEGIN
        part1len := part1len + 1;
        partbufp^ [part1len] := cpr_nullchar ;
        END;
    (*ENDIF*) 
    syposacc := retpos;
    symb     := cpr_s_unknown;
    p11wrerrorlisting (apc, cpc_del_oracle_statement);
    WHILE  (symb <> cpr_s_eof) AND (symb <> cpr_s_bufeof) DO
        next_symbol (apc, partbufp^, part1len);
    (*ENDWHILE*) 
    END;
(*ENDWITH*) 
&ifdef TRACE
m90name(xx, 'END p14oracle     ');
&endif
END;
 
(*------------------------------*) 
 
PROCEDURE
      p14_put_dclgen   (VAR apc : tpc_globals);
 
VAR
      sn  : tsp00_Sname;
      len  : integer;
 
BEGIN
WITH apc, pccmdpart, pcdclgen DO
    BEGIN
    part1len := 0;
    IF   pcerror = cpc_pre_ok
    THEN
        BEGIN
        SAPDB_PascalForcedFill (partsizlen, @partbufp^, 1, 300, bsp_c1);
        sn := '   INCLUDE  ';
        s10mv (SNAME_MXSP00, partsizlen,
              @sn, 1 , @partbufp^, part1len + 1,
              SNAME_MXSP00);
        part1len := part1len + SNAME_MXSP00 + 1;
        partbufp^ [part1len] := pcopts.opt_quo [1] ;
        len := clause [1].dclfnlen;
        s10mv (VFILENAME_MXSP00, partsizlen,
              @pcvf.vffn [cpc_includefile].vffilen, 1,
              @partbufp^, part1len + 1, len);
        part1len := part1len + len  + 1;
        partbufp^ [part1len] := pcopts.opt_quo [1] ;
        IF  tabclause = cpc_i_table
        THEN
            sn := ' TABLE      '
        ELSE
            sn := ' DBPROC     ';
        (*ENDIF*) 
        s10mv (SNAME_MXSP00, partsizlen,
              @sn, 1 , @partbufp^, part1len + 2, 9);
        part1len := part1len + 10;
        IF  dcluser <> bsp_knl_identifier
        THEN
            BEGIN
            len     := s30len1 (dcluser, bsp_c1, sizeof(dcluser));
            s10mv (sizeof(dcluser), partsizlen,
                  @dcluser, 1 , @partbufp^, part1len + 1,
                  len );
            part1len := part1len + len + 2;
            partbufp^ [part1len] := '.';
            END;
        (*ENDIF*) 
        s10mv (sizeof(dcltab), partsizlen,
              @dcltab, 1 , @partbufp^, part1len + 1,
              dcltabl );
        part1len := part1len + dcltabl + 1;
        IF  dclmodul <> bsp_knl_identifier
        THEN
            BEGIN
            partbufp^ [part1len+1] := '.';
            len     := s30len1 (dclmodul, bsp_c1, sizeof(dclmodul));
            s10mv (sizeof(dclmodul), partsizlen,
                  @dclmodul, 1 , @partbufp^, part1len + 2,
                  len );
            part1len := part1len + len + 2;
            END;
        (*ENDIF*) 
        CASE asclause OF
            cpc_as_record :
                sn := ' AS RECORD  ';
            cpc_as_type :
                sn := ' AS TYPE    ';
            cpc_as_struct :
                sn := ' AS STRUCT  ';
            OTHERWISE:
                sn := ' AS VAR     ';
            END;
        (*ENDCASE*) 
        s10mv (SNAME_MXSP00, partsizlen,
              @sn, 1 , @partbufp^, part1len + 1,
              SNAME_MXSP00);
        part1len := part1len + SNAME_MXSP00 + 1;
        s10mv (sizeof(clause[1].dclattr), partsizlen,
              @clause [1]. dclattr, 1 , @partbufp^, part1len + 1,
              clause [1]. dclattrl);
        part1len := part1len +  clause [1]. dclattrl + 1;
        IF  indclause = cpr_is_true
        THEN
            BEGIN
            sn := 'IND         ';
            s10mv (SNAME_MXSP00, partsizlen,
                  @sn, 1 , @partbufp^, part1len + 1, 5);
            part1len := part1len + 5 + 1;
            s10mv (sizeof(clause[1].dclattr), partsizlen,
                  @clause [2]. dclattr, 1 , @partbufp^, part1len + 1,
                  clause [2]. dclattrl);
            part1len := part1len +  clause [2]. dclattrl + 1;
            END;
        (*ENDIF*) 
        END;
    (*ENDIF*) 
    END;
(*ENDWITH*) 
&ifdef TRACE
m90name(xx, 'END p14_put_dclgen');
&endif
END;
 
(*------------------------------*) 
 
PROCEDURE
      p14open  (
            PROCEDURE next_symbol (VAR p1: tpc_globals;
            VAR p2: tpc_partbuffer; p3: integer);
            VAR apc : tpc_globals;
            VAR openno : integer);
 
VAR
      keyind : integer;
      ind    : integer;
      openind: integer;
      found  : boolean;
      err    : tpc_pre_errors;
      cursorn: tsp00_KnlIdentifier;
      cursorl: integer;
      kaind     : tsp00_Int2;
      macro     : tsp00_Int2;
&     ifdef PREPSTMT
      param     : tsp00_Int2;
      va1ix     : tsp00_Int2;
      ch12      : tsp00_C12;
      no        : integer;
      CursorNameIndex  : tsp00_Int2;
      rscan  : tpr_scannertype;
      ndcuindex  : integer;
&     endif
      lineno    : tsp00_Int2;
      kaentry   : sqlkaentry;
      cudiind   : tsp00_Int2;
      dummy : tsp00_Int2;
 
BEGIN
WITH apc, pcscan, sqlca, sqlrap^, pccmdpart, sqlxa DO
    BEGIN
    xadescpos := 0;
    xadesclen := 0;
    IF   pcerror = cpc_pre_ok
    THEN
        BEGIN
        err := cpc_pre_ok;
        openno := 0;
        next_symbol (apc, partbufp^, part1len);
        p10getkeyword (apc, partbufp^, keyind);
        IF  (keyind = cpc_i_column)
        THEN
            BEGIN
            pcan.ancomtyp := cpr_com_sql
            END
        ELSE
            pcan.ancomtyp := cpr_com_sql_open;
        (*ENDIF*) 
        p14getname (next_symbol, apc, cursorn, cursorl, macro
&             ifdef PREPSTMT
              , param
&             endif
              );
&       ifdef PREPSTMT
        IF  (param = cpr_is_true)
        THEN
            BEGIN
            dummy := 0;
            p14_add_prind(apc, ind, dummy);
            ind := pcpr;
            rscan := pcscan;
            p14_hostv_get (next_symbol, apc, CursorNameIndex, va1ix);
            no := va1ix;
            p05inttochr12 (no, ch12);
            cursorn := bsp_knl_identifier;
            cursorn[1] := ':';
            s10mv (mxsp_c12, sizeof(cursorn), @ch12, 2,
                  @cursorn, 2, 4);
            pcscan := rscan;
            (* PTS 1104482 *)
            ndcuindex := pcsqlva.ndcnt;
            END
        ELSE
            BEGIN
&           endif
&           ifdef PREPSTMT
            dummy := 0;
            p14_add_prind(apc, ind, dummy);
            ind := pcpr;
            CursorNameIndex := 0;
            (* PTS 1104482 *)
            ndcuindex := 0;
&           else
            p14bcusearch (apc, partbufp^,
                  part1len );
            p19scursorprname (apc, cursorn, ind);
&           ifdef TRACE
            m90int2 (pc, 'ind         ', ind      );
&           endif
&           endif
&           ifdef PREPSTMT
            END;
        (*ENDIF*) 
&       endif
        IF   (ind = 0)
        THEN
            BEGIN
            next_symbol (apc, partbufp^, part1len);
            p10getkeyword (apc, partbufp^, keyind);
            IF  (symb = cpr_s_eof) OR (keyind = cpc_i_into) OR
                (keyind = cpc_i_using)
            THEN
                (* open ohne declare cursor *)
                err := cpc_unknown_cursorname
            ELSE
                p14ansqlstatement (next_symbol, apc);
            (*ENDIF*) 
            END
        ELSE
            (* cursorname gefunden *)
            WITH sqlxa, sqlprp^ [ind ] DO
                BEGIN
                cudiind := 0;
                IF  prcuindex > 0
                THEN
                    cudiind := sqlprp^ [prcuindex]. prkaindex;
&               ifdef TRACE
                (*ENDIF*) 
                m90int2 (pc, 'cudiind ****', cudiind);
                m90int2 (pc, 'prcuindex   ', prcuindex);
                m90int2 (pc, 'prkaindex   ', prkaindex);
                m90int2 (pc, 'prStmtNameIn', prStmtNameIndex);
                m90int2 (pc, 'prarea      ', prarea   );
                m90int2 (pc, 'prstate     ', prstate  );
                m90int2 (pc, 'prstcount   ', prstcount);
                m90int2 (pc, 'prstindex   ', prstindex);
&               endif
                IF  pcinpind = cpc_inputfile
                THEN
                    lineno   := pclno.lnosrc
                ELSE
                    lineno   := - pclno.lnoexp;
                (*ENDIF*) 
                next_symbol (apc, partbufp^, part1len);
                IF   symb = cpr_s_eof
                THEN
                    (* cursorname ohne using oder into *)
                    (* es wird kein sa eintrag generiert *)
                    BEGIN
                    (* ka_eintrag generieren *)
                    p14kaentryinit (apc);
&                   ifdef PREPSTMT
                    prCursorName := cursorn;
                    prCursorNameIndex := CursorNameIndex;
                    prkaindex := pcka;
&                   endif
                    WITH sqlkap^ [pcka ] DO
                        BEGIN
                        kaprindex := ind;
                        kamacro   := macro;
                        kacuindex := pckacuind;
                        kalineno  := lineno;
                        openno    := pcka;
                        END;
                    (*ENDWITH*) 
                    IF   prkaindex = 0
                    THEN
                        BEGIN
                        END
                    ELSE
                        BEGIN
                        (** open ohne prepare korr 1.11.95 *)
                        openind := prkaindex;
                        found := false;
                        REPEAT
&                           ifdef TRACE
                            m90int2 (pc, 'prkaindex   ', prkaindex);
                            m90int2 (pc, 'openind     ', openind  );
&                           endif
                            IF  (sqlkap^[openind].katyp <> pcan.ancomtyp)
                                OR  (sqlkap^[openind].kaprindex <> ind)
                            THEN
                                openind := sqlkap^[openind].kadiindex
                            ELSE
                                found := true;
                            (*ENDIF*) 
                        UNTIL
                            (openind = 0) OR (found);
                        (*ENDREPEAT*) 
                        IF  openind = 0
                        THEN
                            openind := prkaindex;
                        (*ENDIF*) 
                        sqlkap^[pcka] := sqlkap^ [openind];
                        sqlkap^ [pcka] .katyp    := pcan.ancomtyp;
                        sqlkap^ [pcka] .kalineno := lineno;
                        sqlkap^[openind].kadiindex := pcka;
                        openno := pcka;
&                       ifdef TRACE
                        m90int2 (pc, 'kaprindex   ',
                              sqlkap^ [prkaindex] .kaprindex );
                        m90int2 (pc, 'prkaindex   ', prkaindex);
                        m90int2 (pc, 'openind     ', openind  );
                        m90int2 (pc, 'pcpr        ', pcpr     );
                        m90int2 (pc, 'pcka        ', pcka     );
&                       endif
                        END;
                    (*ENDIF*) 
&                   ifdef TRACE
                    m90int2 (pc, 'openno      ', openno  );
&                   endif
                    pcan.ancheck := pcopts.opt_mode;
                    sqlxa.xakano := openno;
                    (* PTS 1104482 *)
                    IF  ndcuindex > 0
                    THEN
                        pcsqlva.ndtabp^ [ndcuindex].ndkano := pcka;
                    (*ENDIF*) 
                    END
                ELSE
                    BEGIN
                    (* using oder descriptor *)
                    p10getkeyword (apc, partbufp^, keyind);
                    CASE keyind OF
                        cpc_i_into, cpc_i_using :
                            BEGIN
                            IF   prkaindex = 0
                            THEN
                                kaind := pcka
                            ELSE
                                kaind := prkaindex;
                            (*ENDIF*) 
                            next_symbol (apc, partbufp^, part1len);
                            p10getkeyword (apc, partbufp^, keyind);
                            IF   keyind = cpc_i_descriptor
                            THEN
                                BEGIN
                                (* ka_eintrag generieren *)
                                p14kaentryinit (apc);
                                (** open entry doppeln *)
                                sqlkap^[pcka] := sqlkap^[kaind];
                                kaind := pcka;
                                WITH sqlkap^ [kaind ] DO
&                                   ifndef PREPSTMT
                                    IF  cudiind <> 0
                                    THEN
                                        BEGIN
                                        (* rueckverwise sqlprarea *)
                                        kadiindex := cudiind;
                                        prkaindex := pcka;
                                        sqlprp^[prcuindex].prkaindex:= pcka;
                                        END
                                    ELSE
                                        BEGIN
                                        kadiindex := prkaindex;
                                        prkaindex := pcka;
                                        END;
                                    (*ENDIF*) 
                                (*ENDWITH*) 
&                               else
                                BEGIN
                                kadiindex := prkaindex;
                                prkaindex := pcka;
                                prCursorName := cursorn;
                                (* PTS 1104482 *)
                                prCursorNameIndex := CursorNameIndex;
                                IF  ndcuindex > 0
                                THEN
                                    pcsqlva.ndtabp^ [ndcuindex].ndkano := pcka;
                                (*ENDIF*) 
                                END;
&                               endif
                                next_symbol (apc, partbufp^, part1len);
                                IF   symb <> cpr_s_eof
                                THEN
                                    BEGIN
                                    IF  (rakamode <> cpr_kind_internal)
                                    THEN
                                        BEGIN
                                        IF  partbufp^ [sypos] = cpr_paramchr
                                        THEN
                                            xadescpos := sypos + 1
                                        ELSE
                                            xadescpos := sypos;
                                        (*ENDIF*) 
                                        (* xadescpos := sypos; *)
                                        xadesclen := syposacc - xadescpos;
                                        next_symbol (apc, partbufp^, part1len);
                                        END
                                    ELSE
                                        BEGIN
                                        IF  partbufp^ [sypos] = cpr_paramchr
                                        THEN
                                            xadescpos := sypos + 1
                                        ELSE
                                            BEGIN
                                            p10getkeyword (apc, partbufp^, keyind);
                                            IF  keyind <> cpc_i_keep
                                            THEN
                                                BEGIN
                                                xadescpos := sypos;
                                                xadesclen := syposacc - xadescpos;
                                                next_symbol (apc, partbufp^, part1len);
                                                END
                                            ELSE
                                                BEGIN
                                                xadescpos := -1;
                                                END
                                            (*ENDIF*) 
                                            END
                                        (*ENDIF*) 
                                        END;
                                    (*ENDIF*) 
                                    p10getkeyword (apc, partbufp^, keyind);
                                    IF  keyind = cpc_i_keep
                                    THEN
                                        BEGIN
                                        pcan.ancomtyp := cpr_com_sql_open_keep;
                                        END;
                                    (*ENDIF*) 
                                    WHILE  (symb <> cpr_s_eof) AND
                                          (symb <> cpr_s_bufeof) DO
                                        BEGIN
                                        next_symbol (apc, partbufp^,
                                              part1len);
                                        END;
                                    (*ENDWHILE*) 
                                    END
                                ELSE
                                    BEGIN
                                    IF  (rakamode = cpr_kind_internal)
                                    THEN
                                        (* default sqldb sqlda expansion *)
                                        xadescpos := -1
                                    ELSE
                                        err := cpc_invalid_sql_command;
                                    (*ENDIF*) 
                                    END;
                                (*ENDIF*) 
                                sqlxa.sqlprp^ [ind] .prDescribe :=
                                      cpr_is_true;
                                sqlxa.sqlkap^[kaind] .kaprindex := ind;
                                sqlxa.sqlkap^[kaind] .kapacount:= -1;
                                sqlxa.sqlkap^[kaind] .katyp := pcan.ancomtyp;
                                sqlxa.sqlkap^[kaind] .kalineno := lineno;
                                openno := kaind;
                                END
                            ELSE
                                IF  symb <> cpr_s_parameter_name
                                THEN
                                    err := cpc_invalid_sql_command
                                ELSE
                                    BEGIN
                                    kaentry := sqlkap^[kaind];  (*bf*)
                                    p14an1sqlstatement (next_symbol, apc);
&                                   ifdef TRACE
                                    m90int2 (pc, 'ind         ', ind);
                                    m90int2 (pc, 'kaind       ', kaind);
                                    m90int2 (pc, 'pcka        ', pcka);
                                    m90int2 (pc, 'prkaindex   ', prkaindex);
                                    m90int2 (pc, 'kalineno    ', lineno   );
&                                   endif
                                    (******bf*******)
                                    WITH kaentry  DO
                                        BEGIN
                                        kaprindex := ind;
                                        katyp := pcan.ancomtyp;
                                        kapacount := sqlxa.sqlkap^ [pcka]
                                              .kapacount;
                                        kapaindex := sqlxa.sqlkap^ [pcka]
                                              .kapaindex;
                                        kalineno := lineno;
                                        IF  cudiind <> 0
                                        THEN
                                            BEGIN
                                            kadiindex := cudiind;
                                            prkaindex := pcka;
                                            sqlprp^[prcuindex].prkaindex
                                                  := pcka;
                                            END
                                        ELSE
                                            BEGIN
                                            kadiindex := prkaindex;
                                            prkaindex := pcka;
                                            END;
                                        (*ENDIF*) 
                                        prCursorName := cursorn;
                                        prCursorNameIndex := CursorNameIndex;
                                        sqlxa.sqlkap^[pcka] := kaentry;
                                        END;
                                    (*ENDWITH*) 
                                    xakano := pcka;
                                    openno := pcka;
                                    END;
                                (*ENDIF*) 
                            (*ENDIF*) 
                            END;
                        OTHERWISE:
                            err := cpc_invalid_sql_command;
                        END;
                    (*ENDCASE*) 
                    sqlxa.xakano := openno;
                    END;
                (*ENDIF*) 
                END;
            (*ENDWITH*) 
        (*ENDIF*) 
        IF   err <> cpc_pre_ok
        THEN
            p11precomerror (apc, err);
        (*ENDIF*) 
        END;
    (*ENDIF*) 
    WHILE  (symb <> cpr_s_eof) AND (symb <> cpr_s_bufeof) DO
        next_symbol (apc, partbufp^, part1len);
    (*ENDWHILE*) 
&   ifdef TRACE
    m90int2 (pc, 'xakano      ', xakano   );
    m90int2 (pc, 'xadescpos   ', xadescpos);
    m90int2 (pc, 'xadesclen   ', xadesclen);
&   endif
    END;
(*ENDWITH*) 
&ifdef TRACE
m90name(xx, 'END p14open       ');
&endif
END;
 
(*------------------------------*) 
 
PROCEDURE
      p14include   (
            PROCEDURE next_symbol (VAR p1: tpc_globals;
            VAR p2: tpc_partbuffer; p3: integer);
            VAR apc : tpc_globals;
            VAR keyind: integer;
            VAR dclgen : boolean);
 
VAR
      len    : integer;
      pos    : integer;
      rscan  : tpr_scannertype;
      inclfile : boolean;
 
BEGIN
WITH apc, pcscan, sqlca, sqlrap^, pccmdpart, pcdclgen DO
    BEGIN
    keyind:= 0;
    dclgen   := false;
    inclfile := false;
    asclause := cpc_as_empty;
    IF   pcerror = cpc_pre_ok
    THEN
        BEGIN
        next_symbol (apc, partbufp^, part1len);
        IF   (symb = cpr_s_identifier)
            OR ((ralang = cpr_la_c)
            AND (symb <> cpr_s_string_literal)
            AND  (symb <> cpr_s_cstring_literal))
        THEN
            BEGIN
            p10getkeyword (apc, partbufp^, keyind);
            CASE ralang OF
                cpr_la_pascallpi,
                cpr_la_pascal, cpr_la_pascal31, cpr_la_pascalvax :
                    CASE keyind OF
                        cpc_i_sqlconst :
                            BEGIN
                            IF   (pccodeind > cpc_work1file)
                            THEN
                                p11precomerror (apc,
                                      cpc_include_area_on_wrong_position);
                            (*ENDIF*) 
                            pccodeind := cpc_work2file;
                            END;
                        cpc_i_sqlproc  :
                            BEGIN
                            IF   (pccodeind > cpc_work2file)
                            THEN
                                p11precomerror (apc,
                                      cpc_include_area_on_wrong_position);
                            (*ENDIF*) 
                            pccodeind := cpc_work3file;
                            END;
                        cpc_i_sqltype, cpc_i_sqlca  :
                            BEGIN
                            IF   (pccodeind <> cpc_work2file)
                            THEN
                                p11precomerror (apc,
                                      cpc_include_area_on_wrong_position);
                            (*ENDIF*) 
                            END;
                        OTHERWISE:
                            p11wrerrorlisting (apc, cpc_unknown_sql_command);
                        END;
                    (*ENDCASE*) 
                cpr_la_cobol, cpr_la_cobmic :
                    BEGIN
                    END;
                cpr_la_c :
                    IF   (keyind in [cpc_i_sqlca, cpc_i_sqlda, cpc_i_oraca] )
                    THEN
                        BEGIN
                        WHILE (symb<> cpr_s_eof) AND (symb <> cpr_s_bufeof) DO
                            BEGIN
                            next_symbol (apc, partbufp^, part1len);
                            END;
                        (*ENDWHILE*) 
                        END
                    ELSE
                        IF  (rakamode <> cpr_kind_oracle)
                            AND  ( rakamode <> cpr_kind_sapr3 )
                        THEN
                            p11wrerrorlisting(apc,cpc_unknown_sql_command)
                        ELSE
                            BEGIN
                            (* umschalten auf include file *)
                            IF   pcinpind = cpc_includefile
                            THEN
                                p11wrerrorlisting (apc,
                                      cpc_includefile_allready_open)
                            ELSE
                                WITH pcvf.vffn [cpc_includefile ] DO
                                    BEGIN
                                    inclfile := true;
                                    vffileno := 0;
                                    vffilemode  := sp5vf_read;
                                    vfbinary := false;
                                    vfreclen2:= 0;
                                    vfreclen4:= 0;
                                    pr01eInitFileName(vffilen);
                                    vfcnt    := 0;
                                    pos       := 1;
                                    WHILE (symb <> cpr_s_eof) AND
                                          (symb <> cpr_s_bufeof) DO
                                        BEGIN
                                        IF   sylen + pos > VFILENAME_MXSP00
                                        THEN
                                            len := VFILENAME_MXSP00 - pos
                                        ELSE
                                            len := sylen;
                                        (*ENDIF*) 
                                        s10mv (partsizlen, VFILENAME_MXSP00,
                                              @partbufp^, sypos,
                                              @vffilen, pos, len);
                                        pos := pos + len;
                                        next_symbol (apc, partbufp^,
                                              part1len);
                                        END;
                                    (*ENDWHILE*) 
                                    END;
                                (*ENDWITH*) 
                            (*ENDIF*) 
                            END;
                        (*ENDIF*) 
                    (*ENDIF*) 
                OTHERWISE:
                    p11wrerrorlisting(apc,cpc_pre_not_implemented);
                END;
            (*ENDCASE*) 
            IF  (pcerror = cpc_pre_ok)
                AND (symb <> cpr_s_eof) AND (symb <> cpr_s_bufeof)
                AND (ralang <> cpr_la_cobol)
            THEN
                BEGIN
                rscan := pcscan;
                next_symbol (apc, partbufp^, part1len);
                IF   (symb <> cpr_s_eof) AND (symb <> cpr_s_bufeof)
                THEN
                    p11wrerrorlisting (apc, cpc_invalid_sql_command);
                (*ENDIF*) 
                IF  NOT (ralang in [cpr_la_c, cpr_la_cobol])
                THEN
                    pcscan := rscan;
                (*ENDIF*) 
                END;
            (*ENDIF*) 
            END
        ELSE
            IF  NOT (  (symb = cpr_s_string_literal)
                OR (symb = cpr_s_cstring_literal))
            THEN
                p11wrerrorlisting (apc, cpc_invalid_sql_command);
            (*ENDIF*) 
        (*ENDIF*) 
        IF   (symb = cpr_s_string_literal)
            OR (symb = cpr_s_cstring_literal)
        THEN
            BEGIN
            (* umschalten auf include file *)
            p10stringliteralget (apc, partbufp^);
            IF   pcinpind = cpc_includefile
            THEN
                p11wrerrorlisting (apc, cpc_includefile_allready_open)
            ELSE
                WITH pcvf.vffn [cpc_includefile ] DO
                    BEGIN
                    inclfile := true;
                    vffileno := 0;
                    vffilemode  := sp5vf_read;
                    vfbinary := false;
                    vfreclen2:= 0;
                    vfreclen4:= 0;
                    pr01eInitFileName(vffilen);
                    vfcnt    := 0;
                    IF   sylen > VFILENAME_MXSP00
                    THEN
                        len := VFILENAME_MXSP00
                    ELSE
                        len := sylen;
                    (*ENDIF*) 
                    s10mv (partsizlen, VFILENAME_MXSP00, @partbufp^, sypos,
                          @vffilen, 1, len);
                    (*  get include syntax into pcdclgen *)
                    p14_dclgen (next_symbol, apc, dclgen, len);
                    END;
                (*ENDWITH*) 
            (*ENDIF*) 
            END;
        (*ENDIF*) 
        IF  inclfile
        THEN
            WITH pcvf.vffn [cpc_includefile ] DO
                BEGIN
                IF   pcan.ansection <> cpc_se_off
                THEN
                    pcsqlcom := true;
                (*ENDIF*) 
                p11vfopen (apc, cpc_includefile);
                IF   pcerror = cpc_pre_ok
                THEN
                    BEGIN
                    pcinpind := cpc_includefile;
                    (* sqlfn-area belegen 3.11.93 *)
                    p14sqlfn_areaput (apc);
                    IF  dclgen
                    THEN
                        BEGIN
                        p11wrerrorlisting (apc, cpc_include_file_exist);
                        sqlca.sqlcode := 0;
                        pcerror := cpc_pre_ok ;
                        END;
                    (*ENDIF*) 
                    dclgen := false;
                    END
                ELSE
                    BEGIN
                    IF  (dclgen) AND (pcopts.opt_mode <> cpc_ch_no)
                    THEN
                        BEGIN
                        p16tabledclgen (apc, dclgen);
                        IF  (dclgen) AND (sqlcode = 0)
                        THEN
                            BEGIN
                            pcerror  := cpc_pre_ok;
                            vffilemode  := sp5vf_write;
                            p11vfopen (apc, cpc_includefile);
                            p14_put_dclgen (apc);
                            END
                        (*ENDIF*) 
                        END;
                    (*ENDIF*) 
                    IF  (NOT dclgen) OR (pcerror <> cpc_pre_ok)
                    THEN
                        BEGIN
                        dclgen := false;
                        p11wrerrorlisting (apc, cpc_includefile_open_error);
                        END;
                    (*ENDIF*) 
                    END;
                (*ENDIF*) 
                END;
            (*ENDWITH*) 
        (*ENDIF*) 
        END;
    (*ENDIF*) 
    END;
(*ENDWITH*) 
&ifdef TRACE
m90name(xx, 'END p14include    ');
&endif
END;
 
(*------------------------------*) 
 
PROCEDURE
      p14begin (
            PROCEDURE next_symbol (VAR p1: tpc_globals;
            VAR p2: tpc_partbuffer; p3: integer);
            VAR apc : tpc_globals);
 
VAR
      keyind : integer;
 
BEGIN
WITH apc, pcscan, sqlca, sqlrap^, pccmdpart DO
    BEGIN
    IF   pcerror = cpc_pre_ok
    THEN
        BEGIN
        next_symbol (apc, partbufp^, part1len);
        p10getkeyword (apc, partbufp^, keyind);
        IF   keyind = cpc_i_declare
        THEN
            BEGIN
            next_symbol (apc, partbufp^, part1len);
            p10getkeyword (apc, partbufp^, keyind);
            CASE ralang OF
                cpr_la_pascallpi,
                cpr_la_pascal, cpr_la_pascal31, cpr_la_pascalvax :
                    IF   pcan.ansection <> cpc_se_off
                    THEN
                        p11wrerrorlisting (apc, cpc_invalid_section_begin_or_end)
                    ELSE
                        CASE keyind OF
                            cpc_i_const :
                                BEGIN
                                pcan.ansection := cpc_se_const;
                                next_symbol (apc, partbufp^, part1len);
                                p10getkeyword (apc, partbufp^, keyind);
                                IF   keyind <> cpc_i_section
                                THEN
                                    p11wrerrorlisting (apc,cpc_unknown_sql_command);
                                (*ENDIF*) 
                                END;
                            cpc_i_type  :
                                BEGIN
                                pcan.ansection := cpc_se_type;
                                next_symbol (apc, partbufp^, part1len);
                                p10getkeyword (apc, partbufp^, keyind);
                                IF   keyind <> cpc_i_section
                                THEN
                                    p11wrerrorlisting (apc,cpc_unknown_sql_command);
                                (*ENDIF*) 
                                END;
                            cpc_i_section  :
                                pcan.ansection := cpc_se_var;
                            OTHERWISE:
                                p11wrerrorlisting (apc, cpc_unknown_sql_command);
                            END;
                        (*ENDCASE*) 
                    (*ENDIF*) 
                cpr_la_c, cpr_la_cobol, cpr_la_cobmic, cpr_la_cob8860 :
                    IF   keyind = cpc_i_section
                    THEN
                        pcan.ansection := cpc_se_var
                    ELSE
                        p11wrerrorlisting (apc,cpc_unknown_sql_command);
                    (*ENDIF*) 
                OTHERWISE:
                    p11wrerrorlisting (apc, cpc_pre_not_implemented);
                END;
            (*ENDCASE*) 
            IF   (pcerror = cpc_pre_ok)
            THEN
                BEGIN
                next_symbol (apc, partbufp^, part1len);
                IF   (symb <> cpr_s_eof) AND (symb <> cpr_s_bufeof)
                THEN
                    p11wrerrorlisting (apc, cpc_invalid_sql_command);
                (*ENDIF*) 
                END;
            (*ENDIF*) 
            END
        ELSE
            p11wrerrorlisting (apc, cpc_unknown_sql_command);
        (*ENDIF*) 
        END;
    (*ENDIF*) 
    IF  pcan.ansection <> cpc_se_record
    THEN
        WHILE  (symb <> cpr_s_eof) AND (symb <> cpr_s_bufeof) DO
            next_symbol (apc, partbufp^, part1len);
        (*ENDWHILE*) 
    (*ENDIF*) 
    END;
(*ENDWITH*) 
&ifdef TRACE
m90name(xx, 'END p14begin      ');
&endif
END;
 
(*------------------------------*) 
 
PROCEDURE
      p14command  (
            PROCEDURE next_symbol (VAR p1: tpc_globals;
            VAR p2: tpc_partbuffer; p3: integer);
            VAR apc : tpc_globals);
 
VAR
      err   : tpc_pre_errors;
      ptypentix : tsp00_Int2;
      pvatyp    : tsp00_Int2;
      keyind    : integer;
      pos       : integer;
      len       : integer;
      retpos    : tsp00_Int2;
      lastvatyp : tsp00_Int2;
      vix       : integer;
 
BEGIN
WITH apc, sqlxa, pcscan, sqlca, sqlrap^, pccmdpart, pcsqlva DO
    BEGIN
    retpos := sypos;
    pcan.ancheck := pcopts.opt_mode;
    pcusage.uscom    := cpc_usage_comm;
    pcusage.usdobjn1 := bsp_knl_identifier;
    pcusage.usdobjn2 := bsp_knl_identifier;
    IF  ralang in [cpr_la_c, cpr_la_cobol]
    THEN
        WHILE  (symb <> cpr_s_eof) AND (symb <> cpr_s_bufeof) DO
            next_symbol (apc, partbufp^, part1len);
        (*ENDWHILE*) 
    (*ENDIF*) 
    IF  ralang = cpr_la_cobol
    THEN
        BEGIN
        part1len := part1len + 1;
        partbufp^ [part1len] := cpr_nullchar ;
        END;
    (*ENDIF*) 
    syposacc := retpos;
    symb     := cpr_s_unknown;
    err  := cpc_pre_ok;
    p14kaentryinit (apc);
    WITH sqlkap^ [pcka ] DO
        BEGIN
        p19sqlprallocate (pcpr);
        WITH sqlxa, sqlprp^ [pcpr ] DO
            BEGIN
            kaprindex := pcpr;
            prstcount := 0;
            prstindex := 0;
            prcuindex := 0;
            prstate:= cpr_state_sync_exec;
            prarea := cpr_in_sqlva;
            prkaindex := 0;
            prDescribe := cpr_is_false;
            prStmtName   := bsp_knl_identifier;
            prStmtNameIndex := 0;
            prCursorNameIndex := 0;
            prCursorName := bsp_knl_identifier;
            next_symbol (apc, partbufp^, part1len);
            IF  symb = cpr_s_identifier
            THEN
                BEGIN
                p10getkeyword (apc, partbufp^, keyind);
                CASE  keyind OF
                    cpc_i_sync :
                        prstate:= cpr_state_sync_exec;
                    cpc_i_newsync :
                        prstate:= cpr_state_newsync_exec;
                    cpc_i_async :
                        prstate:= cpr_state_async_exec;
                    OTHERWISE:
                        p11precomerror (apc, cpc_invalid_sql_command);
                    END;
                (*ENDCASE*) 
                next_symbol (apc, partbufp^, part1len);
                END;
            (*ENDIF*) 
            IF  symb = cpr_s_parameter_name
            THEN
                BEGIN
                syposacc := sypos + 1;
                ptypentix := 0;
                p14btypentget (next_symbol, apc, ptypentix,
                      pvatyp, lastvatyp, cpr_is_true);
                IF  ptypentix = 0
                THEN
                    p11precomerror (apc, cpc_unknown_parametername)
                ELSE
                    BEGIN
                    kapacount := 0;
                    kapaindex := pcpa + 1;
                    syposacc   := sypos;
                    WITH ndtabp^ [ndcnt] DO
                        BEGIN
                        IF  ndsqlva1st <> ndsqlva1ix
                        THEN
                            BEGIN
                            p19cparentry (apc, sqlparst, ndsqlva1st,
                                  0 , ndsqlva1cnt);
                            kapacount := 1;
                            END;
                        (*ENDIF*) 
                        p19cparentry (apc, sqlparel,
                              ndsqlva1ix, 0, 0);
                        kapacount := kapacount + 1;
                        END;
                    (*ENDWITH*) 
                    END;
                (*ENDIF*) 
                END
            ELSE
                IF  (symb = cpr_s_string_literal)
                    OR (symb = cpr_s_cstring_literal)
                THEN
                    BEGIN
                    (* command = stringconst  *)
                    p10stringliteralget (apc, partbufp^);
                    kaStindex := pcst + 1;
                    prarea     := cpr_in_sqlst;
                    pos := sypos;
                    WHILE pos <  sypos + sylen  DO
                        BEGIN
                        IF   pos + mxpr_sqlline
                            > sypos + sylen
                        THEN
                            len := sypos + sylen - pos
                        ELSE
                            len := mxpr_sqlline;
                        (*ENDIF*) 
                        p19sqlstallocate (pcst);
                        IF  pcst > pcstmax
                        THEN
                            pcstmax := pcst;
                        (*ENDIF*) 
                        kaStcount := kaStcount + 1;
                        s10mv (partsizlen,mxpr_sqlline,
                              @partbufp^, pos,
                              @sqlstp^ [pcst].stline, 1, len);
                        sqlstp^ [pcst].stllen  := len;
                        sqlstp^ [pcst].stkano := pcka;
                        pos := pos + len;
                        END;
                    (*ENDWHILE*) 
                    END
                ELSE
                    p11precomerror (apc, cpc_invalid_sql_command);
                (*ENDIF*) 
            (*ENDIF*) 
            IF   (symb <> cpr_s_eof) AND  (symb <> cpr_s_bufeof)
            THEN
                next_symbol (apc, partbufp^, part1len);
            (*ENDIF*) 
            IF  prstate <> cpr_state_async_exec
            THEN
                BEGIN
                (* result parameter *)
                p10getkeyword (apc, partbufp^, keyind);
                IF  keyind <> cpc_i_result
                THEN
                    p11precomerror (apc, cpc_invalid_sql_command)
                ELSE
                    BEGIN
                    next_symbol (apc, partbufp^, part1len);
                    IF  symb <> cpr_s_parameter_name
                    THEN
                        p11precomerror (apc, cpc_invalid_sql_command)
                    ELSE
                        BEGIN
                        syposacc := sypos + 1;
                        ptypentix := 0;
                        p14btypentget (next_symbol, apc, ptypentix,
                              pvatyp, lastvatyp, cpr_is_true);
                        IF  ptypentix = 0
                        THEN
                            p11precomerror (apc, cpc_unknown_parametername)
                        ELSE
                            BEGIN
                            prkaindex := pcpa + 1;
                            WITH ndtabp^ [ndcnt] DO
                                BEGIN
                                IF  ndsqlva1st <> ndsqlva1ix
                                THEN
                                    BEGIN
                                    p19cparentry (apc, sqlparst,
                                          ndsqlva1st, 0, ndsqlva1cnt);
                                    END;
                                (*ENDIF*) 
                                p19cparentry (apc, sqlparel,
                                      ndsqlva1ix, 0, 0);
                                vix := ndsqlva1ix;
                                IF  sqlv1p^[vix].va1indi_sc = sqlvapt
                                THEN
                                    vix :=  sqlv1p^[vix].va1ix_pt;
                                (*ENDIF*) 
                                END;
                            (*ENDWITH*) 
                            WITH  sqlv1p^[vix],sqlv2p^[va1indva2_sc] DO
                                CASE  va2typ  OF
                                    cpr_vint2, cpr_vint4 :
                                        BEGIN
                                        END;
                                    OTHERWISE:
                                        BEGIN
                                        p11precomerror (apc,
                                              cpc_datatyp_not_compatible);
                                        END;
                                    END;
                                (*ENDCASE*) 
                            (*ENDWITH*) 
                            END;
                        (*ENDIF*) 
                        IF   (symb <> cpr_s_eof) AND
                            (symb <> cpr_s_bufeof)
                        THEN
                            next_symbol (apc, partbufp^, part1len);
                        (*ENDIF*) 
                        END;
                    (*ENDIF*) 
                    END;
                (*ENDIF*) 
                END;
            (*ENDIF*) 
            IF  (symb <> cpr_s_eof)
                AND (symb <> cpr_s_bufeof)
            THEN
                p11precomerror (apc, cpc_invalid_sql_command);
            (*ENDIF*) 
            END;
        (*ENDWITH*) 
        END;
    (*ENDWITH*) 
    IF   err <> cpc_pre_ok
    THEN
        p11precomerror (apc, err);
    (*ENDIF*) 
    symb := cpr_s_eof;
    END;
(*ENDWITH*) 
&ifdef TRACE
m90name(xx, 'END p14command    ');
&endif
END;
 
(*------------------------------*) 
 
PROCEDURE
      p14cancel  (
            PROCEDURE next_symbol (VAR p1: tpc_globals;
            VAR p2: tpc_partbuffer; p3: integer);
            VAR apc : tpc_globals);
 
VAR
      err   : tpc_pre_errors;
      ptypentix : tsp00_Int2;
      pvatyp    : tsp00_Int2;
      keyind    : integer;
      retpos    : tsp00_Int2;
      lastvatyp : tsp00_Int2;
      sessno    : tsp00_Int2;
 
BEGIN
WITH apc, sqlxa, pcscan, sqlca, sqlrap^, pccmdpart, pcsqlva DO
    BEGIN
    retpos := syposacc;
    pcan.ancheck := pcopts.opt_mode;
    pcan.ancomtyp := cpr_com_cancel;
    pcusage.uscom    := cpc_usage_cancel;
    pcusage.usdobjn1 := bsp_knl_identifier;
    pcusage.usdobjn2 := bsp_knl_identifier;
    IF  ralang in [cpr_la_c, cpr_la_cobol]
    THEN
        WHILE  (symb <> cpr_s_eof) AND (symb <> cpr_s_bufeof) DO
            next_symbol (apc, partbufp^, part1len);
        (*ENDWHILE*) 
    (*ENDIF*) 
    IF  ralang = cpr_la_cobol
    THEN
        BEGIN
        part1len := part1len + 1;
        partbufp^ [part1len] := cpr_nullchar ;
        END;
    (*ENDIF*) 
    syposacc := retpos;
    symb     := cpr_s_unknown;
    err  := cpc_pre_ok;
    p14kaentryinit (apc);
    WITH sqlkap^ [pcka ] DO
        BEGIN
        next_symbol (apc, partbufp^, part1len);
        CASE symb OF
            cpr_s_identifier :
                BEGIN
                p10getkeyword (apc, partbufp^, keyind);
                IF  keyind = cpc_i_current
                THEN
                    (* kapaindex = null *)
                    kapacount := 1
                ELSE
                    p11wrerrorlisting (apc, cpc_unknown_sql_command);
                (*ENDIF*) 
                next_symbol (apc, partbufp^, part1len);
                END;
            cpr_s_parameter_name :
                WITH  pcsqlva, pcsymtab DO
                    BEGIN
                    (* statement in variabler *)
                    syposacc := sypos+1;
                    ptypentix  := 0;
                    p14btypentget (next_symbol, apc, ptypentix,
                          pvatyp, lastvatyp, cpr_is_true);
                    IF   ptypentix = 0
                    THEN
                        BEGIN
                        IF   (pcerror = cpc_pre_ok)
                        THEN
                            BEGIN
                            p11precomerror (apc, cpc_unknown_parametername);
                            p11nerrorlisting ( apc,
                                  vartablep^ [ndtabp^[ndcnt].ndvarentix].vaname,
                                  vartablep^[ndtabp^[ndcnt].ndvarentix].vanaml,0);
                            END
                        (*ENDIF*) 
                        END
                    ELSE
                        IF  NOT (pvatyp in [cpr_vint2, cpr_vint4,
                            cpr_vuns2, cpr_vuns4])
                        THEN
                            BEGIN
                            p11precomerror (apc, cpc_datatyp_not_compatible);
                            p11nerrorlisting ( apc,
                                  vartablep^ [ndtabp^[ndcnt].ndvarentix].vaname,
                                  vartablep^[ndtabp^[ndcnt].ndvarentix].vanaml,0);
                            END
                        ELSE
                            BEGIN
                            (* kapaindex positiv *)
                            kapaindex := pcpa + 1;
                            WITH ndtabp^ [ndcnt] DO
                                BEGIN
                                IF  ndsqlva1st <> ndsqlva1ix
                                THEN
                                    BEGIN
                                    p19cparentry (apc, sqlparst, ndsqlva1st,
                                          0 , ndsqlva1cnt);
                                    kapacount := 1;
                                    END;
                                (*ENDIF*) 
                                p19cparentry (apc, sqlparel,
                                      ndsqlva1ix, 0, 0);
                                kapacount := kapacount + 1;
                                END;
                            (*ENDWITH*) 
                            END;
                        (*ENDIF*) 
                    (*ENDIF*) 
                    END;
                (*ENDWITH*) 
            cpr_s_unsigned_integer :
                BEGIN
                p10int2unsignedget (apc, partbufp^, sessno);
                IF  (sessno < 1)
                    OR (sessno > 8)
                THEN
                    p11wrerrorlisting (apc, cpc_session_not_allowed)
                ELSE
                    BEGIN
                    (* kapaindex negativ *)
                    kapacount := 1;
                    kapaindex := - sessno;
                    END;
                (*ENDIF*) 
                next_symbol (apc, partbufp^, part1len);
                END;
            OTHERWISE
                p11wrerrorlisting (apc, cpc_unknown_sql_command);
            END;
        (*ENDCASE*) 
        IF   (symb <> cpr_s_eof) AND
            (symb <> cpr_s_bufeof)
        THEN
            p11wrerrorlisting (apc, cpc_unknown_sql_command);
        (*ENDIF*) 
        END;
    (*ENDWITH*) 
    symb := cpr_s_eof;
    END;
(*ENDWITH*) 
END;
 
(*------------------------------*) 
 
PROCEDURE
      p14abortsession (
            PROCEDURE next_symbol (VAR p1: tpc_globals;
            VAR p2: tpc_partbuffer; p3: integer);
            VAR apc : tpc_globals);
 
VAR
      nextsa : boolean;
      err    : tpc_pre_errors;
      pos    : integer;
      len    : integer;
      retpos : integer;
      keyind    : integer;
 
BEGIN
WITH apc, pcscan, sqlca, sqlrap^, pccmdpart  DO
    BEGIN
    retpos := syposacc;
    IF  ralang in [cpr_la_c]
    THEN
        WHILE  (symb <> cpr_s_eof) AND (symb <> cpr_s_bufeof) DO
            next_symbol (apc, partbufp^, part1len);
        (*ENDWHILE*) 
    (*ENDIF*) 
    syposacc := retpos;
    symb     := cpr_s_unknown;
    err  := cpc_pre_ok;
    next_symbol (apc, partbufp^, part1len);
    p10getkeyword (apc, partbufp^, keyind);
    IF   keyind = cpc_i_session
    THEN
        BEGIN
        pcan.ancomtyp := cpr_com_abort_session;
        p14kaentryinit (apc);
        END
    ELSE
        p11wrerrorlisting (apc, cpc_unknown_sql_command);
    (*ENDIF*) 
    END;
(*ENDWITH*) 
&ifdef TRACE
m90name(xx, 'END p14abortsessio');
&endif
END;
 
(*------------------------------*) 
 
PROCEDURE
      p14version  (
            PROCEDURE next_symbol (VAR p1: tpc_globals;
            VAR p2: tpc_partbuffer; p3: integer);
            VAR apc : tpc_globals);
 
VAR
      i     : integer;
      err   : tpc_pre_errors;
      ptypentix : tsp00_Int2;
      pvatyp    : tsp00_Int2;
      retpos    : tsp00_Int2;
      lastvatyp : tsp00_Int2;
 
BEGIN
WITH apc, sqlxa, pcscan, sqlca, sqlrap^, pccmdpart, pcsqlva DO
    BEGIN
    retpos := syposacc;
    pcan.ancheck := pcopts.opt_mode;
    pcan.ancomtyp := cpr_com_cancel;
    pcusage.uscom    := cpc_usage_cancel;
    pcusage.usdobjn1 := bsp_knl_identifier;
    pcusage.usdobjn2 := bsp_knl_identifier;
    IF  ralang in [cpr_la_c, cpr_la_cobol]
    THEN
        WHILE  (symb <> cpr_s_eof) AND (symb <> cpr_s_bufeof) DO
            next_symbol (apc, partbufp^, part1len);
        (*ENDWHILE*) 
    (*ENDIF*) 
    IF  ralang = cpr_la_cobol
    THEN
        BEGIN
        part1len := part1len + 1;
        partbufp^ [part1len] := cpr_nullchar ;
        END;
    (*ENDIF*) 
    syposacc := retpos;
    symb     := cpr_s_unknown;
    err  := cpc_pre_ok;
    p14kaentryinit (apc);
    WITH sqlkap^ [pcka ] DO
        BEGIN
        kapaindex := pcpa + 1;
        FOR i := 1 TO 2 DO
            BEGIN
            next_symbol (apc, partbufp^, part1len);
            CASE symb OF
                cpr_s_parameter_name :
                    WITH  pcsqlva, pcsymtab DO
                        BEGIN
                        (* 1.lzu  2.pcr version variable *)
                        syposacc := sypos+1;
                        ptypentix  := 0;
                        p14btypentget (next_symbol, apc, ptypentix,
                              pvatyp, lastvatyp, cpr_is_true);
                        IF   ptypentix = 0
                        THEN
                            BEGIN
                            IF   (pcerror = cpc_pre_ok)
                            THEN
                                BEGIN
                                p11precomerror(apc,cpc_unknown_parametername);
                                p11nerrorlisting ( apc,
                                      vartablep^ [ndtabp^[ndcnt].ndvarentix]
                                      .vaname,
                                      vartablep^[ndtabp^[ndcnt].ndvarentix]
                                      .vanaml,0);
                                END
                            (*ENDIF*) 
                            END
                        ELSE
                            IF  NOT (pvatyp in [cpr_vchar, cpr_vcharc,
                                cpr_vbuf, cpr_vstring, cpr_vstring4])
                            THEN
                                BEGIN
                                p11precomerror (apc,
                                      cpc_datatyp_not_compatible);
                                p11nerrorlisting ( apc,
                                      vartablep^ [ndtabp^[ndcnt].ndvarentix]
                                      .vaname,
                                      vartablep^[ndtabp^[ndcnt].ndvarentix]
                                      .vanaml,0);
                                END
                            ELSE
                                BEGIN
                                (* kapaindex pa-area-index *)
                                WITH ndtabp^ [ndcnt] DO
                                    BEGIN
                                    IF  ndsqlva1st <> ndsqlva1ix
                                    THEN
                                        BEGIN
                                        p19cparentry (apc, sqlparst, ndsqlva1st,
                                              0 , ndsqlva1cnt);
                                        kapacount := kapacount + 1;
                                        END;
                                    (*ENDIF*) 
                                    p19cparentry (apc, sqlparel,
                                          ndsqlva1ix, 0, 0);
                                    kapacount := kapacount + 1;
                                    END;
                                (*ENDWITH*) 
                                END;
                            (*ENDIF*) 
                        (*ENDIF*) 
                        END;
                    (*ENDWITH*) 
                OTHERWISE
                    p11wrerrorlisting (apc, cpc_unknown_sql_command);
                END;
            (*ENDCASE*) 
            END;
        (*ENDFOR*) 
        IF   (symb <> cpr_s_eof) AND
            (symb <> cpr_s_bufeof)
        THEN
            p11wrerrorlisting (apc, cpc_unknown_sql_command);
        (*ENDIF*) 
        END;
    (*ENDWITH*) 
    symb := cpr_s_eof;
    END;
(*ENDWITH*) 
END;
 
(*------------------------------*) 
 
PROCEDURE
      p14_hostv_get  (
            PROCEDURE next_symbol (VAR p1: tpc_globals;
            VAR p2: tpc_partbuffer; p3: integer);
            VAR apc : tpc_globals;
            VAR paix : tsp00_Int2;
            VAR va1ix : tsp00_Int2);
 
VAR
      ptypentix : tsp00_Int2;
      pvatyp    : tsp00_Int2;
      lastvatyp : tsp00_Int2;
 
BEGIN
WITH apc, sqlxa, pcscan, sqlca DO
    BEGIN
&   ifdef TRACE
    m90int(pc, 'pcpr        ', pcpr);
&   endif
    WITH  sqlprp^ [pcpr ],  sqlkap^ [pcka ],
         pcsqlva, pcsymtab DO
        BEGIN
        (* statementname in hostvar *)
        va1ix    := 0;
        syposacc := sypos+1;
        ptypentix  := 0;
        p14btypentget (next_symbol, apc, ptypentix,
              pvatyp, lastvatyp, cpr_is_true);
        IF   ptypentix = 0
        THEN
            BEGIN
            IF   (pcerror = cpc_pre_ok)
            THEN
                BEGIN
                p11precomerror (apc, cpc_unknown_parametername);
                p11nerrorlisting ( apc,
                      vartablep^ [ndtabp^[ndcnt].ndvarentix].vaname,
                      vartablep^ [ndtabp^[ndcnt].ndvarentix].vanaml, 0);
                END
            (*ENDIF*) 
            END
        ELSE
            IF  NOT (pvatyp in [cpr_vchar..cpr_vbuf,
                cpr_vstring, cpr_vstring1, cpr_vucs2, cpr_vutf16, cpr_vunicode, cpr_vunicodec])
            THEN
                BEGIN
                p11precomerror (apc, cpc_datatyp_not_compatible);
                p11nerrorlisting ( apc,
                      vartablep^ [ndtabp^[ndcnt].ndvarentix].vaname,
                      vartablep^ [ndtabp^[ndcnt].ndvarentix].vanaml, 0);
                END;
            (*ENDIF*) 
        (*ENDIF*) 
        IF   (pcerror = cpc_pre_ok)
        THEN
            BEGIN
            paix  := pcpa + 1;
            WITH ndtabp^ [ndcnt] DO
                BEGIN
                IF  ndsqlva1st <> ndsqlva1ix
                THEN
                    BEGIN
                    p19cparentry (apc, sqlparst, ndsqlva1st,
                          0 , ndsqlva1cnt);
                    END;
                (*ENDIF*) 
                p19cparentry (apc, sqlparel,
                      ndsqlva1ix, 0, 0);
                va1ix := ndsqlva1ix;
                END;
            (*ENDWITH*) 
            END;
        (*ENDIF*) 
        END;
    (*ENDWITH*) 
    END;
(*ENDWITH*) 
&ifdef TRACE
m90int2(pc, 'paix        ', paix);
m90name(xx, 'END p14_hostv_get ');
&endif
END;
 
(*------------------------------*) 
 
PROCEDURE
      p14_prind_get  (
            PROCEDURE next_symbol (VAR p1: tpc_globals;
            VAR p2: tpc_partbuffer; p3: integer);
            VAR apc : tpc_globals;
            VAR prind : integer);
 
VAR
      ptypentix : tsp00_Int2;
      pvatyp    : tsp00_Int2;
      lastvatyp : tsp00_Int2;
      statemn   : tsp00_KnlIdentifier;
      paix      : tsp00_Int2;
      ch12      : tsp00_C12;
      no        : integer;
 
BEGIN
WITH apc, sqlxa, pcscan, sqlca, pccmdpart DO
    BEGIN
&   ifdef TRACE
    m90int(pc, 'pcpr        ', pcpr);
&   endif
    WITH  pcsqlva, pcsymtab DO
        BEGIN
        (* statementname in hostvar *)
        (* eliminate parametermarker *)
        paix    := 0;
        statemn := bsp_knl_identifier;
        statemn[1] := ':';
        (*****
              IF  sylen >  sizeof(statemn)
              THEN
              stateml :=  sizeof(statemn)
              ELSE
              stateml := sylen;
              s10mv (sizeof(partbufp^), sizeof(statemn), @partbufp^, sypos,
              @statemn, 1, stateml);
              *******)
        partbufp^ [sypos] := bsp_c1;
        syposacc := sypos+1;
        ptypentix  := 0;
        p14btypentget (next_symbol, apc, ptypentix,
              pvatyp, lastvatyp, cpr_is_true);
        IF   ptypentix = 0
        THEN
            BEGIN
            IF   (pcerror = cpc_pre_ok)
            THEN
                BEGIN
                p11precomerror (apc, cpc_unknown_parametername);
                p11nerrorlisting ( apc,
                      vartablep^ [ndtabp^[ndcnt].ndvarentix].vaname,
                      vartablep^ [ndtabp^[ndcnt].ndvarentix].vanaml, 0);
                END
            (*ENDIF*) 
            END
        ELSE
            IF  NOT (pvatyp in [cpr_vchar..cpr_vbuf,
                cpr_vstring, cpr_vstring1, cpr_vucs2, cpr_vutf16, cpr_vunicode, cpr_vunicodec])
            THEN
                BEGIN
                p11precomerror (apc, cpc_datatyp_not_compatible);
                p11nerrorlisting ( apc,
                      vartablep^ [ndtabp^[ndcnt].ndvarentix].vaname,
                      vartablep^ [ndtabp^[ndcnt].ndvarentix].vanaml, 0);
                END;
            (*ENDIF*) 
        (*ENDIF*) 
        IF   (pcerror = cpc_pre_ok)
        THEN
            BEGIN
            paix  := pcpa + 1;
            WITH ndtabp^ [ndcnt] DO
                BEGIN
                IF  ndsqlva1st <> ndsqlva1ix
                THEN
                    BEGIN
                    p19cparentry (apc, sqlparst, ndsqlva1st,
                          0 , ndsqlva1cnt);
                    END;
                (*ENDIF*) 
                p19cparentry (apc, sqlparel,
                      ndsqlva1ix, 0, 0);
                no := ndsqlva1ix;
                p05inttochr12 (no, ch12);
                s10mv (mxsp_c12, sizeof(statemn), @ch12, 2,
                      @statemn, 2, 4);
                END;
            (*ENDWITH*) 
            END;
        (**    p14_add_prind(apc, prind, paix);   ***)
        (**    sqlprp^[prind].prStmtName := statemn;  ***)
&       ifndef PREPSTMT
        (* execute :stmt wuerde auf alte pr entrys zugreifen *)
        (* hier reicht es in jedem Fall einen neuen zu generieren *)
        (*ENDIF*) 
        p19sstatementprname (apc, statemn, prind);
        IF  prind = 0
        THEN
            BEGIN
            p14_add_prind(apc, prind, paix);
            sqlprp^[prind].prStmtName := statemn;
            END
        ELSE
            sqlprp^[pcpr].prStmtNameIndex := paix;
        (*ENDIF*) 
&       else
        p14_add_prind(apc, prind, paix);
        sqlprp^[prind].prStmtName := statemn;
&       endif
&       ifdef TRACE
        m90int (pc, 'prind       ', prind);
        m90int2(pc, 'paix        ', paix);
        m90int2(pc, 'pcpr        ', pcpr);
        m90name(xx, 'END p14_prind_get ');
&       endif
        END;
    (*ENDWITH*) 
    END;
(*ENDWITH*) 
END;
 
(*------------------------------*) 
 
PROCEDURE
      p14_add_prind  (
            VAR apc : tpc_globals;
            VAR prind : integer;
            VAR paix  : tsp00_Int2);
 
BEGIN
WITH apc, sqlxa, sqlca DO
    BEGIN
&   ifdef TRACE
    m90int (pc, 'pcpr        ', pcpr);
    m90int2(pc, 'paix        ', paix);
&   endif
    p19sqlprallocate (pcpr);
    WITH sqlprp^[pcpr] DO
        BEGIN
        prstcount := 0;
        prstindex := 0;
        prcuindex := 0;
        prstate := cpr_state_empty;
        prStmtName   := bsp_knl_identifier;
        prStmtNameIndex := paix;
        prCursorName := bsp_knl_identifier;
        prCursorNameIndex := 0;
        prkaindex := pcka;
        prarea := cpr_in_sqlva;   (** alt st ***)
        prind := pcpr;
        END;
    (*ENDWITH*) 
    END;
(*ENDWITH*) 
&ifdef TRACE
m90name(xx, 'END p14_add_prind ');
&endif
END;
 
(*------------------------------*) 
 
PROCEDURE
      p14prepare  (
            PROCEDURE next_symbol (VAR p1: tpc_globals;
            VAR p2: tpc_partbuffer; p3: integer);
            VAR apc : tpc_globals);
 
VAR
      statemn : tsp00_KnlIdentifier;
      stateml : integer;
      pos     : integer;
      len     : integer;
      ind     : integer;
      posab   : integer;
      posch   : integer;
      subch   : char;
      err     : tpc_pre_errors;
      ptypentix : tsp00_Int2;
      pvatyp    : tsp00_Int2;
      retpos    : integer;
      keyind    : integer;
      lastvatyp : tsp00_Int2;
      paix      : tsp00_Int2;
      va1ix     : tsp00_Int2;
      kaind     : tsp00_Int2;
      kaindlast : tsp00_Int2;
      ch12      : tsp00_C12;
      no        : integer;
 
BEGIN
WITH apc, sqlxa, pcscan, sqlca, sqlrap^, pccmdpart DO
    BEGIN
    xadescpos := 0;
    xadesclen := 0;
    pcan.ancheck := pcopts.opt_mode;
    pcusage.uscom    := cpc_usage_prep;
    pcusage.usdobjn1 := bsp_knl_identifier;
    pcusage.usdobjn2 := bsp_knl_identifier;
    retpos    := syposacc;
    IF  ralang in [cpr_la_c, cpr_la_cobol]
    THEN
        (* if f?ur umstellung next_symbol *)
        WHILE  (symb <> cpr_s_eof) AND (symb <> cpr_s_bufeof) DO
            next_symbol (apc, partbufp^, part1len);
        (*ENDWHILE*) 
    (*ENDIF*) 
    IF  ralang = cpr_la_cobol
    THEN
        BEGIN
        part1len := part1len + 1;
        partbufp^ [part1len] := cpr_nullchar ;
        END;
    (*ENDIF*) 
    syposacc := retpos;
    symb     := cpr_s_unknown;
    IF   pcerror = cpc_pre_ok
    THEN
        BEGIN
        err := cpc_pre_ok;
&       ifdef TRACE
        m90int (pc, 'pcpr   v    ', pcpr);
        m90int2(pc, 'pcka        ', pcka);
        m90int2(pc, 'ind         ', ind );
&       endif
        p14kaentryinit (apc);
        p19sqlprallocate (pcpr);
&       ifdef TRACE
        m90int (pc, 'pcpr   n    ', pcpr);
        m90int2(pc, 'pcka        ', pcka);
        m90int2(pc, 'ind         ', ind );
&       endif
        WITH sqlkap^ [pcka ] DO
            BEGIN
            kaprindex  := pcpr;
            paix       := 0;
            (** sqlprp^ [pcpr].prStmtNameIndex := 0;***)
            next_symbol (apc, partbufp^, part1len);
            IF   (symb = cpr_s_parameter_name)
                AND (err = cpc_pre_ok)
            THEN
                BEGIN
&               ifdef TRACE
                m90c30(pc, 'in slow version expand hostvar');
&               endif
                ind := pcpr;
                p14_hostv_get (next_symbol, apc, paix, va1ix);
                no := va1ix;
                p05inttochr12 (no, ch12);
                statemn := bsp_knl_identifier;
                statemn[1] := ':';
                s10mv (mxsp_c12, sizeof(statemn), @ch12, 2,
                      @statemn, 2, 4);
&               ifdef TRACE
                m90int (pc, 'pcpr        ', pcpr);
                m90int2(pc, 'pcka        ', pcka);
                m90int2(pc, 'paix        ', paix );
                m90int2(pc, 'va1ix       ', va1ix );
&               endif
                END
            ELSE
                BEGIN
                p19getname (apc, statemn, stateml);
                IF  partbufp^ [sypos-1] <> '"'
                THEN
                    p05up2casebuf (statemn, 1, stateml);
                (*ENDIF*) 
                END;
            (*ENDIF*) 
            p19sprepareprname (apc, statemn, ind);
&           ifdef TRACE
            m90int (pc, 'pcpr        ', pcpr);
            m90int2(pc, 'pcka        ', pcka);
            m90int2(pc, 'ind         ', ind );
&           endif
&           ifndef PREPSTMT
            IF  (ind <> 0)
            THEN
                BEGIN
                IF   (sqlprp^ [ind].prstate = cpr_state_decl_statem)
                    OR  (sqlprp^ [ind].prstate = cpr_state_empty)
                THEN
                    BEGIN
                    pcpr := pcpr - 1;
                    p19setprsqlindex (pcpr);
                    sqlprp^ [ind].prstate := cpr_state_prepare;
                    sqlprp^ [ind].prStmtNameIndex  := paix;
                    kaprindex  := ind;    (** 24.11.94 pcpr;**)
                    (** rueckverwiese describe, decl, open vor preppare *)
                    kaind := sqlprp^ [ind].prkaindex;
                    IF  kaind <> 0
                    THEN
                        BEGIN
                        WHILE (kaind <> 0) DO
                            BEGIN
                            kaindlast := kaind;
                            kaind := sqlkap^[kaind].kadiindex;
                            END;
                        (*ENDWHILE*) 
                        sqlkap^[kaindlast].kadiindex := pcka;
                        END;
                    (*ENDIF*) 
                    END
                ELSE
                    err := cpc_duplicate_statementname;
                (*ENDIF*) 
                END
            ELSE
                BEGIN
                ind := pcpr;
                sqlprp^ [ind ].prkaindex := 0;
                END;
            (*ENDIF*) 
&           else
            ind := pcpr;
            sqlprp^ [ind ].prkaindex := 0;
&           endif
            next_symbol (apc, partbufp^, part1len);
            IF  err = cpc_pre_ok
            THEN
                WITH sqlxa, sqlprp^ [ind ] DO
                    BEGIN
                    prstate:= cpr_state_prepare;
                    prarea := cpr_in_sqlva;
                    prStmtNameIndex := paix;
                    (**** 29.07.96****)
                    IF  prkaindex = 0
                    THEN
                        prkaindex := pcka;
                    (*ENDIF*) 
                    prDescribe := cpr_is_false;
                    prStmtName     := statemn;
                    prcuindex  := 0;
                    (* into or from *)
                    p10getkeyword (apc, partbufp^, keyind);
                    IF   keyind = cpc_i_into
                    THEN
                        BEGIN
                        xakano := pcka;
                        next_symbol (apc, partbufp^, part1len);
                        xadescpos := sypos;
                        WHILE  (keyind  <> cpc_i_using) AND
                              (keyind  <> cpc_i_from) AND
                              (symb <> cpr_s_eof) AND (symb <> cpr_s_bufeof) DO
                            BEGIN
                            xadesclen := syposacc - xadescpos;
                            next_symbol (apc, partbufp^, part1len);
                            p10getkeyword (apc, partbufp^, keyind);
                            END;
                        (*ENDWHILE*) 
                        IF   keyind = cpc_i_using
                        THEN
                            BEGIN
                            next_symbol (apc, partbufp^, part1len);
                            p10getkeyword (apc, partbufp^, keyind);
                            IF   (keyind <>  cpc_i_names)
                                AND (keyind <>  cpc_i_labels)
                                AND (keyind <>  cpc_i_any)
                            THEN
                                p11precomerror (apc, cpc_pre_not_implemented);
                            (*ENDIF*) 
                            next_symbol (apc, partbufp^, part1len);
                            END;
                        (*ENDIF*) 
                        p10getkeyword (apc, partbufp^, keyind);
                        END;
                    (*ENDIF*) 
                    IF   keyind = cpc_i_from
                    THEN
                        next_symbol (apc, partbufp^, part1len);
                    (*ENDIF*) 
                    END;
                (*ENDWITH*) 
            (*ENDIF*) 
            END;
        (*ENDWITH*) 
        WITH  sqlprp^ [ind ],  sqlkap^ [pcka ],
             pcsqlva, pcsymtab DO
            BEGIN
            (** statement **)
            IF  ((symb = cpr_s_parameter_name)
                OR   (symb = cpr_s_identifier)) {Horst,29.10.96, PTS 2606 }
                AND (err = cpc_pre_ok)
            THEN
                BEGIN
                (* statement in variabler *)
                IF  (symb = cpr_s_parameter_name)
                THEN
                    syposacc := sypos+1
                ELSE                       {Horst,29.10.96, PTS 2606 }
                    syposacc := sypos;
                (*ENDIF*) 
                ptypentix  := 0;
                p14btypentget (next_symbol, apc, ptypentix,
                      pvatyp, lastvatyp, cpr_is_true);
                IF   ptypentix = 0
                THEN
                    BEGIN
                    IF   (pcerror = cpc_pre_ok)
                    THEN
                        BEGIN
                        p11precomerror (apc, cpc_unknown_parametername);
                        p11nerrorlisting ( apc,
                              vartablep^ [ndtabp^[ndcnt].ndvarentix].vaname,
                              vartablep^[ndtabp^[ndcnt].ndvarentix].vanaml,0);
                        END
                    (*ENDIF*) 
                    END
                ELSE
                    IF  NOT (pvatyp in [cpr_vchar..cpr_vbuf,
                        cpr_vstring, cpr_vstring1, cpr_vunicode ,cpr_vunicodec,
                        cpr_vucs2, cpr_vutf16])
                    THEN
                        BEGIN
                        p11precomerror (apc, cpc_datatyp_not_compatible);
                        p11nerrorlisting ( apc,
                              vartablep^ [ndtabp^[ndcnt].ndvarentix].vaname,
                              vartablep^[ndtabp^[ndcnt].ndvarentix].vanaml,0);
                        END;
                    (*ENDIF*) 
                (*ENDIF*) 
                kaStcount := 0;
                kaStindex := pcpa + 1;
                prstcount := 0;
                prstindex := kaStindex;
                prcuindex := 0;
                prCursorName := bsp_knl_identifier;  (*BF*)
                prCursorNameIndex := 0;
                prStmtName   := statemn;
                WITH ndtabp^ [ndcnt] DO
                    BEGIN
                    IF  ndsqlva1st <> ndsqlva1ix
                    THEN
                        BEGIN
                        p19cparentry (apc, sqlparst, ndsqlva1st,
                              0 , ndsqlva1cnt);
                        kaStcount := 1;
                        END;
                    (*ENDIF*) 
                    p19cparentry (apc, sqlparel,
                          ndsqlva1ix, 0, 0);
                    kaStcount := kaStcount + 1;
                    END;
                (*ENDWITH*) 
                END
            ELSE
                IF   NOT  (((symb = cpr_s_string_literal)  OR
                    (symb = cpr_s_cstring_literal))
                    AND (err = cpc_pre_ok))
                THEN
                    BEGIN
                    IF   err = cpc_pre_ok
                    THEN
                        err := cpc_invalid_parametername
                    (*ENDIF*) 
                    END
                ELSE
                    BEGIN
                    (* prepare statement als string *)
                    p10stringliteralget (apc, partbufp^);
                    posab := sypos;
                    posch := 1;
                    WHILE (posch <> 0) DO
                        BEGIN
                        p19snextsubchar (apc, posab, posch, subch);
                        IF   (posch <> 0) AND (subch <> cpr_preparechr)
                        THEN
                            err := cpc_only_question_marks_allowed;
                        (*ENDIF*) 
                        posab := posch + 1;
                        END;
                    (*ENDWHILE*) 
                    IF   err = cpc_pre_ok
                    THEN
                        BEGIN
                        kaStindex := pcst + 1;
                        prstindex := kaStindex;
                        prarea     := cpr_in_sqlst;
                        prStmtName   := statemn;
                        prCursorName := bsp_knl_identifier;  (*BF*)
                        prCursorNameIndex := 0;  (*BF*)
                        prcuindex  := 0;
                        pos := sypos;
                        WHILE pos <  sypos + sylen  DO
                            BEGIN
                            IF   pos + mxpr_sqlline
                                > sypos + sylen
                            THEN
                                len := sypos + sylen - pos
                            ELSE
                                len := mxpr_sqlline;
                            (*ENDIF*) 
                            p19sqlstallocate (pcst);
                            IF  pcst > pcstmax
                            THEN
                                pcstmax := pcst;
                            (*ENDIF*) 
                            kaStcount := kaStcount + 1;
                            prstcount := kaStcount;
                            s10mv (partsizlen,mxpr_sqlline,
                                  @partbufp^, pos,
                                  @sqlstp^ [pcst].stline, 1, len);
                            sqlstp^ [pcst].stllen  := len;
                            sqlstp^ [pcst].stkano := pcka;
                            pos := pos + len;
                            END;
                        (*ENDWHILE*) 
                        END;
                    (*ENDIF*) 
                    END;
                (*ENDIF*) 
            (*ENDIF*) 
            END;
        (*ENDWITH*) 
        IF   err <> cpc_pre_ok
        THEN
            p11precomerror (apc, err);
        (*ENDIF*) 
        END;
    (*ENDIF*) 
    symb := cpr_s_eof;
&   ifdef TRACE
    m90int2 (pc, 'xakano      ', xakano   );
    m90int2 (pc, 'xadescpos   ', xadescpos);
    m90int2 (pc, 'xadesclen   ', xadesclen);
&   endif
    END;
(*ENDWITH*) 
&ifdef TRACE
m90name(xx, 'END   p14prepa    ');
&endif
END;
 
(*------------------------------*) 
 
PROCEDURE
      p14execute  (
            PROCEDURE next_symbol (VAR p1: tpc_globals;
            VAR p2: tpc_partbuffer; p3: integer);
            VAR apc : tpc_globals;
            VAR statemno : integer;
            VAR immediate: integer);
 
VAR
      statemn : tsp00_KnlIdentifier;
      stateml : integer;
      keyind  : integer;
      prind   : integer;
      posab   : integer;
      pos     : integer;
      len     : integer;
      posch   : integer;
      mnr     : integer;
      subch   : char;
      err     : tpc_pre_errors;
      ptypentix : tsp00_Int2;
      pvatyp    : tsp00_Int2;
      kaind     : tsp00_Int2;
      retpos    : tsp00_Int2;
      lastvatyp : tsp00_Int2;
      ndindex   : integer;
 
BEGIN
WITH apc, pcscan, sqlca, sqlrap^, pccmdpart, sqlxa, pcsqlva  DO
    BEGIN
    retpos    := syposacc;
    xadescpos := 0;
    xadesclen := 0;
    IF  ralang in [cpr_la_c, cpr_la_cobol]
    THEN
        (* if f?ur umstellung next_symbol *)
        WHILE  (symb <> cpr_s_eof) AND (symb <> cpr_s_bufeof) DO
            next_symbol (apc, partbufp^, part1len);
        (*ENDWHILE*) 
    (*ENDIF*) 
    IF  ralang = cpr_la_cobol
    THEN
        BEGIN
        part1len := part1len + 1;
        partbufp^ [part1len] := cpr_nullchar ;
        END;
    (*ENDIF*) 
    syposacc := retpos;
    symb     := cpr_s_unknown;
    IF   pcerror = cpc_pre_ok
    THEN
        BEGIN
        err := cpc_pre_ok;
        IF  err = cpc_pre_ok
        THEN
            BEGIN
            immediate := cpc_imm_no;
            next_symbol (apc, partbufp^, part1len);
            p10getkeyword (apc, partbufp^, keyind);
            IF   keyind = cpc_i_immediate
            THEN
                BEGIN
                p14kaentryinit (apc);
                p19sqlprallocate (pcpr);
                p19sqlfaallocate (pcfa);
                statemno := pcka;
                WITH sqlxa.sqlprp^ [pcpr] ,
                     sqlxa.sqlkap^ [pcka ], sqlxa, pcsqlva, pcsymtab DO
                    BEGIN
                    prstcount := 0;
                    prstindex := 0;
                    prcuindex := 0;
                    prstate:= cpr_state_prepare;
                    prStmtName   := bsp_knl_identifier;
                    prStmtNameIndex := 0;
                    prCursorName := bsp_knl_identifier;
                    prCursorNameIndex := 0;
                    prkaindex := pcka;
                    prarea     := cpr_in_sqlva;
                    prDescribe := cpr_is_false;
                    kaprindex  := pcpr;
                    kafaindex  := pcfa;
                    next_symbol (apc, partbufp^, part1len);
                    IF   symb = cpr_s_parameter_name
                    THEN
                        BEGIN
                        (* variable *)
                        immediate := cpc_imm_variable;
                        syposacc := sypos + 1;
                        ptypentix := 0;
                        p14btypentget (next_symbol, apc, ptypentix,
                              pvatyp, lastvatyp, cpr_is_true);
                        IF   ptypentix = 0
                        THEN
                            BEGIN
                            IF   (pcerror = cpc_pre_ok)
                            THEN
                                BEGIN
                                p11precomerror(apc,cpc_unknown_parametername);
                                p11nerrorlisting ( apc,
                                      vartablep^ [ndtabp^[ndcnt]
                                      .ndvarentix].vaname,
                                      vartablep^ [ndtabp^[ndcnt]
                                      .ndvarentix].vanaml, 0);
                                END
                            (*ENDIF*) 
                            END
                        ELSE
                            BEGIN
                            WITH ndtabp^ [ndcnt] DO
                                BEGIN
                                kaStindex := pcpa + 1;
                                IF  ndsqlva1st <> ndsqlva1ix
                                THEN
                                    p19cparentry(apc,sqlparst, ndsqlva1st,
                                          0 , ndsqlva1cnt);
                                (*ENDIF*) 
                                p19cparentry (apc, sqlparel,
                                      ndsqlva1ix, 0, 0);
                                END;
                            (*ENDWITH*) 
                            END;
                        (*ENDIF*) 
                        END
                    ELSE
                        BEGIN
                        (* stringconstante *)
                        p10stringliteralget (apc, partbufp^); (*PETER*)
                        immediate := cpc_imm_string;
                        SAPDB_PascalForcedFill (partsizlen, @partbufp^, 1,
                              sypos-1, bsp_c1);
                        posab := sypos;
                        posch := 1;
                        WHILE (posch <> 0) DO
                            BEGIN
                            p19snextsubchar (apc, posab, posch, subch);
                            IF   subch = cpr_macrochr
                            THEN
                                BEGIN
                                kamacro := cpr_is_true;
                                p19gmacronumber (apc, posch, mnr, posch);
                                err := cpc_macros_not_allowed;
                                END;
                            (*ENDIF*) 
                            posab := posch + 1;
                            END;
                        (*ENDWHILE*) 
                        prarea     := cpr_in_sqlst;
                        kaStcount := 0;
                        kaStindex := pcst + 1;
                        pos := sypos;
                        WHILE pos <  sypos + sylen  DO
                            BEGIN
                            IF   pos + mxpr_sqlline
                                > sypos + sylen
                            THEN
                                len := sypos + sylen - pos
                            ELSE
                                len := mxpr_sqlline;
                            (*ENDIF*) 
                            p19sqlstallocate (pcst);
                            IF  pcst > pcstmax
                            THEN
                                pcstmax := pcst;
                            (*ENDIF*) 
                            kaStcount := kaStcount + 1;
                            s10mv (partsizlen,mxpr_sqlline,
                                  @partbufp^, pos,
                                  @sqlstp^ [pcst] .stline, 1, len);
                            sqlstp^ [pcst].stllen  := len;
                            sqlstp^ [pcst].stkano := pcka;
                            pos := pos + len;
                            END;
                        (*ENDWHILE*) 
                        syposacc := sypos;
                        next_symbol (apc, partbufp^, part1len);
                        p10getkeyword (apc, partbufp^, keyind);
                        IF   keyind = cpc_i_connect
                        THEN
                            pcan.ancomtyp := cpr_com_sql_conn;
                        (*ENDIF*) 
                        END;
                    (*ENDIF*) 
                    IF  err = cpc_pre_ok
                    THEN
                        pcan.ancheck := pcopts.opt_mode;
                    (*ENDIF*) 
                    sqlxa.xakano := pcka;
                    END
                (*ENDWITH*) 
                END
            ELSE
                BEGIN
                (* execute using *)
                ndindex := 0;
                IF   (symb = cpr_s_parameter_name)
                    AND (err = cpc_pre_ok)
                THEN
                    BEGIN
&                   ifdef TRACE
                    m90buf (pc, partbufp^ [1], 1 , part1len );
                    m90int2 (pc, 'syposacc    ', syposacc);
                    m90int2 (pc, 'sypos       ', sypos);
&                   endif
                    p14_prind_get (next_symbol, apc, prind);
                    ndindex := ndcnt;
                    END
                ELSE
                    BEGIN
                    p19getname (apc, statemn, stateml);
                    IF  partbufp^ [sypos-1] <> '"'
                    THEN
                        p05up2casebuf (statemn, 1, stateml);
                    (*ENDIF*) 
                    p19sstatementprname (apc, statemn, prind);
&                   ifdef TRACE
                    m90int2 (pc, 'prind       ', prind    );
&                   endif
                    next_symbol (apc, partbufp^, part1len);
                    END;
                (*ENDIF*) 
                IF   prind = 0
                THEN
                    err := cpc_unknown_statementname
                ELSE
                    BEGIN
&                   ifdef TRACE
                    m90int2 (pc, 'prind       ', prind    );
                    m90int2 (pc, 'pcka        ', pcka );
                    m90int2 (pc, 'prStmtNameIn', sqlprp^[prind].prStmtNameIndex );
&                   endif
                    IF  sqlprp^[prind].prStmtNameIndex > 0
                    THEN
                        BEGIN
                        p14kaentryinit (apc);
&                       ifdef TRACE
                        m90int2 (pc, 'pcka        ', pcka );
&                       endif
                        WITH sqlkap^[pcka] DO
                            BEGIN
                            kaind := pcka;
                            kaprindex  := prind;
                            END;
                        (*ENDWITH*) 
                        END
                    ELSE
                        kaind := sqlprp^ [prind] .prkaindex;
                    (*ENDIF*) 
&                   ifdef TRACE
                    m90int2 (pc, 'kaind       ', kaind    );
&                   endif
                    IF   symb = cpr_s_eof
                    THEN
                        BEGIN
                        (* without parameter *)
                        p14kaentryinit (apc);
                        p19sqlfaallocate (pcfa);
                        statemno     := pcka;
                        sqlkap^ [pcka ] :=  sqlkap^ [kaind ];
                        WITH sqlxa.sqlkap^ [pcka ] DO
                            BEGIN
                            katyp  := pcan.ancomtyp;
                            kapaindex := 0;
                            IF  pcinpind = cpc_inputfile
                            THEN
                                kalineno   := pclno.lnosrc
                            ELSE
                                kalineno   := - pclno.lnoexp;
                            (*ENDIF*) 
                            kamode    := rakamode;
                            kaatindex := pckaatind;
                            kacuindex := 0;
                            pcan.ancheck := pcopts.opt_mode;
                            pcda  := mxpr_sqln;
                            sqlxa.sqlprp^ [prind] .prDescribe :=
                                  cpr_is_true;
                            (* verweiss auf same prepare stm *)
                            sqlxa.sqlprp^ [prind] .prkaindex := pcka;
                            kadiindex := kaind;
                            kafaindex  := pcfa;
                            END;
                        (*ENDWITH*) 
                        END
                    ELSE
                        BEGIN
                        (* using *)
                        p10getkeyword (apc, partbufp^, keyind);
                        IF   keyind = cpc_i_using
                        THEN
                            BEGIN
                            next_symbol (apc, partbufp^, part1len);
                            p10getkeyword (apc, partbufp^, keyind);
                            IF   keyind = cpc_i_descriptor
                            THEN
                                BEGIN
                                p14kaentryinit (apc);
                                p19sqlfaallocate (pcfa);
                                statemno     := pcka;
                                sqlkap^ [pcka ] :=  sqlkap^ [kaind ];
                                WITH sqlxa.sqlkap^ [pcka ] DO
                                    BEGIN
                                    katyp  := pcan.ancomtyp;
                                    kapacount := -1;
                                    kapaindex := 0;
                                    IF  pcinpind = cpc_inputfile
                                    THEN
                                        kalineno   := pclno.lnosrc
                                    ELSE
                                        kalineno   := - pclno.lnoexp;
                                    (*ENDIF*) 
                                    kamode    := rakamode;
                                    kaatindex := pckaatind;
                                    kacuindex := 0;
                                    pcan.ancheck := pcopts.opt_mode;
                                    pcda  := mxpr_sqln;
                                    sqlxa.sqlprp^ [prind] .prDescribe :=
                                          cpr_is_true;
                                    (* verweiss auf same prepare stm *)
                                    sqlxa.sqlprp^ [prind] .prkaindex := pcka;
                                    kadiindex := kaind;
                                    kafaindex  := pcfa;
                                    END;
                                (*ENDWITH*) 
                                next_symbol (apc, partbufp^, part1len);
                                IF   symb <> cpr_s_eof
                                THEN
                                    BEGIN
                                    IF  partbufp^ [sypos] = cpr_paramchr
                                    THEN
                                        xadescpos := sypos + 1
                                    ELSE
                                        xadescpos := sypos;
                                    (*ENDIF*) 
                                    WHILE  (symb <> cpr_s_eof) AND
                                          (symb <> cpr_s_bufeof) DO
                                        BEGIN
                                        xadesclen := syposacc - xadescpos;
                                        next_symbol (apc, partbufp^,
                                              part1len);
                                        END;
                                    (*ENDWHILE*) 
                                    END
                                ELSE
                                    BEGIN
                                    IF  (rakamode = cpr_kind_internal)
                                    THEN
                                        (* default sqldb sqlda expansion *)
                                        xadescpos := -1
                                    ELSE
                                        err := cpc_invalid_sql_command;
                                    (*ENDIF*) 
                                    END;
                                (*ENDIF*) 
                                END
                            ELSE
                                IF   symb <> cpr_s_parameter_name
                                THEN
                                    err := cpc_invalid_parametername
                                ELSE
                                    BEGIN
                                    p14an1sqlstatement (next_symbol, apc);
                                    statemno     := pcka;
                                    sqlxa.xakano := pcka;
                                    sqlkap^ [pcka] .kaprindex := prind;
                                    sqlkap^ [pcka] .kaStcount:=
                                          sqlkap^ [kaind] .kaStcount;
                                    sqlkap^ [pcka] .kaStindex:=
                                          sqlkap^ [kaind] .kaStindex;
                                    (* verweiss auf same prepare stm *)
                                    sqlprp^ [prind] .prkaindex := pcka;
                                    sqlkap^ [pcka] .kadiindex := kaind;
                                    p19sqlfaallocate (pcfa);
                                    sqlkap^ [pcka] .kafaindex  := pcfa;
                                    IF  ndindex > 0
                                    THEN
                                        ndtabp^ [ndindex].ndkano := pcka;
                                    (*ENDIF*) 
                                    END
                                (*ENDIF*) 
                            (*ENDIF*) 
                            END
                        ELSE
                            err := cpc_invalid_sql_command;
                        (*ENDIF*) 
                        END;
                    (*ENDIF*) 
                    END;
                (*ENDIF*) 
                END;
            (*ENDIF*) 
            END;
        (*ENDIF*) 
        IF   err <> cpc_pre_ok
        THEN
            p11precomerror (apc, err);
        (*ENDIF*) 
        END;
&   ifdef TRACE
    (*ENDIF*) 
    m90int2 (pc, 'xakano      ', xakano   );
    m90int2 (pc, 'xadescpos   ', xadescpos);
    m90int2 (pc, 'xadesclen   ', xadesclen);
&   endif
    symb := cpr_s_eof;
    END;
(*ENDWITH*) 
&ifdef TRACE
m90name(xx, 'END p14execute    ');
&endif
END;
 
(*------------------------------*) 
 
PROCEDURE
      p14declare  (
            PROCEDURE next_symbol (VAR p1: tpc_globals;
            VAR p2: tpc_partbuffer; p3: integer);
            VAR apc : tpc_globals;
            VAR keyindex : integer;
            VAR statemno : integer);
 
VAR
      statemn : tsp00_KnlIdentifier;
      stateml : integer;
      cursorn : tsp00_KnlIdentifier;
      cursorl : integer;
      keyind  : integer;
      ind     : integer;
      kaind   : integer;
      macro  : tsp00_Int2;
&     ifdef PREPSTMT
      param  : tsp00_Int2;
      va1ix     : tsp00_Int2;
      ch12      : tsp00_C12;
      no        : integer;
      rscan  : tpr_scannertype;
      StmtNameIndex  : tsp00_Int2;
&     endif
      retcom : tsp00_Int2;
      withhold : boolean;
      ndindex  : integer;
      ndcuindex  : integer;
      CursorNameIndex  : tsp00_Int2;
      retStmtNameIndex  : tsp00_Int2;
 
BEGIN
WITH apc, pcscan, sqlca, sqlrap^, pccmdpart, pcsqlva DO
    BEGIN
    ndindex  := 0;
    keyindex := 0;
    withhold := false;
    IF   pcerror = cpc_pre_ok
    THEN
        BEGIN
        p19sqlprallocate (pcpr);
        next_symbol (apc, partbufp^, part1len);
        p10getkeyword (apc, partbufp^, keyind);
        keyindex := keyind;
        IF  keyind <> cpc_i_table
        THEN
            BEGIN
            p14getname (next_symbol, apc, cursorn, cursorl, macro
&                 ifdef PREPSTMT
                  , param
&                 endif
                  );
            WITH sqlxa, sqlprp^ [pcpr ] DO
                BEGIN
                prstcount := 0;
                prstindex := 0;
                prcuindex := 0;
                prCursorName := bsp_knl_identifier;  (*BF*)
                prCursorNameIndex := 0;
                prStmtName   := bsp_knl_identifier;    (*BD*)
                prStmtNameIndex := 0;
                prstate    := cpr_state_command;
                prarea     := cpr_in_sqlva;
                prkaindex := 0;
                prDescribe := cpr_is_false;
&               ifdef PREPSTMT
                IF   (param = cpr_is_true)
                THEN
                    BEGIN
                    ind := pcpr;
                    rscan := pcscan;
                    p14_hostv_get (next_symbol, apc, CursorNameIndex, va1ix);
                    no := va1ix;
                    p05inttochr12 (no, ch12);
                    cursorn := bsp_knl_identifier;
                    cursorn[1] := ':';
                    s10mv (mxsp_c12, sizeof(cursorn), @ch12, 2,
                          @cursorn, 2, 4);
                    pcscan := rscan;
                    (* PTS 1104482 *)
                    ndcuindex := ndcnt;
                    END
                ELSE
                    BEGIN
                    CursorNameIndex := 0;
                    ndcuindex := 0;
                    END;
                (*ENDIF*) 
&               endif
                next_symbol (apc, partbufp^, part1len);
                p10getkeyword (apc, partbufp^, keyind);
                keyindex := keyind;
                IF  ( keyind = cpc_i_database )  AND
                    ( ( rakamode = cpr_kind_oracle ) OR
                    ( rakamode = cpr_kind_sapr3 ) )
                THEN
                    BEGIN
                    pcpr := pcpr - 1;
                    p19setprsqlindex (pcpr);
                    p14batdatabase (apc, cursorn);
                    END
                ELSE
                    IF   keyind =   cpc_i_statement
                    THEN
                        BEGIN
                        prstate  := cpr_state_decl_statem;
                        prStmtName   := cursorn;
                        END
                    ELSE
                        BEGIN
                        IF   keyind <>  cpc_i_cursor
                        THEN
                            BEGIN
                            pcpr := pcpr - 1;
                            p19setprsqlindex (pcpr);
                            p11precomerror (apc, cpc_invalid_sql_command);
                            END
                        ELSE
                            BEGIN
                            (* for or with hold *)
                            next_symbol (apc, partbufp^, part1len);
                            p10getkeyword (apc, partbufp^, keyind);
                            IF  (keyind <> cpc_i_for)
                            THEN
                                BEGIN
                                p10getkeyword (apc, partbufp^, keyind);
                                IF  (keyind <> cpc_i_with)
                                THEN
                                    p11precomerror (apc,
                                          cpc_invalid_sql_command);
                                (*  hold  *)
                                (*ENDIF*) 
                                next_symbol (apc, partbufp^, part1len);
                                p10getkeyword (apc, partbufp^, keyind);
                                IF  (keyind <> cpc_i_hold)
                                THEN
                                    p11precomerror (apc,
                                          cpc_invalid_sql_command);
                                (* for  *)
                                (*ENDIF*) 
                                next_symbol (apc, partbufp^, part1len);
                                p10getkeyword (apc, partbufp^, keyind);
                                IF  (keyind <> cpc_i_for)
                                THEN
                                    p11precomerror (apc,
                                          cpc_invalid_sql_command);
                                (*ENDIF*) 
                                withhold := true;
                                IF  rakamode <> cpr_kind_db2
                                THEN
                                    p11precomerror (apc,
                                          cpc_invalid_sql_command);
                                (*ENDIF*) 
                                END;
                            (*ENDIF*) 
                            next_symbol (apc, partbufp^, part1len);
                            p10getkeyword (apc, partbufp^, keyind);
                            IF  (keyind = cpc_i_select)
                                OR (keyind = cpc_i_with)
                                OR  (symb = cpr_s_leftpar)
                                OR  (symb = cpr_s_leftindpar)
                            THEN
                                BEGIN
                                (* select statement als string *)
                                pcan.ancheck := cpc_ch_no;
                                retcom := pcan.ancomtyp;
                                pcan.ancomtyp := cpr_com_declare_cursor;
                                p14an1sqlstatement (next_symbol, apc);
                                pcan.ancomtyp := retcom;
                                pcan.ancheck := pcopts.opt_mode;
                                statemno := pcka;
                                sqlkap^ [pcka] .katyp     := retcom;
                                sqlkap^ [pcka] .kaprindex := pcpr;
                                sqlkap^ [pcka] .kamacro   := macro;
                                prkaindex := pcka;
                                prarea     := cpr_in_sqlst;
                                prStmtNameIndex := 0;
                                prCursorName  := cursorn;
                                prCursorNameIndex := CursorNameIndex;
                                p14putsqlstarea (apc);
                                END
                            ELSE
                                BEGIN
                                (* statement name *)
                                IF   (symb = cpr_s_parameter_name)
                                THEN
                                    BEGIN
&                                   ifdef PREPSTMT
                                    rscan := pcscan;
                                    p14_hostv_get (next_symbol, apc, StmtNameIndex, va1ix);
                                    no := va1ix;
                                    p05inttochr12 (no, ch12);
                                    statemn := bsp_knl_identifier;
                                    statemn[1] := ':';
                                    s10mv (mxsp_c12, sizeof(statemn), @ch12, 2,
                                          @statemn, 2, 4);
                                    pcscan := rscan;
                                    ndindex := ndcnt;
&                                   else
                                    p14_prind_get (next_symbol, apc, ind);
                                    ndindex := ndcnt;
&                                   endif
                                    END
                                ELSE
                                    BEGIN
                                    ndindex := 0;
                                    p19getname (apc, statemn, stateml);
                                    IF  partbufp^ [sypos-1] <> '"'
                                    THEN
                                        p05up2casebuf (statemn,1,stateml);
                                    (*ENDIF*) 
                                    p19sprepareprname (apc, statemn, ind);
&                                   ifdef PREPSTMT
                                    StmtNameIndex := 0;
&                                   endif
                                    END;
                                (*ENDIF*) 
                                IF   ind = 0
                                THEN
                                    p11precomerror (apc,
                                          cpc_unknown_statementname)
                                ELSE
                                    BEGIN
&                                   ifdef PREPSTMT
                                    p14kaentryinit (apc);
                                    statemno := pcka;
                                    prCursorName := cursorn;
                                    prCursorNameIndex := CursorNameIndex;
                                    prStmtName := statemn;
                                    prStmtNameIndex := StmtNameIndex;
                                    IF  withhold
                                    THEN
                                        prstate:= cpr_state_decl_with_hold
                                    ELSE
                                        prstate := cpr_state_command;
                                    (*ENDIF*) 
                                    prkaindex :=  pcka;
                                    sqlkap^ [pcka] .kaprindex := pcpr;
                                    sqlkap^ [pcka] .kamacro   := macro;
                                    sqlkap^ [pcka] .kapacount:= 0;
                                    IF  pcinpind = cpc_inputfile
                                    THEN
                                        sqlkap^ [pcka] .kalineno
                                              := pclno.lnosrc
                                    ELSE
                                        sqlkap^ [pcka] .kalineno
                                              := - pclno.lnoexp;
                                    (*ENDIF*) 
                                    sqlprp^ [pcpr] .prcuindex := ind;
                                    sqlkap^ [pcka] .kafaindex := 0;
                                    (* PTS 1104482 *)
                                    IF  ndcuindex > 0
                                    THEN
                                        ndtabp^ [ndcuindex].ndkano := pcka;
                                    (*ENDIF*) 
                                    IF  ndindex > 0
                                    THEN
                                        ndtabp^ [ndindex].ndkano := pcka;
&                                   else
                                    (*ENDIF*) 
                                    p14kaentryinit (apc);
                                    retStmtNameIndex := sqlprp^ [pcpr ].prStmtNameIndex;
                                    sqlprp^ [pcpr ] := sqlprp^ [ind] ;
                                    sqlprp^ [pcpr ].prStmtNameIndex := retStmtNameIndex;
&                                   ifdef TRACE
                                    m90int2 (pc, 'retStmtNameI', retStmtNameIndex );
                                    m90int2 (pc, 'pcpr        ', pcpr );
                                    m90int2 (pc, 'ind         ', ind  );
                                    m90int2 (pc, 'prkaindex   ',
                                          sqlprp^ [pcpr] .prkaindex );
                                    m90int2 (pc, 'pcka        ', pcka );
&                                   endif
                                    statemno := pcka;
                                    prCursorName := cursorn;
                                    prCursorNameIndex := CursorNameIndex;
                                    IF  withhold
                                    THEN
                                        prstate:= cpr_state_decl_with_hold
                                    ELSE
                                        prstate := cpr_state_command;
                                    (*ENDIF*) 
                                    kaind   := sqlprp^ [pcpr] .prkaindex;
                                    prkaindex :=  pcka;
                                    IF  kaind = 0
                                    THEN
                                        WITH sqlkap^ [pcka ] DO
                                            BEGIN
                                            kaind   := pcka;
                                            kaprindex  := pcpr;
                                            END
                                        (*ENDWITH*) 
                                    ELSE
                                        BEGIN
                                        sqlkap^ [pcka] .kadiindex := kaind;
                                        sqlkap^ [pcka ] := sqlkap^ [kaind] ;
                                        END;
                                    (*ENDIF*) 
                                    sqlkap^ [pcka] .kaprindex := pcpr;
                                    sqlkap^ [pcka] .kamacro   := macro;
                                    sqlkap^ [pcka] .kapacount:= 0;
                                    IF  pcinpind = cpc_inputfile
                                    THEN
                                        sqlkap^ [pcka] .kalineno
                                              := pclno.lnosrc
                                    ELSE
                                        sqlkap^ [pcka] .kalineno
                                              := - pclno.lnoexp;
                                    (*ENDIF*) 
                                    (* verweiss auf same prepare stm *)
                                    sqlprp^ [ind] .prkaindex := pcka;
                                    IF  pcka <> kaind
                                    THEN
                                        sqlkap^ [pcka].kadiindex := kaind;
                                    (****
                                          **20.6.96**
                                          IF  sqlkap^ [pcka].kadiindex = 0
                                          THEN
                                          sqlprp^ [pcpr] .prcuindex := ind;
                                          ***end******)
                                    (*ENDIF*) 
                                    sqlprp^ [pcpr] .prcuindex := ind;
                                    sqlkap^ [pcka] .kafaindex := 0;
                                    IF  ndindex > 0
                                    THEN
                                        ndtabp^ [ndindex].ndkano := pcka;
&                                   endif
                                    (*ENDIF*) 
                                    END;
                                (*ENDIF*) 
                                END;
                            (*ENDIF*) 
                            p14bcudeclare ( apc, cursorn );
                            END;
                        (*ENDIF*) 
                        END;
                    (*ENDIF*) 
                (*ENDIF*) 
                END;
            (*ENDWITH*) 
            END;
        (*ENDIF*) 
        END;
    (*ENDIF*) 
    WHILE  (symb <> cpr_s_eof) AND (symb <> cpr_s_bufeof) DO
        next_symbol (apc, partbufp^, part1len);
    (*ENDWHILE*) 
    END;
(*ENDWITH*) 
&ifdef TRACE
m90name(xx, 'END   p14decla    ');
&endif
END;
 
(*------------------------------*) 
 
PROCEDURE
      p14describe (
            PROCEDURE next_symbol (VAR p1: tpc_globals;
            VAR p2: tpc_partbuffer; p3: integer);
            VAR apc : tpc_globals);
 
VAR
      keyind : integer;
      ind    : integer;
      staten : tsp00_KnlIdentifier;
      statel : integer;
      orakatyp : tsp00_Int2;
      ndindex  : integer;
 
BEGIN
WITH apc, pcscan, sqlca, sqlrap^, pccmdpart, sqlxa, pcsqlva DO
    BEGIN
    xadescpos := 0;
    xadesclen := 0;
    IF   pcerror = cpc_pre_ok
    THEN
        BEGIN
        next_symbol (apc, partbufp^, part1len);
        orakatyp := cpr_com_empty;
        IF  (rakamode = cpr_kind_oracle)
            OR  (rakamode = cpr_kind_sapr3 )
        THEN
            p14oradescribe (next_symbol, apc, orakatyp);
        (*ENDIF*) 
        IF   (symb = cpr_s_parameter_name)
            AND (pcerror = cpc_pre_ok)
        THEN
            BEGIN
            p14_prind_get (next_symbol, apc, ind);
            ndindex := ndcnt;
            END
        ELSE
            BEGIN
            ndindex := 0;
            p19getname (apc, staten, statel);
            IF  partbufp^ [sypos-1] <> '"'
            THEN
                p05up2casebuf (staten, 1, statel);
            (*ENDIF*) 
            p19sstatementprname (apc, staten, ind);
            next_symbol (apc, partbufp^, part1len);
            END;
        (*ENDIF*) 
        IF   ind = 0
        THEN
            p19scursorprname (apc, staten, ind);
        (*ENDIF*) 
        IF   ind = 0
        THEN
            p11precomerror (apc, cpc_unknown_statementname)
        ELSE
            WITH sqlxa, sqlprp^ [ind ] DO
                BEGIN
                p14kaentryinit (apc);
                pcda    := mxpr_sqln;
                IF   prkaindex = 0
                THEN
                    BEGIN
                    (* ka_eintrag generieren *)
                    prkaindex := pcka;
                    (* init sqlka-entry *)
                    WITH sqlkap^ [prkaindex ] DO
                        BEGIN
                        IF  orakatyp = cpr_com_empty
                        THEN
                            katyp   := pcan.ancomtyp
                        ELSE
                            katyp   := orakatyp;
                        (*ENDIF*) 
                        kaprindex  := ind;
                        kapacount := -3;
                        END;
                    (*ENDWITH*) 
                    END
                ELSE
                    BEGIN
                    sqlkap^ [pcka] := sqlkap^ [prkaindex];
                    IF  orakatyp = cpr_com_empty
                    THEN
                        sqlkap^ [pcka].katyp   := pcan.ancomtyp
                    ELSE
                        sqlkap^ [pcka].katyp   := orakatyp;
                    (*ENDIF*) 
                    sqlkap^ [pcka].kapacount := -3;
                    sqlkap^ [pcka].kapaindex :=  0;
                    IF  pcinpind = cpc_inputfile
                    THEN
                        sqlkap^ [pcka] .kalineno   := pclno.lnosrc
                    ELSE
                        sqlkap^ [pcka] .kalineno   := - pclno.lnoexp;
                    (*ENDIF*) 
                    sqlkap^ [pcka].kamode     := rakamode;
                    sqlkap^ [pcka]. kaatindex := pckaatind;
                    sqlkap^ [pcka]. kacuindex := 0;
                    (* verweiss auf same prepare stment *)
                    sqlkap^ [pcka].kadiindex  := prkaindex;
                    sqlkap^ [pcka].kafaindex  := 0;
                    sqlprp^ [ind]. prkaindex := pcka;
                    sqlkap^ [pcka].kaprindex  := ind;
                    END;
                (*ENDIF*) 
                pcan.ancheck := pcopts.opt_mode;
                sqlxa.xakano := prkaindex;
                IF  ndindex > 0
                THEN
                    ndtabp^ [ndindex].ndkano := prkaindex;
                (*ENDIF*) 
                p10getkeyword (apc, partbufp^, keyind);
                IF   (symb = cpr_s_eof) OR (symb = cpr_s_bufeof)
                THEN
                    BEGIN
                    IF  (rakamode = cpr_kind_internal)
                    THEN
                        (* default sqldb sqlda expansion *)
                        xadescpos := -1
                    ELSE
                        p11precomerror (apc, cpc_invalid_sql_command);
                    (*ENDIF*) 
                    END
                ELSE
                    BEGIN
                    IF  (keyind = cpc_i_into)
                    THEN
                        BEGIN
                        (* descriptor name *)
                        next_symbol (apc, partbufp^, part1len);
                        IF  partbufp^ [sypos] = cpr_paramchr
                        THEN
                            xadescpos := sypos + 1
                        ELSE
                            xadescpos := sypos;
                        (*ENDIF*) 
                        WHILE  (symb <> cpr_s_eof) AND (symb <> cpr_s_bufeof)
                              AND (keyind <> cpc_i_using) DO
                            BEGIN
                            xadesclen := syposacc - xadescpos;
                            next_symbol (apc, partbufp^, part1len);
                            p10getkeyword (apc, partbufp^, keyind);
                            END;
                        (*ENDWHILE*) 
                        END
                    ELSE
                        p11precomerror (apc, cpc_invalid_sql_command);
                    (*ENDIF*) 
                    IF  (keyind = cpc_i_using)
                    THEN
                        BEGIN
                        next_symbol (apc, partbufp^, part1len);
                        p10getkeyword (apc, partbufp^, keyind);
                        IF   (keyind <>  cpc_i_names)
                            AND (keyind <>  cpc_i_labels)
                            AND (keyind <>  cpc_i_any)
                        THEN
                            p11precomerror (apc, cpc_pre_not_implemented);
                        (*ENDIF*) 
                        END;
                    (*ENDIF*) 
                    END;
                (*ENDIF*) 
                END;
            (*ENDWITH*) 
        (*ENDIF*) 
        END;
    (*ENDIF*) 
    WHILE  (symb <> cpr_s_eof) AND (symb <> cpr_s_bufeof) DO
        next_symbol (apc, partbufp^, part1len);
    (*ENDWHILE*) 
&   ifdef TRACE
    m90int2 (pc, 'xakano      ', xakano   );
    m90int2 (pc, 'xadescpos   ', xadescpos);
    m90int2 (pc, 'xadesclen   ', xadesclen);
&   endif
    END;
(*ENDWITH*) 
&ifdef TRACE
m90name(xx, 'END p14describe   ');
&endif
END;
 
(*------------------------------*) 
 
PROCEDURE
      p14close  (
            PROCEDURE next_symbol (VAR p1: tpc_globals;
            VAR p2: tpc_partbuffer; p3: integer);
            VAR apc : tpc_globals);
 
VAR
      retpos    : tsp00_Int2;
      macro  : tsp00_Int2;
      param  : tsp00_Int2;
      cursorn : tsp00_KnlIdentifier;
      cursorl : integer;
      rscan  : tpr_scannertype;
      va1ix     : tsp00_Int2;
      ch12      : tsp00_C12;
      no        : integer;
      CursorNameIndex  : tsp00_Int2;
      prind : integer;
      paix  : tsp00_Int2;
      ndcuindex  : integer;
 
BEGIN
WITH apc, pcscan, sqlca, sqlrap^, pccmdpart, sqlxa   DO
    BEGIN
    retpos := syposacc;
    (* if f?ur umstellung next_symbol *)
    WHILE  (symb <> cpr_s_eof) AND (symb <> cpr_s_bufeof) DO
        next_symbol (apc, partbufp^, part1len);
    (*ENDWHILE*) 
    syposacc := retpos;
    symb     := cpr_s_unknown;
    (* close *)
    next_symbol (apc, partbufp^, part1len);
    p14getname (next_symbol, apc, cursorn, cursorl, macro, param );
    WITH sqlxa, sqlprp^ [pcpr ] DO
        BEGIN
        paix := 0;
        p14_add_prind  (apc, prind, paix);
        pcpr := prind;
        WITH sqlxa, sqlprp^ [pcpr ] DO
            BEGIN
            sqlprp^[pcpr].prarea := cpr_in_sqlst;
            sqlprp^[pcpr].prDescribe := cpr_is_false;
            END;
        (*ENDWITH*) 
        pcan.ancomtyp    := cpr_com_sql_close;
        pcusage.uscom    := cpc_usage_prep;
        IF  (param = cpr_is_true)
        THEN
            BEGIN
            pcan.ancheck := cpc_ch_no;
            rscan := pcscan;
            p14_hostv_get (next_symbol, apc, CursorNameIndex, va1ix);
            no := va1ix;
            p05inttochr12 (no, ch12);
            cursorn := bsp_knl_identifier;
            cursorn[1] := ':';
            s10mv (mxsp_c12, sizeof(cursorn), @ch12, 2,
                  @cursorn, 2, 4);
            pcscan := rscan;
            (* PTS 1104482 *)
            ndcuindex := pcsqlva.ndcnt;
            sqlprp^[pcpr].prCursorName := cursorn;
            sqlprp^[pcpr].prCursorNameIndex := CursorNameIndex;
            END
        ELSE
            BEGIN
            sqlxa.sqlprp^[pcpr].prCursorName := cursorn;
            (* PTS 1104482 *)
            ndcuindex := 0;
            END;
        (*ENDIF*) 
        IF  ndcuindex > 0
        THEN
            pcsqlva.ndtabp^ [ndcuindex].ndkano := pcka+1;
        (*ENDIF*) 
        END;
    (*ENDWITH*) 
    END;
(*ENDWITH*) 
&ifdef TRACE
m90name(xx, 'END p14close      ');
&endif
END;
 
(*------------------------------*) 
 
PROCEDURE
      p14forloop  (
            PROCEDURE next_symbol (VAR p1: tpc_globals;
            VAR p2: tpc_partbuffer; p3: integer);
            VAR apc : tpc_globals);
 
VAR
      retposfor : integer;
      retpos : integer;
      itypentix : tsp00_Int2;
      ivatyp    : tsp00_Int2;
      iind      : tsp00_Int2;
      loopcnt   : tsp00_Int2;
      keyind : integer;
      i      : integer;
      lastvatyp : tsp00_Int2;
      statemno : integer;
      immediate: integer;
      loopcnterr : tpc_pre_errors;
      cursorparampos : tsp00_Int4;
 
BEGIN
WITH apc, pcscan, sqlca, sqlrap^, pccmdpart, pcsqlva, sqlxa   DO
    BEGIN
    statemno  := 0;
    retposfor := sypos;
    retpos    := syposacc;
    loopcnterr:= cpc_pre_ok;
    IF  ralang in [cpr_la_c, cpr_la_cobol]
    THEN
        (* if f?ur umstellung next_symbol *)
        WHILE  (symb <> cpr_s_eof) AND (symb <> cpr_s_bufeof) DO
            next_symbol (apc, partbufp^, part1len);
        (*ENDWHILE*) 
    (*ENDIF*) 
    IF  ralang = cpr_la_cobol
    THEN
        BEGIN
        part1len := part1len + 1;
        partbufp^ [part1len] := cpr_nullchar ;
        END;
    (*ENDIF*) 
    symb     := cpr_s_unknown;
    syposacc := retpos;
&   ifdef TRACE
    m90buf (pc, partbufp^ [1], 1 , part1len );
&   endif
    IF   pcerror = cpc_pre_ok
    THEN
        BEGIN
        next_symbol (apc, partbufp^, part1len);
        IF  symb = cpr_s_parameter_name
        THEN
            BEGIN
            syposacc := sypos + 1;
            itypentix := 0;
            p14btypentget (next_symbol, apc, itypentix, ivatyp,
                  lastvatyp, cpr_is_true );
            IF  ((ivatyp = cpr_vstruct) OR
                (ivatyp = cpr_varray))
            THEN
                p11wrerrorlisting (apc, cpc_invalid_sql_command)
            ELSE
                BEGIN
                IF  itypentix <> 0
                THEN
                    BEGIN
                    IF  pcpaloop = 0
                    THEN
                        BEGIN
                        (* first entry for sqlsa sastruc = cpr_is_loop_cnt *)
                        iind := ndtabp^ [ndcnt].ndsqlva1ix;
                        p19cparentry (apc, sqlparlo,
                              -iind, 0, 0);
                        pcpaloop := -pcpa;
                        ndtabp^ [ndcnt] .ndkano  := pcka + 1;
                        FOR i := retposfor TO sypos-1 DO
                            partbufp^ [i] := bsp_c1;
                        (*ENDFOR*) 
                        (* massen comand *)
                        END;
                    (*ENDIF*) 
                    END
                (*ENDIF*) 
                END
            (*ENDIF*) 
            END
        ELSE
            IF  symb = cpr_s_unsigned_integer
            THEN
                BEGIN
                p10int2unsignedget (apc, partbufp^, loopcnt);
                IF  loopcnt < 1
                THEN
                    BEGIN
                    p11wrerrorlisting (apc, cpc_p_loop_init_wrong);
                    loopcnterr :=  cpc_p_loop_init_wrong;
                    END;
                (*ENDIF*) 
                p19cparentry (apc,  sqlparlo,
                      loopcnt, loopcnt, 0);
                pcpaloop := -pcpa;
                FOR i := retposfor TO syposacc-1 DO
                    partbufp^ [i] := bsp_c1;
                (*ENDFOR*) 
                next_symbol (apc, partbufp^, part1len);
                END
            ELSE
                p11wrerrorlisting (apc, cpc_invalid_sql_command);
            (*ENDIF*) 
        (*ENDIF*) 
        END;
    (*ENDIF*) 
    IF  pcopts.opt_comp = 0
    THEN
        p11wrerrorlisting (apc, cpc_forloop_not_allowed);
    (*ENDIF*) 
    retpos := syposacc;
    (* untersuche ob:  for :loop  execute into .... *)
    (* next_symbol (apc, partbufp^, part1len);   *)
    p10getkeyword (apc, partbufp^, keyind);
    CASE  keyind OF
        cpc_i_open :
            BEGIN
            p14open (next_symbol, apc, statemno);
            IF  statemno > 0
            THEN
                IF  sqlxa.sqlkap^ [statemno].kapacount < 0
                THEN
                    sqlxa.sqlkap^ [statemno].kapacount :=
                          sqlxa.sqlkap^ [statemno].kapacount - 1;   (* +1 *)
                (*ENDIF*) 
            (*ENDIF*) 
            keyind := cpc_i_open;
            xakano := statemno;
            END;
        cpc_i_execute :
            BEGIN
            p14execute (next_symbol, apc, statemno, immediate);
            IF  statemno > 0
            THEN
                IF  sqlxa.sqlkap^ [statemno].kapacount < 0
                THEN
                    sqlxa.sqlkap^ [statemno].kapacount :=
                          sqlxa.sqlkap^ [statemno].kapacount - 1;   (* +1 *)
                (*ENDIF*) 
            (*ENDIF*) 
            keyind := cpc_i_execute;
            xakano := statemno;
            END;
        cpc_i_fetch :
            BEGIN
            p14fetch (next_symbol, apc, keyind, retpos, cursorparampos);
            IF   keyind = cpc_i_descriptor
            THEN
                BEGIN
                syposacc := retpos;
                p14ansqlstatement (next_symbol, apc);
                sqlxa.sqlkap^ [pcka] .kapacount := -3; (* +1 *)
                pcda := mxpr_sqln;
                END
            ELSE
                BEGIN
                syposacc := retpos;
                p14ansqlstatement (next_symbol, apc);
                END;
            (*ENDIF*) 
            END;
        cpc_i_putval :
            BEGIN
            p14putval (next_symbol, apc, keyind, retpos);
            p14ansqlstatement (next_symbol, apc);
            IF  keyind = cpc_i_descriptor
            THEN
                BEGIN
                sqlxa.sqlkap^ [pcka] .kapacount := -2;
                pcda := mxpr_sqln;
                END
            (*ENDIF*) 
            END;
        cpc_i_getval :
            BEGIN
            p14getval (next_symbol, apc, keyind, retpos);
            IF   keyind = cpc_i_descriptor
            THEN
                BEGIN
                syposacc := retpos;
                p14ansqlstatement (next_symbol, apc);
                sqlxa.sqlkap^ [pcka] .kapacount := -2; (* +1 *)
                pcda := mxpr_sqln;
                END
            ELSE
                BEGIN
                syposacc := retpos;
                p14ansqlstatement (next_symbol, apc);
                END;
            (*ENDIF*) 
            END;
        OTHERWISE:
            BEGIN
            syposacc := retpos;
            p14ansqlstatement (next_symbol, apc);
            END;
        END;
    (*ENDCASE*) 
    IF  xakano > 0
    THEN
        BEGIN
        sqlkap^ [xakano].kapaindex := pcpaloop;
        sqlkap^ [xakano].kapacount := sqlkap^ [xakano].kapacount +1;
&       ifdef TRACE
        m90int2 (pc, 'pcka        ', pcka     );
        m90int2 (pc, 'xakano      ', xakano   );
        m90int2 (pc, 'pcpaloop    ', pcpaloop );
        m90int2 (pc, 'kapacount   ', sqlkap^ [xakano].kapacount );
&       endif
        END;
    (*ENDIF*) 
    IF  pcerror = cpc_pre_ok
    THEN
        pcerror := loopcnterr;
    (*ENDIF*) 
    symb := cpr_s_eof;
    END;
(*ENDWITH*) 
&ifdef TRACE
m90name(xx, 'END p14forloop    ');
&endif
END;
 
(*------------------------------*) 
 
PROCEDURE
      p14fetch  (
            PROCEDURE next_symbol (VAR p1: tpc_globals;
            VAR p2: tpc_partbuffer; p3: integer);
            VAR apc : tpc_globals;
            VAR keyind : integer;
            VAR pos : tsp00_Int4;
            VAR cursorparampos : tsp00_Int4);
 
VAR
      n       : integer;
      f_pos   : tsp00_Int4;
      stmlen : tsp00_Int4;
&     ifdef PREPSTMT
      macro  : tsp00_Int2;
      param  : tsp00_Int2;
      cursorn : tsp00_KnlIdentifier;
      cursorl : integer;
      rscan  : tpr_scannertype;
      va1ix     : tsp00_Int2;
      ch12      : tsp00_C12;
      no        : integer;
      CursorNameIndex  : tsp00_Int2;
      prind : integer;
      paix  : tsp00_Int2;
      ndcuindex : integer;
&     endif
 
BEGIN
WITH apc, pcscan, sqlca, sqlrap^, pccmdpart, sqlxa   DO
    BEGIN
    IF  ralang in [cpr_la_c, cpr_la_cobol]
    THEN
        (* if f?ur umstellung next_symbol *)
        WHILE  (symb <> cpr_s_eof) AND (symb <> cpr_s_bufeof) DO
            next_symbol (apc, partbufp^, part1len);
        (*ENDWHILE*) 
    (*ENDIF*) 
    symb     := cpr_s_unknown;
    xadescpos := 0;
    xadesclen := 0;
    keyind := 0;
    f_pos  := 0;
    cursorparampos := 0;
    pcan.ancomtyp := cpr_com_sql_fetch;
    p10rmspace (partbufp^, cpr_quotsym , cpr_quotsym,
          1, part1len-1, part1len, stmlen);
    IF  ralang <> cpr_la_cobol
    THEN
        partbufp^ [part1len] := chr (0);
&   ifdef TRACE
    (*ENDIF*) 
    m90buf (pc, partbufp^ [1], 1 , part1len );
&   endif
    (* fetch command *)
    syposacc := 1;
    next_symbol (apc, partbufp^, part1len);
    p19sqlfaallocate (pcfa);
    (* fetch spec oder ergname  *)
    next_symbol (apc, partbufp^, part1len);
    p10getkeyword (apc, partbufp^, keyind);
&   ifndef PREPSTMT
    p14bcusearch (apc, partbufp^,
          part1len );
&   endif
    IF   keyind = cpc_i_pos
    THEN
        BEGIN
        n := 0;
        REPEAT
            next_symbol (apc, partbufp^, part1len);
            IF  symb = cpr_s_leftpar
            THEN
                n := n + 1;
            (*ENDIF*) 
            IF  symb = cpr_s_parameter_name
            THEN
                f_pos := sypos;
            (*ENDIF*) 
            IF  symb = cpr_s_rightpar
            THEN
                n := n - 1;
            (*ENDIF*) 
        UNTIL
            (n = 0) OR (symb = cpr_s_eof) OR (symb = cpr_s_bufeof);
        (*ENDREPEAT*) 
        END;
&   ifdef PREPSTMT
    (*ENDIF*) 
    IF  (f_pos > 0)
    THEN
        BEGIN
        next_symbol (apc, partbufp^, part1len);
        p10getkeyword (apc, partbufp^, keyind);
        END;
    (*ENDIF*)
    IF  (keyind <> cpc_i_using)
        AND (keyind <> cpc_i_into)
    THEN
        BEGIN
        (* ergname oder fetchspec *)
        IF    (keyind <> cpc_i_next)
            AND     (keyind <> cpc_i_prev)
            AND     (keyind <> cpc_i_last)
            AND     (keyind <> cpc_i_first)
            AND     (keyind <> cpc_i_pos)
        THEN
            BEGIN
            p14getname (next_symbol, apc, cursorn, cursorl, macro
                  , param
                  );
            paix := 0;
            p14_add_prind  (apc, prind, paix);
            pcpr := prind;
            WITH sqlxa, sqlprp^ [pcpr ] DO
                BEGIN
                sqlprp^[pcpr].prarea := cpr_in_sqlst;
                sqlprp^[pcpr].prDescribe := cpr_is_false;
                END;
            (*ENDWITH*) 
            IF  (param = cpr_is_true)
            THEN
                BEGIN
                pcan.ancomtyp := cpr_com_sql_fetch;
                pcan.ancheck := cpc_ch_no;
                pcusage.uscom := cpc_usage_empty;
                rscan := pcscan;
                cursorparampos := sypos;
                p14_hostv_get (next_symbol, apc, CursorNameIndex, va1ix);
                no := va1ix;
                p05inttochr12 (no, ch12);
                cursorn := bsp_knl_identifier;
                cursorn[1] := ':';
                s10mv (mxsp_c12, sizeof(cursorn), @ch12, 2,
                      @cursorn, 2, 4);
                (* PTS 1104482 *)
                ndcuindex := pcsqlva.ndcnt;
                IF  ndcuindex > 0
                THEN
                    pcsqlva.ndtabp^ [ndcuindex].ndkano := pcka+1;
                (*ENDIF*) 
                pcscan := rscan;
                sqlprp^[pcpr].prCursorName := cursorn;
                sqlprp^[pcpr].prCursorNameIndex := CursorNameIndex;
                END
            ELSE
                BEGIN
                sqlxa.sqlprp^[pcpr].prCursorName := cursorn;
                END;
            (*ENDIF*) 
            next_symbol (apc, partbufp^, part1len);
            p10getkeyword (apc, partbufp^, keyind);
            END;
        (*ENDIF*) 
        END
    ELSE
        BEGIN
        paix := 0;
        p14_add_prind  (apc, prind, paix);
        pcpr := prind;
        WITH sqlxa, sqlprp^ [pcpr ] DO
            BEGIN
            sqlprp^[pcpr].prarea := cpr_in_sqlst;
            sqlprp^[pcpr].prDescribe := cpr_is_false;
            END;
        (*ENDWITH*) 
        END;
    (*ENDIF*) 
&   endif
    pos := syposacc;
    IF  (keyind <> cpc_i_using)
        AND (keyind <> cpc_i_into)
    THEN
        BEGIN
        (*  using/ into    *)
        next_symbol (apc, partbufp^, part1len);
        p10getkeyword (apc, partbufp^, keyind);
        END;
    (*ENDIF*) 
    IF   keyind <>  cpc_i_descriptor
    THEN
        BEGIN
        next_symbol (apc, partbufp^, part1len);
        p10getkeyword (apc, partbufp^, keyind);
        END;
    (*ENDIF*) 
    IF   keyind = cpc_i_descriptor
    THEN
        BEGIN
        (*        sqlprp^[pcpr].prDescribe := cpr_is_true;*)
        IF  f_pos > 0
        THEN
            p11wrerrorlisting (apc, cpc_invalid_sql_command)
        ELSE
            BEGIN
            (* default :descriptor, delete ':' *)
            n := syposacc;
            WHILE (partbufp^ [n] = bsp_c1) DO
                n := n + 1;
            (*ENDWHILE*) 
            IF  partbufp^ [n] = cpr_paramchr
            THEN
                partbufp^ [n] := bsp_c1;
            (*ENDIF*) 
            xadescpos := n;
            xadesclen := part1len - xadescpos;
            END;
        (*ENDIF*) 
        IF  (rakamode = cpr_kind_internal) AND (part1len - n = 0)
        THEN
            BEGIN
            xadescpos := -1
            END
        (*ENDIF*) 
        END;
    (*ENDIF*) 
    symb     := cpr_s_eof;
    syposacc := 1;
    IF  (f_pos > 0)
    THEN
        pos := f_pos;
    (*ENDIF*)
    END;
(*ENDWITH*) 
&ifdef TRACE
m90name(xx, 'END p14fetch      ');
&endif
END;
 
(*------------------------------*) 
 
PROCEDURE
      p14whenever  (
            PROCEDURE next_symbol (VAR p1: tpc_globals;
            VAR p2: tpc_partbuffer; p3: integer);
            VAR apc : tpc_globals);
 
VAR
      keyind : integer;
 
BEGIN
WITH apc, pcscan, pccmdpart DO
    BEGIN
    IF   pcerror = cpc_pre_ok
    THEN
        BEGIN
        pcwheset := cpr_is_true;
        next_symbol (apc, partbufp^, part1len);
        p10getkeyword (apc, partbufp^, keyind);
        CASE keyind OF
            cpc_i_sqlwarning :
                p14_get_action (next_symbol, apc, 1);
            cpc_i_sqlerror :
                p14_get_action (next_symbol, apc, 2);
            cpc_i_sqlexception :
                p14_get_action (next_symbol, apc, 3);
            cpc_i_notfound  :
                p14_get_action (next_symbol, apc, 4);
            cpc_i_not  :
                BEGIN
                next_symbol (apc, partbufp^, part1len);
                p10getkeyword (apc, partbufp^, keyind);
                IF   keyind = cpc_i_found
                THEN
                    p14_get_action (next_symbol, apc, 4)
                ELSE
                    p11wrerrorlisting (apc, cpc_unknown_sql_command);
                (*ENDIF*) 
                END;
            cpc_i_sqlbegin :
                p14_get_action (next_symbol, apc, 5);
            cpc_i_sqlend   :
                p14_get_action (next_symbol, apc, 6);
            OTHERWISE:
                p11wrerrorlisting (apc, cpc_unknown_sql_command);
            END;
        (*ENDCASE*) 
        END;
    (*ENDIF*) 
    WHILE  (symb <> cpr_s_eof) AND (symb <> cpr_s_bufeof) DO
        next_symbol (apc, partbufp^, part1len);
    (*ENDWHILE*) 
    END;
(*ENDWITH*) 
&ifdef TRACE
m90name(xx, 'END p14whenever   ');
&endif
END;
 
(*------------------------------*) 
 
PROCEDURE
      p14_get_action (
            PROCEDURE next_symbol (VAR p1: tpc_globals;
            VAR p2: tpc_partbuffer; p3: integer);
            VAR apc : tpc_globals;
            ind : integer);
 
VAR
      i           : integer;
      pos, keyind : integer;
 
BEGIN
WITH apc, pcscan, sqlca, sqlrap^, pccmdpart, pcwhe [ind ] DO
    IF   pcerror = cpc_pre_ok
    THEN
        BEGIN
        pos := syposacc;
        IF  ralang in [cpr_la_c, cpr_la_cobol]
        THEN
            (* if f?ur umstellung next_symbol *)
            WHILE  (symb <> cpr_s_eof) AND (symb <> cpr_s_bufeof) DO
                next_symbol (apc, partbufp^, part1len);
            (*ENDWHILE*) 
        (*ENDIF*) 
        IF  ralang = cpr_la_cobol
        THEN
            BEGIN
            part1len := part1len + 1;
            partbufp^ [part1len] := cpr_nullchar ;
            END;
        (*ENDIF*) 
        syposacc := pos;
        symb := cpr_s_unknown;
        next_symbol (apc, partbufp^, part1len);
        p10getkeyword (apc, partbufp^, keyind);
        CASE keyind OF
            cpc_i_stop :
                BEGIN
                whlen := sylen;
                whact := cpc_i_stop;
                s10mv (partsizlen, mxsp_c50, @partbufp^, sypos,
                      @whstr, 1, sylen);
                END;
            cpc_i_continue :
                BEGIN
                whlen := 0;
                whact := cpc_i_continue;
                END;
            cpc_i_goto, cpc_i_go :
                IF  (ind = 5) OR (ind = 6)
                THEN
                    p11wrerrorlisting (apc, cpc_unknown_sql_command)
                ELSE
                    BEGIN
                    IF   ralang in [cpr_la_cobol, cpr_la_cobmic,
                        cpr_la_cob8860 ]
                    THEN
                        BEGIN
                        IF   keyind = cpc_i_go
                        THEN
                            BEGIN
                            next_symbol (apc, partbufp^, part1len);
                            p10getkeyword (apc, partbufp^, keyind);
                            IF   keyind <> cpc_i_to
                            THEN
                                p11wrerrorlisting (apc, cpc_unknown_sql_command);
                            (*ENDIF*) 
                            END;
                        (*ENDIF*) 
                        pos := syposacc;
                        END
                    ELSE
                        pos := sypos;
                    (*ENDIF*) 
                    IF   ralang =  cpr_la_c
                    THEN
                        BEGIN
                        IF   keyind = cpc_i_go
                        THEN
                            BEGIN
                            next_symbol (apc, partbufp^, part1len);
                            p10getkeyword (apc, partbufp^, keyind);
                            IF   keyind <> cpc_i_to
                            THEN
                                p11wrerrorlisting (apc, cpc_unknown_sql_command);
                            (*ENDIF*) 
                            END;
                        (*ENDIF*) 
                        partbufp^ [pos]   := 'g';
                        partbufp^ [pos+1] := 'o';
                        partbufp^ [pos+2] := 't';
                        partbufp^ [pos+3] := 'o';
                        FOR i := pos+4 TO syposacc DO
                            partbufp^ [i] := bsp_c1;
                        (*ENDFOR*) 
                        END;
                    (*ENDIF*) 
                    whlen := part1len - pos;
                    whact := cpc_i_goto;
                    IF   whlen > mxsp_c50
                    THEN
                        BEGIN
                        whlen := mxsp_c50;
                        p11wrerrorlisting (apc, cpc_too_long_wheneverstring)
                        END;
                    (*ENDIF*) 
                    i := syposacc;
                    WHILE ((partbufp^ [i] = bsp_c1) AND (i < part1len)) DO
                        i := i + 1;
                    (*ENDWHILE*) 
                    IF  partbufp^ [i] = cpr_paramchr
                    THEN
                        partbufp^ [i] := bsp_c1;
                    (*ENDIF*) 
                    s10mv (partsizlen, mxsp_c50, @partbufp^, pos,
                          @whstr, 1, whlen);
                    END;
                (*ENDIF*) 
            cpc_i_do :
                BEGIN
                IF  (ralang = cpr_la_cobol)
                    OR (ralang = cpr_la_cobmic)
                THEN
                    BEGIN
                    next_symbol (apc, partbufp^, part1len);
                    p10getkeyword (apc, partbufp^, keyind);
                    IF   keyind <> cpc_i_perform
                    THEN
                        p11wrerrorlisting (apc, cpc_unknown_sql_command);
                    (*ENDIF*) 
                    END;
                (*ENDIF*) 
                pos := syposacc;
                whlen := part1len - pos;
                whact := cpc_i_call;
                IF   whlen > mxsp_c50
                THEN
                    BEGIN
                    whlen := mxsp_c50;
                    p11wrerrorlisting (apc, cpc_too_long_wheneverstring)
                    END;
                (*ENDIF*) 
                s10mv (partsizlen, mxsp_c50, @partbufp^, pos,
                      @whstr, 1, whlen);
                END;
            cpc_i_call :
                BEGIN
                pos := syposacc;
                whlen := part1len - pos;
                whact := cpc_i_call;
                IF   whlen > mxsp_c50
                THEN
                    BEGIN
                    whlen := mxsp_c50;
                    p11wrerrorlisting (apc, cpc_too_long_wheneverstring)
                    END;
                (*ENDIF*) 
                s10mv (partsizlen, mxsp_c50, @partbufp^, pos,
                      @whstr, 1, whlen);
                END;
            OTHERWISE:
                p11wrerrorlisting (apc, cpc_unknown_sql_command);
            END;
        (*ENDCASE*) 
        symb := cpr_s_eof;
        END;
&   ifdef TRACE
    (*ENDIF*) 
(*ENDWITH*) 
m90name(xx, 'END p14_get_action');
&endif
END;
 
(*------------------------------*) 
 
PROCEDURE
      p14nolog (
            PROCEDURE next_symbol (VAR p1: tpc_globals;
            VAR p2: tpc_partbuffer; p3: integer);
            VAR apc : tpc_globals);
 
VAR
      err : tpc_pre_errors;
      retpos     : tsp00_Int2;
 
BEGIN
WITH apc, pcscan, sqlca, sqlrap^, pccmdpart,
     sqlxa, pcsqlva, pcsymtab DO
    BEGIN
    retpos := syposacc;
    IF  ralang in [cpr_la_c]
    THEN
        WHILE  (symb <> cpr_s_eof) AND (symb <> cpr_s_bufeof) DO
            next_symbol (apc, partbufp^, part1len);
        (*ENDWHILE*) 
    (*ENDIF*) 
    syposacc := retpos;
    symb     := cpr_s_unknown;
    IF   pcerror = cpc_pre_ok
    THEN
        BEGIN
        err := cpc_pre_ok;
        next_symbol (apc, partbufp^, part1len);
        IF   (symb = cpr_s_eof) OR   (symb = cpr_s_bufeof)
        THEN
            BEGIN
            (* set nolog flag in gaentry *)
            sqlgap^.gaentry [raactsession]^.ganolog := cpr_is_true;
            END
        ELSE
            p11wrerrorlisting (apc, cpc_invalid_sql_command);
        (*ENDIF*) 
        END;
    (*ENDIF*) 
    END;
(*ENDWITH*) 
END;
 
(*------------------------------*) 
 
PROCEDURE
      p14option  (
            PROCEDURE next_symbol (VAR p1: tpc_globals;
            VAR p2: tpc_partbuffer; p3: integer);
            VAR apc : tpc_globals;
            VAR statemno : integer);
 
VAR
      statemn : tsp00_KnlIdentifier;
      stateml : integer;
      keyind  : integer;
      prind   : integer;
      posab   : integer;
      pos     : integer;
      len     : integer;
      posch   : integer;
      mnr     : integer;
      subch   : char;
      err     : tpc_pre_errors;
      ptypentix : tsp00_Int2;
      pvatyp    : tsp00_Int2;
      kaind     : tsp00_Int2;
      retpos    : tsp00_Int2;
      lastvatyp : tsp00_Int2;
      ndindex   : integer;
 
BEGIN
WITH apc, pcscan, sqlca, sqlrap^, pccmdpart, sqlxa, pcsqlva  DO
    BEGIN
    retpos    := syposacc;
    xadescpos := 0;
    xadesclen := 0;
    (* if f?ur umstellung next_symbol *)
    WHILE  (symb <> cpr_s_eof) AND (symb <> cpr_s_bufeof) DO
        next_symbol (apc, partbufp^, part1len);
    (*ENDWHILE*) 
    syposacc := retpos;
    symb     := cpr_s_unknown;
    IF   pcerror = cpc_pre_ok
    THEN
        BEGIN
        err := cpc_pre_ok;
        IF  err = cpc_pre_ok
        THEN
            BEGIN
            (*next_symbol (apc, partbufp^, part1len);*)
            p10getkeyword (apc, partbufp^, keyind);
            p14kaentryinit (apc);
            p19sqlprallocate (pcpr);
            p19sqlfaallocate (pcfa);
            statemno := pcka;
            WITH sqlxa.sqlprp^ [pcpr] ,
                 sqlxa.sqlkap^ [pcka ], sqlxa, pcsqlva, pcsymtab DO
                BEGIN
                prstcount := 0;
                prstindex := 0;
                prcuindex := 0;
                prstate:= cpr_state_prepare;
                prStmtName   := bsp_knl_identifier;
                prStmtNameIndex := 0;
                prCursorName := bsp_knl_identifier;
                prCursorNameIndex := 0;
                prkaindex := pcka;
                prarea     := cpr_in_sqlva;
                prDescribe := cpr_is_false;
                kaprindex  := pcpr;
                kafaindex  := pcfa;
                next_symbol (apc, partbufp^, part1len);
                IF   symb = cpr_s_parameter_name
                THEN
                    BEGIN
                    (* variable *)
                    syposacc := sypos + 1;
                    ptypentix := 0;
                    p14btypentget (next_symbol, apc, ptypentix,
                          pvatyp, lastvatyp, cpr_is_true);
                    IF   ptypentix = 0
                    THEN
                        BEGIN
                        IF   (pcerror = cpc_pre_ok)
                        THEN
                            BEGIN
                            p11precomerror(apc,cpc_unknown_parametername);
                            p11nerrorlisting ( apc,
                                  vartablep^ [ndtabp^[ndcnt]
                                  .ndvarentix].vaname,
                                  vartablep^ [ndtabp^[ndcnt]
                                  .ndvarentix].vanaml, 0);
                            END
                        (*ENDIF*) 
                        END
                    ELSE
                        BEGIN
                        WITH ndtabp^ [ndcnt] DO
                            BEGIN
                            kaStindex := pcpa + 1;
                            IF  ndsqlva1st <> ndsqlva1ix
                            THEN
                                p19cparentry(apc,sqlparst, ndsqlva1st,
                                      0 , ndsqlva1cnt);
                            (*ENDIF*) 
                            p19cparentry (apc, sqlparel,
                                  ndsqlva1ix, 0, 0);
                            END;
                        (*ENDWITH*) 
                        END;
                    (*ENDIF*) 
                    END
                ELSE
                    BEGIN
                    (* stringconstante *)
                    pcan.ancheck := cpc_ch_no;
                    p10stringliteralget (apc, partbufp^);
                    SAPDB_PascalForcedFill (partsizlen, @partbufp^, 1,
                          sypos-1, bsp_c1);
                    posab := sypos;
                    posch := 1;
                    WHILE (posch <> 0) DO
                        BEGIN
                        p19snextsubchar (apc, posab, posch, subch);
                        IF   subch = cpr_macrochr
                        THEN
                            BEGIN
                            kamacro := cpr_is_true;
                            p19gmacronumber (apc, posch, mnr, posch);
                            IF   (mnr <= 0) OR (mnr > 128)
                            THEN
                                err := cpc_invalid_macronumber;
                            (*ENDIF*) 
                            END;
                        (*ENDIF*) 
                        posab := posch + 1;
                        END;
                    (*ENDWHILE*) 
                    prarea     := cpr_in_sqlst;
                    kaStcount := 0;
                    kaStindex := pcst + 1;
                    pos := sypos;
                    WHILE pos <  sypos + sylen  DO
                        BEGIN
                        IF   pos + mxpr_sqlline
                            > sypos + sylen
                        THEN
                            len := sypos + sylen - pos
                        ELSE
                            len := mxpr_sqlline;
                        (*ENDIF*) 
                        p19sqlstallocate (pcst);
                        IF  pcst > pcstmax
                        THEN
                            pcstmax := pcst;
                        (*ENDIF*) 
                        kaStcount := kaStcount + 1;
                        s10mv (partsizlen,mxpr_sqlline,
                              @partbufp^, pos,
                              @sqlstp^ [pcst] .stline, 1, len);
                        sqlstp^ [pcst].stllen  := len;
                        sqlstp^ [pcst].stkano := pcka;
                        pos := pos + len;
                        END;
                    (*ENDWHILE*) 
                    syposacc := sypos;
                    END;
                (*ENDIF*) 
                sqlxa.xakano := pcka;
                END;
            (*ENDWITH*) 
            END;
        (*ENDIF*) 
        IF   err <> cpc_pre_ok
        THEN
            p11precomerror (apc, err);
        (*ENDIF*) 
        END;
&   ifdef TRACE
    (*ENDIF*) 
    m90int2 (pc, 'xakano      ', xakano   );
    m90int2 (pc, 'xadescpos   ', xadescpos);
    m90int2 (pc, 'xadesclen   ', xadesclen);
&   endif
    symb := cpr_s_eof;
    END;
(*ENDWITH*) 
END;
 
(*------------------------------*) 
 
PROCEDURE
      p14gdbsname (
            PROCEDURE next_symbol (VAR p1: tpc_globals;
            VAR p2: tpc_partbuffer; p3: integer);
            VAR apc : tpc_globals;
            VAR ind : integer;
            VAR dbpos : integer;
            VAR dblen : integer;
            VAR dbnodepos : integer;
            VAR dbnodelen : integer);
 
VAR
      keyind : integer;
      dbsname: tsp00_DbName;
      dbnode : tsp00_NodeId;
      vnam   : tsp00_Lname;
      pcnt   : integer;
      vnaml  : integer;
      len    : integer;
      lastvatyp : tsp00_Int2;
      ptypentix : tsp00_Int2;
      pvatyp    : tsp00_Int2;
      vix       : tsp00_Int2;
      pvalen    : tsp00_Int2;
      retpos    : integer;
 
BEGIN
WITH apc, pcscan, sqlca, sqlrap^, pccmdpart, sqlxa,
     pcsqlva, pcsymtab  DO
    BEGIN
    pcnt      := 0;
    dbpos     := 1;
    dblen     := 0;
    dbnodepos := 1;
    dbnodelen := 0;
    retpos := syposacc;
    IF  ralang in [cpr_la_c, cpr_la_cobol]
    THEN
        (* if f?ur umstellung next_symbol *)
        WHILE  (symb <> cpr_s_eof) AND (symb <> cpr_s_bufeof) DO
            next_symbol (apc, partbufp^, part1len);
        (*ENDWHILE*) 
    (*ENDIF*) 
    IF  ralang = cpr_la_cobol
    THEN
        BEGIN
        part1len := part1len + 1;
        partbufp^ [part1len] := cpr_nullchar ;
        END;
    (*ENDIF*) 
    syposacc := retpos;
    symb     := cpr_s_unknown;
    IF   pcerror = cpc_pre_ok
    THEN
        BEGIN
&       ifdef TRACE
        m90buf (pc, partbufp^ [1], 1 , part1len );
&       endif
        ind   := raactsession;
        next_symbol (apc, partbufp^, part1len);
        (* dbname analyse *)
        p14kaentryinit (apc);
        IF   (symb = cpr_s_string_literal)
            OR  (symb = cpr_s_cstring_literal)
        THEN
            BEGIN
            p10stringliteralget (apc, partbufp^);
            IF   sylen > DBNAME_MXSP00
            THEN
                p11wrerrorlisting (apc, cpc_invalid_sql_command)
            ELSE
                BEGIN
                dbsname := bsp_dbname;
                sqlgap^.gaentry [ind]^ .gavaindex := 0;
                s10mv (partsizlen, DBNAME_MXSP00, @partbufp^, sypos,
                      @dbsname, 1, sylen);
                dbpos := sypos;
                dblen := sylen;
                next_symbol (apc, partbufp^, part1len);
                IF   sqlgap^.gaentry [ind]^.gaxuserrec.xu_serverdb
                    = bsp_dbname
                THEN
                    sqlgap^.gaentry [ind]^.gaxuserrec.xu_serverdb
                          := dbsname;
                (*ENDIF*) 
                END
            (*ENDIF*) 
            END
        ELSE
            IF   symb = cpr_s_parameter_name
            THEN
                BEGIN
                pcnt  := pcnt + 1;
                dbpos := sypos + 1;
                syposacc := sypos + 1;
                ptypentix := 0;
                p14btypentget (next_symbol, apc, ptypentix,
                      pvatyp, lastvatyp, cpr_is_true);
                dblen := sypos  - dbpos;
                WHILE partbufp^ [dbpos+dblen-1] in [bsp_c1, cpr_pc_endsign] DO
                    dblen := dblen - 1;
                (*ENDWHILE*) 
                IF   ptypentix = 0
                THEN
                    BEGIN
                    p11precomerror (apc, cpc_unknown_parametername);
                    vnam := 'SERVERDB_PARAMETER              ';
                    vnaml:= 20;
                    p11nerrorlisting ( apc, vnam, vnaml, pcnt);
                    END
                ELSE
                    BEGIN
                    sqlgap^.gaentry [ind]^ .gavaindex :=  pcpa + 1;
                    WITH ndtabp^ [ndcnt] DO
                        BEGIN
                        IF  ndsqlva1st <> ndsqlva1ix
                        THEN
                            BEGIN
                            p19cparentry (apc, sqlparst, ndsqlva1st,
                                  0 , ndsqlva1cnt);
                            END;
                        (*ENDIF*) 
                        p19cparentry (apc, sqlparel,
                              ndsqlva1ix, 0, 0);
                        vix    := ndtabp^ [ndcnt].ndsqlva1ix;
                        IF  sqlv1p^[vix].va1indi_sc = sqlvapt
                        THEN
                            vix :=  sqlv1p^[vix].va1ix_pt;
                        (*ENDIF*) 
                        pvalen := sqlv2p^[sqlv1p^[vix].va1indva2_sc].va2size;
                        END;
                    (*ENDWITH*) 
                    IF  NOT (pvatyp in [cpr_vchar..cpr_vbuf,
                        cpr_vstring,  cpr_vstring1])
                    THEN
                        p11wrerrorlisting (apc, cpc_datatyp_not_compatible)
                    ELSE
                        IF  pvalen > 0
                        THEN
                            BEGIN
                            len := DBNAME_MXSP00;
                            IF   pvatyp = cpr_vcharc
                            THEN
                                len := len + 1;
                            (*ENDIF*) 
                            IF   len < pvalen
                            THEN
                                BEGIN
                                p11wrerrorlisting (apc,
                                      cpc_variable_will_be_truncated);
                                vnam := 'SERVERDB_PARAMETER              ';
                                vnaml:= 20;
                                p11nerrorlisting ( apc, vnam, vnaml, pcnt);
                                pcerror := cpc_pre_ok;
                                END;
                            (*ENDIF*) 
                            END;
                        (*ENDIF*) 
                    (*ENDIF*) 
                    END
                (*ENDIF*) 
                END
            ELSE
                p11wrerrorlisting (apc, cpc_invalid_sql_command);
            (*ENDIF*) 
        (*ENDIF*) 
        END;
    (*ENDIF*) 
    IF   (symb = cpr_s_eof) OR   (symb = cpr_s_bufeof)
    THEN
        BEGIN
        (* servernode  = blank *)
        dbnodepos := 1;
        dbnodelen := 0;
        sqlgap^.gaentry [ind]^.gaxuserrec.xu_servernode := bsp_nodeid;
        sqlgap^.gaentry [ind]^ .ganodeindex := 0;
        END
    ELSE
        BEGIN
        p10getkeyword (apc, partbufp^, keyind);
        IF  keyind <> cpc_i_on
        THEN
            p11wrerrorlisting (apc, cpc_invalid_sql_command)
        ELSE
            BEGIN
            next_symbol (apc, partbufp^, part1len);
            (* servernode  analyse *)
            IF   (symb = cpr_s_string_literal)
                OR  (symb = cpr_s_cstring_literal)
            THEN
                BEGIN
                p10stringliteralget (apc, partbufp^);
                IF   sylen > NODEID_MXSP00
                THEN
                    p11wrerrorlisting (apc, cpc_invalid_sql_command)
                ELSE
                    BEGIN
                    dbnode := bsp_nodeid;
                    sqlgap^.gaentry [ind]^ .ganodeindex := 0;
                    s10mv (partsizlen, NODEID_MXSP00, @partbufp^, sypos,
                          @dbnode, 1, sylen);
                    dbnodepos := sypos;
                    dbnodelen := sylen;
                    next_symbol (apc, partbufp^, part1len);
                    IF   sqlgap^.gaentry [ind]^ .gaxuserrec.xu_servernode
                        = bsp_nodeid
                    THEN
                        sqlgap^.gaentry [ind]^ .gaxuserrec.xu_servernode
                              := dbnode;
                    (*ENDIF*) 
                    END
                (*ENDIF*) 
                END
            ELSE
                IF   symb = cpr_s_parameter_name
                THEN
                    BEGIN
                    pcnt  := pcnt + 1;
                    dbnodepos := sypos + 1;
                    syposacc := sypos + 1;
                    ptypentix := 0;
                    p14btypentget (next_symbol, apc, ptypentix,
                          pvatyp, lastvatyp, cpr_is_true);
                    dbnodelen := sypos  - dbnodepos;
                    WHILE partbufp^ [dbnodepos+dbnodelen-1]
                          in [bsp_c1, cpr_pc_endsign] DO
                        dbnodelen := dbnodelen - 1;
                    (*ENDWHILE*) 
                    IF   ptypentix = 0
                    THEN
                        BEGIN
                        p11precomerror (apc, cpc_unknown_parametername);
                        vnam := 'SERVERNODE_PARAMETER            ';
                        vnaml:= 22;
                        p11nerrorlisting ( apc, vnam, vnaml, pcnt);
                        END
                    ELSE
                        BEGIN
                        IF   (symb <> cpr_s_eof) AND  (symb <> cpr_s_bufeof)
                        THEN
                            next_symbol (apc, partbufp^, part1len);
                        (*ENDIF*) 
                        IF   (symb = cpr_s_eof) OR  (symb = cpr_s_bufeof)
                        THEN
                            BEGIN
                            sqlgap^.gaentry [ind]^ .ganodeindex := pcpa + 1;
                            WITH ndtabp^ [ndcnt] DO
                                BEGIN
                                IF  ndsqlva1st <> ndsqlva1ix
                                THEN
                                    BEGIN
                                    p19cparentry (apc, sqlparst, ndsqlva1st,
                                          0 , ndsqlva1cnt);
                                    END;
                                (*ENDIF*) 
                                p19cparentry (apc, sqlparel,
                                      ndsqlva1ix, 0, 0);
                                vix    := ndtabp^ [ndcnt].ndsqlva1ix;
                                IF  sqlv1p^[vix].va1indi_sc = sqlvapt
                                THEN
                                    vix :=  sqlv1p^[vix].va1ix_pt;
                                (*ENDIF*) 
                                pvalen := sqlv2p^[sqlv1p^[vix].va1indva2_sc]
                                      .va2size;
                                END;
                            (*ENDWITH*) 
                            END
                        ELSE
                            p11wrerrorlisting (apc, cpc_invalid_sql_command);
                        (*ENDIF*) 
                        IF  NOT (pvatyp in [cpr_vchar..cpr_vbuf,
                            cpr_vstring,  cpr_vstring1])
                        THEN
                            p11wrerrorlisting (apc, cpc_datatyp_not_compatible)
                        ELSE
                            IF  pvalen > 0
                            THEN
                                BEGIN
                                len := NODEID_MXSP00;
                                IF   pvatyp = cpr_vcharc
                                THEN
                                    len := len + 1;
                                (*ENDIF*) 
                                IF   len < pvalen
                                THEN
                                    BEGIN
                                    p11wrerrorlisting (apc,
                                          cpc_variable_will_be_truncated);
                                    vnam:= 'SERVERNODE_PARAMETER            ';
                                    vnaml:= 22;
                                    p11nerrorlisting (apc, vnam, vnaml, pcnt);
                                    pcerror := cpc_pre_ok;
                                    END;
                                (*ENDIF*) 
                                END;
                            (*ENDIF*) 
                        (*ENDIF*) 
                        END
                    (*ENDIF*) 
                    END
                ELSE
                    p11wrerrorlisting (apc, cpc_invalid_sql_command);
                (*ENDIF*) 
            (*ENDIF*) 
            END;
        (*ENDIF*) 
        END;
    (*ENDIF*) 
    symb := cpr_s_eof;
    END;
(*ENDWITH*) 
&ifdef TRACE
m90name(xx, 'END p14gdbsname   ');
&endif
END;
 
(*------------------------------*) 
 
PROCEDURE
      p14gtrace (
            PROCEDURE next_symbol (VAR p1: tpc_globals;
            VAR p2: tpc_partbuffer; p3: integer);
            VAR apc : tpc_globals;
            keyind: integer);
 
BEGIN
WITH apc, pcscan, sqlca, pccmdpart, sqlgap^, sqloap^ DO
    BEGIN
    CASE keyind OF
        cpc_i_off  :
            oamodsettrty := cpr_trace_off;
        cpc_i_on   :
            oamodsettrty := cpr_trace_formal;
        cpc_i_long :
            oamodsettrty := cpr_trace_long;
        OTHERWISE:
            p11precomerror (apc, cpc_unknown_sql_command);
        END;
    (*ENDCASE*) 
    IF  pcerror = cpc_pre_ok
    THEN
        BEGIN
        next_symbol (apc, partbufp^, part1len);
        IF  ( symb <> cpr_s_eof ) AND ( symb <> cpr_s_bufeof )
        THEN
            p11precomerror ( apc, cpc_missing_endsign );
        (*ENDIF*) 
        END;
    (*ENDIF*) 
    WHILE NOT (symb in [cpr_s_eof, cpr_s_bufeof]) DO
        next_symbol (apc, partbufp^, part1len);
    (*ENDWHILE*) 
    END;
(*ENDWITH*) 
&ifdef TRACE
m90name(xx, 'END p14gtrace     ');
&endif
END;
 
(*------------------------------*) 
 
PROCEDURE
      p14traceline (
            PROCEDURE next_symbol (VAR p1: tpc_globals;
            VAR p2: tpc_partbuffer; p3: integer);
            VAR apc : tpc_globals;
            VAR statemno : integer);
 
BEGIN
p14option (next_symbol, apc, statemno);
&ifdef TRACE
m90name(xx, 'END p14traceline  ');
&endif
END;
 
(*------------------------------*) 
 
FUNCTION
      p14ifstbind   (VAR apc : tpc_globals;
            kano : integer) : boolean;
 
VAR
      stbind  : boolean;
      pcstset : boolean;
 
BEGIN
WITH apc, sqlxa.sqlkap^ [kano] DO
    BEGIN
    stbind  := true;
    pcstset := true;
    kaversion  := 0;
    IF  kaprindex <> 0
    THEN
        IF  sqlxa.sqlprp^[kaprindex].prarea <> cpr_in_sqlst
        THEN
            stbind := false
        ELSE
            pcstset := false;
        (*ENDIF*) 
&   ifdef TRACE
    (*ENDIF*) 
    m90int2 (pc, 'pcst vor    ', pcst );
    m90int2 (pc, 'kaStindex   ', kaStindex);
&   endif
    IF  (stbind) AND (pcstset)
    THEN
        IF  kaStindex + kaStcount - 1 = pcst
        THEN
            BEGIN
            pcst :=  kaStindex - 1;
            p19setsqlstindex (pcst);
            END;
&       ifdef TRACE
        (*ENDIF*) 
    (*ENDIF*) 
    m90int2 (pc, 'pcst nach   ', pcst );
    m90int2 (pc, 'kaStindex   ', kaStindex);
&   endif
    IF   kaStcount  > pcststm
    THEN
        pcststm :=  kaStcount;
    (*ENDIF*) 
    p14ifstbind := stbind;
    END;
(*ENDWITH*) 
END;
 
(*------------------------------*) 
 
PROCEDURE
      p14_dclgen   (
            PROCEDURE next_symbol (VAR p1: tpc_globals;
            VAR p2: tpc_partbuffer; p3: integer);
            VAR apc : tpc_globals;
            VAR dclgen : boolean;
            VAR fnlen  : integer);
 
VAR
      keyind : integer;
      len, i : integer;
      attrpos  : integer;
      pos      : integer;
 
BEGIN
WITH apc, pcscan, sqlca, pccmdpart, pcdclgen DO
    BEGIN
    next_symbol (apc, partbufp^, part1len);
    IF   (symb = cpr_s_eof) OR (symb = cpr_s_bufeof)
    THEN
        BEGIN
        dclgen  := false;
        sqlcxap^.xasqldap.sqldaptr^.sqln := 0;
        sqlcxap^.xasqldap.sqldaptr^.sqld := 0;
        END
    ELSE
        BEGIN
        (* pcdclgen default init *)
        dclgen     := true;
        asclause  := cpc_as_var;
        indclause := cpr_is_false;
        dcluser    := bsp_knl_identifier;
        dcltab     := bsp_knl_identifier;
        dcltabl    := 0;
        (* virt.filename length = fnlen *)
        clause [1].dclfnlen := fnlen;
        FOR i := 1 TO 2 DO
            WITH clause [i] DO
                BEGIN
                SAPDB_PascalForcedFill (sizeof(dclattr), @dclattr, 1, sizeof(dclattr), bsp_c1);
                dclattrl:= 0;
                END;
            (*ENDWITH*) 
        (*ENDFOR*) 
        p10getkeyword (apc, partbufp^, keyind);
        tabclause := 0;
        IF  keyind = cpc_i_table
        THEN
            tabclause := cpc_i_table
        ELSE
            IF  keyind =  cpc_i_dbproc
            THEN
                (* dbproc clause *)
                tabclause := cpc_i_dbproc
            ELSE
                p11wrerrorlisting (apc, cpc_invalid_sql_command);
            (*ENDIF*) 
        (*ENDIF*) 
        IF  tabclause  <>  0
        THEN
            BEGIN
            next_symbol (apc, partbufp^, part1len);
            p10getkeyword (apc, partbufp^, keyind);
            p19getname (apc, dcltab, len);
            dcltabl  := len;
            dclmodul := bsp_knl_identifier;
            next_symbol (apc, partbufp^, part1len);
            symb := p14symb (next_symbol, apc);
            IF  symb = cpr_s_point
            THEN
                BEGIN
                s10mv (mxsp_name, sizeof(dcluser), @dcltab, 1,
                      @dcluser, 1, sizeof(dcluser));
                dcltab     := bsp_knl_identifier;
                next_symbol (apc, partbufp^, part1len);
                p19getname (apc, dcltab, len);
                dcltabl := len;
                next_symbol (apc, partbufp^, part1len);
                END;
            (*ENDIF*) 
            symb := p14symb (next_symbol, apc);
            IF  symb = cpr_s_point
            THEN
                BEGIN
                next_symbol (apc, partbufp^, part1len);
                p19getname (apc, dclmodul, len);
                next_symbol (apc, partbufp^, part1len);
                END;
            (*ENDIF*) 
            p10getkeyword (apc, partbufp^, keyind);
            IF  keyind = cpc_i_as
            THEN
                BEGIN
                next_symbol (apc, partbufp^, part1len);
                p10getkeyword (apc, partbufp^, keyind);
                CASE keyind  OF
                    cpc_i_record :
                        asclause := cpc_as_record;
                    cpc_i_type :
                        asclause := cpc_as_type;
                    cpc_i_struct :
                        asclause := cpc_as_struct;
                    OTHERWISE:
                        asclause := cpc_as_var;
                    END;
                (*ENDCASE*) 
                next_symbol (apc, partbufp^, part1len);
                attrpos  := sypos;
                p10getkeyword (apc, partbufp^, keyind);
                IF  (keyind <> cpc_i_ind)
                    AND (symb <> cpr_s_eof) AND (symb <> cpr_s_bufeof)
                THEN
                    BEGIN
                    REPEAT
                        next_symbol (apc, partbufp^, part1len);
                        p10getkeyword (apc, partbufp^, keyind);
                    UNTIL
                        (keyind = cpc_i_ind) OR (symb = cpr_s_eof)
                        OR (symb = cpr_s_bufeof);
                    (*ENDREPEAT*) 
                    len := sypos - attrpos;
                    IF  len > mxsp_c80
                    THEN
                        len :=  mxsp_c80;
                    (*ENDIF*) 
                    s10mv (partsizlen, sizeof(clause[1].dclattr), 
                          @partbufp^, attrpos,
                          @clause[1].dclattr, 1, len);
                    clause[1].dclattrl := len;
                    END;
                (*ENDIF*) 
                END;
            (*ENDIF*) 
            attrpos  := syposacc;
            IF  keyind = cpc_i_ind
            THEN
                BEGIN
                indclause := cpr_is_true;
                REPEAT
                    next_symbol (apc, partbufp^, part1len);
                    p10getkeyword (apc, partbufp^, keyind);
                UNTIL
                    (symb = cpr_s_eof) OR (symb = cpr_s_bufeof);
                (*ENDREPEAT*) 
                pos := attrpos;
                WHILE (pos < sypos) DO
                    BEGIN
                    pos := pos + 1;
                    IF  partbufp^ [attrpos] = bsp_c1
                    THEN
                        attrpos := attrpos + 1
                    ELSE
                        pos := sypos;
                    (*ENDIF*) 
                    END;
                (*ENDWHILE*) 
                len := sypos - attrpos;
                IF  len > mxsp_c80
                THEN
                    len :=  mxsp_c80;
                (*ENDIF*) 
                s10mv (partsizlen, sizeof(clause[2].dclattr), 
                @partbufp^, attrpos,
                      @clause[2].dclattr, 1, len);
                clause[2].dclattrl := len;
                END;
            (*ENDIF*) 
            IF  (symb = cpr_s_eof) OR (symb = cpr_s_bufeof)
            THEN
                FOR i := 1 TO 2 DO
                    WITH clause [i] DO
                        BEGIN
                        len := s30lnr (dclattr, bsp_c1, 1, dclattrl);
                        IF  len = 0
                        THEN
                            BEGIN
                            dclattrl := dcltabl;
                            IF  i = 1
                            THEN
                                s10mv (sizeof(dcltab), sizeof(dclattr), @dcltab, 1,
                                      @dclattr, 1, dclattrl)
                            ELSE
                                BEGIN
                                s10mv (sizeof(dcltab), sizeof(dclattr), @dcltab, 1,
                                      @dclattr, 2, dclattrl);
                                dclattrl := dclattrl + 1;
                                dclattr [1] := 'I';
                                END;
                            (*ENDIF*) 
                            p05up1casebuf (dclattr, 1, dclattrl);
                            END;
                        (*ENDIF*) 
                        END;
                    (*ENDWITH*) 
                (*ENDFOR*) 
            (*ENDIF*) 
            END;
        (*ENDIF*) 
        END;
    (*ENDIF*) 
    END;
(*ENDWITH*) 
&ifdef TRACE
m90name(xx, 'END p14_dclgen    ');
&endif
END;
 
(*------------------------------*) 
 
PROCEDURE
      p14getname (
            PROCEDURE next_symbol (VAR p1: tpc_globals;
            VAR p2: tpc_partbuffer; p3: integer);
            VAR apc : tpc_globals;
            VAR  nam  : tsp00_KnlIdentifier;
            VAR  len  : integer;
            VAR  macro: tsp00_Int2
&           ifdef PREPSTMT
            ;
            VAR  param: tsp00_Int2
&           endif
            );
 
VAR
      mlen : integer;
      mpos : integer;
      pos  : integer;
 
BEGIN
WITH apc, pccmdpart, pcscan DO
    BEGIN
&   ifdef PREPSTMT
    IF  sylen = 0
    THEN
        next_symbol (apc, partbufp^, part1len);
&   endif
    (*ENDIF*) 
    mpos := sypos;
    mlen := sylen;
    IF  (symb = cpr_s_macro)
&       ifdef PREPSTMT
        OR (symb = cpr_s_parameter_name)
&       endif
    THEN
        BEGIN
&       ifdef PREPSTMT
        IF  symb = cpr_s_parameter_name
        THEN
            BEGIN
            param := cpr_is_true;
            macro := cpr_is_false;
            END
        ELSE
&           endif
            BEGIN
&           ifdef PREPSTMT
            param := cpr_is_false;
&           endif
            macro := cpr_is_true;
            END;
        (*ENDIF*) 
        mlen := sylen+1;
        END
    ELSE
        BEGIN
        macro := cpr_is_false;
&       ifdef PREPSTMT
        param := cpr_is_false;
&       endif
        IF  (symb <> cpr_s_identifier)
            AND  (symb <> cpr_s_unknown)  (*kanji*)
        THEN
            IF  (symb =  cpr_s_string_literal)
                OR (symb =  cpr_s_cstring_literal)
            THEN
                BEGIN
&               ifdef TRACE
                m90int2 (pc, 'len         ', len  );
                m90int2 (pc, 'mpos        ', mpos   );
                m90int2 (pc, 'symb        ', symb   );
                m90int2 (pc, 'sypos       ', sypos  );
                m90int2 (pc, 'sylen       ', sylen  );
                m90buf (pc, partbufp^ [1], 1 , part1len );
&               endif
                IF  partbufp^ [mpos] = '"'
                THEN
                    BEGIN
                    mpos := mpos + 1;
                    mlen := mlen - 2;
                    END;
                (*ENDIF*) 
                END
            ELSE
                p11precomerror (apc, cpc_invalid_sql_command);
            (*ENDIF*) 
        (*ENDIF*) 
        END;
    (*ENDIF*) 
    nam := bsp_knl_identifier;
    len := 0;
    pos := mpos;
    REPEAT
        IF  (partbufp^ [pos] = '"')
            AND  (partbufp^ [pos+1] = '"')
        THEN
            pos := pos + 1;
        (*ENDIF*) 
        len := len + 1;
        nam [len] := partbufp^ [pos];
        pos := pos + 1;
    UNTIL
        (len >= mxsp_c64) OR (pos >= mpos + mlen);
    (*ENDREPEAT*) 
    IF  partbufp^ [mpos-1] <> '"'
    THEN
        p05up2casebuf (nam, 1, len);
    (*ENDIF*) 
    END;
(*ENDWITH*) 
&ifdef TRACE
m90identifier (pc, nam);
m90name(xx, 'END p14getname    ');
&endif
END;
 
(*------------------------------*) 
 
PROCEDURE
      p14oradescribe (
            PROCEDURE next_symbol (VAR p1: tpc_globals;
            VAR p2: tpc_partbuffer; p3: integer);
            VAR apc : tpc_globals;
            VAR orakatyp : tsp00_Int2);
 
VAR
      keyind : integer;
 
BEGIN
WITH apc, pcscan, pccmdpart, sqlxa DO
    BEGIN
    orakatyp := cpr_com_ora_descr_sel;
    p10getkeyword (apc, partbufp^, keyind);
    IF  keyind = cpc_i_select
    THEN
        BEGIN
        next_symbol (apc, partbufp^, part1len);
        p10getkeyword (apc, partbufp^, keyind);
        IF  keyind <> cpc_i_list
        THEN
            p11precomerror (apc, cpc_invalid_sql_command)
        ELSE
            BEGIN
            next_symbol (apc, partbufp^, part1len);
            p10getkeyword (apc, partbufp^, keyind);
            IF  keyind <> cpc_i_for
            THEN
                p11precomerror (apc, cpc_invalid_sql_command)
            ELSE
                next_symbol (apc, partbufp^, part1len);
            (*ENDIF*) 
            END
        (*ENDIF*) 
        END
    ELSE
        IF  keyind = cpc_i_bind
        THEN
            BEGIN
            orakatyp := cpr_com_describe;
            next_symbol (apc, partbufp^, part1len);
            p10getkeyword (apc, partbufp^, keyind);
            IF  keyind <> cpc_i_variables
            THEN
                p11precomerror (apc, cpc_invalid_sql_command)
            ELSE
                BEGIN
                next_symbol (apc, partbufp^, part1len);
                p10getkeyword (apc, partbufp^, keyind);
                IF  keyind <> cpc_i_for
                THEN
                    p11precomerror (apc, cpc_invalid_sql_command)
                ELSE
                    next_symbol (apc, partbufp^, part1len);
                (*ENDIF*) 
                END
            (*ENDIF*) 
            END;
        (*ENDIF*) 
    (*ENDIF*) 
    END;
(*ENDWITH*) 
&ifdef TRACE
m90name(xx, 'END p14oradescribe');
&endif
END;
 
(*------------------------------*) 
 
PROCEDURE
      p14kaentryinit (VAR apc : tpc_globals);
 
BEGIN
WITH apc, sqlxa DO
    BEGIN
    p19sqlkaallocate (pcka);
    WITH sqlxa, sqlkap^ [pcka ], sqlca, sqlrap^ DO
        BEGIN
        katyp  := pcan.ancomtyp;
        kastate:= cpr_state_empty;
        kapacount := 0;
        kapaindex := 0;
        kaStcount := 0;
        kaStindex := 0;
        kaprindex  := 0;
        kaparamcnt := 0;
        kaversion  := -1;
        kadiindex  := 0;
        kafaindex  := 0;
        kamacro    := cpr_is_false;
        IF  pcinpind = cpc_inputfile
        THEN
            kalineno   := pclno.lnosrc
        ELSE
            kalineno   := - pclno.lnoexp;
        (*ENDIF*) 
        kamode    := rakamode;
        kaatindex := pckaatind;
        kacuindex := 0;
        xakano    := pcka;
        END;
    (*ENDWITH*) 
    END;
(*ENDWITH*) 
END;
 
.CM *-END-* code ----------------------------------------
.SP 2 
***********************************************************
*-PRETTY-*  statements    :       2152
*-PRETTY-*  lines of code :       5282        PRETTYX 3.10 
*-PRETTY-*  lines in file :       6463         1997-12-10 
.PA 
