.ad 8
.bm 8
.fm 4
.bt $Copyright (c) 2000-2004 SAP AG$$Page %$
.tm 12
.hm 6
.hs 3
.tt 1 $SQL$Project Distributed Database System$VPC19C$
.tt 2 $$$
.tt 3 $$Name and type table management$1999-09-20$
***************************************************************
.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
Module  :
=========
.sp
Purpose :
.CM *-END-* purpose -------------------------------------
Define  :
#define CALL

&ifdef DEBUG
&else
#line 28 "vpc19c"
&endif

void p19itab (tpc_globals *pc);
void p19ndallocate (tsp00_Int2 *index);
void p19vartypini (tpc_globals * pc);
void p19varallocate (tsp00_Int2 *index);
void p19cmpallocate (tsp00_Int2 *index);
void p19typallocate (tsp00_Int2 *index);
void p19sqlkaallocate (tsp00_Int2 *index);
void p19sqlprallocate (tsp00_Int2 *index);
void p19setprsqlindex (tsp00_Int2 * index);
void p19sqlstallocate (tsp00_Int2 *index);
void p19setsqlstindex (tsp00_Int2 * index);
void p19sqlfaallocate (tsp00_Int2 *index);
void p19sqlatallocate (tsp00_Int2 *index);
void p19sqlcuallocate (tsp00_Int2 *index);
void p19sqlfnallocate (tsp00_Int2 *index);
void p19sqlsdallocate (tsp00_Int2 *index);

tsp00_Uint4 *p19va1cnt ();
tsp00_Uint4 *p19va2cnt ();
tsp00_Uint4 *p19va3cnt ();
tsp00_Uint4 *p19parcnt ();
tsp00_Uint4 *p19ndcnt ();
tsp00_Uint4 *p19kacnt ();
tsp00_Uint4 *p19varcnt ();
tsp00_Uint4 *p19cmpcnt ();
tsp00_Uint4 *p19typcnt ();
void CALL p19scname (tpc_globals*, tsp00_Lname, int*);
void CALL p19typindex (tpc_globals*, int, tsp00_Int4, int, int, tsp00_Int2*);
void CALL p19ptrindex (tpc_globals*, int, tsp00_Int4, int, int, tsp00_Int2*);
void CALL p19varindex (tpc_globals*, const char*, int, tsp00_Int2*);
void CALL p19datova (tpc_globals*);
void p19sqlva (tpc_globals *pc, int vaindex, int typindex, int *va1index);
void p19glova (tpc_globals *pc, int vaindex, int typindex);
void p19cinitnamdesc (tpc_globals *pc, const tsp00_Int2 resolve,  
        const int parlen, const char *parname);
void p19cparentry (tpc_globals *pc, const tsp00_Int2 kindentry, 
	const tsp00_Int4 parm2, const tsp00_Int4 parm3, const tsp00_Int4 parm4 );
 
.CM *-END-* define --------------------------------------
Use     :
 
.CM *-END-* use -----------------------------------------
Synonym :
 
.CM *-END-* synonym -------------------------------------
.sp;.cp 3
Author  : 
.sp
.cp 3
Created : 1994-05-17
.sp
.cp 3
Version : 1994-05-17
.sp
.cp 3
Release :      Date : 1999-09-20
Specification:
.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
.sp
.CM -lll-
Code    :
/*PRETTY */
&ifdef DEBUG
&else
#line 107 "vpc19c"
&endif

static struct sqlmdesc p19sqlv1d =
{0, 0, sizeof (sqlva1en), MXPC_SQLVA1, 0};

static struct sqlmdesc p19sqlv2d =
{0, 0, sizeof (sqlva2en), MXPC_SQLVA2, 0};

static struct sqlmdesc p19sqlv3d =
{0, 0, sizeof (sqlva3en), MXPC_SQLVA3, 0};

static struct sqlmdesc p19sqlndd =
{0, 0, sizeof (tpc_nd_entry), MXPC_SQLND, 0};

static struct sqlmdesc p19varentd =
{0, 0, sizeof (tpc_varent), MXPC_VARENT, 0};

static struct sqlmdesc p19cmpentd =
{0, 0, sizeof (tpc_cmpent), MXPC_VARENT, 0};

static struct sqlmdesc p19typentd =
{0, 0, sizeof (tpc_typent), MXPC_TYPENT, 0};

#define p19mxsqlpar 100

static struct sqlmdesc p19parDesc =
{0, 0, sizeof (sqlparentry), p19mxsqlpar, 0};

/*** ka-area ***/
#define p19mxpr_sqlka 100
static struct sqlmdesc p19kadesc =
{0, 0, sizeof (sqlkaentry), p19mxpr_sqlka, 0};

/* Horst, 5.11.96, PTS 2739 */
tsp00_Uint4          *
p19kacnt ()
{
    return &p19kadesc.descNelem;
}     /*--------------------------------------------*/

void
p19sqlkaallocate (tsp00_Int2 * index)
{
    sqlkaentry    *kaent;

    kaent = (sqlkaentry *) p03dynalloc (&p19kadesc);
    *index = (tsp00_Int2) p19kadesc.descNelem;
}     /*--------------------------------------------*/

/*** pr-area ***/
#define p19mxpr_sqlpr 100
static struct sqlmdesc p19prdesc =
{0, 0, sizeof (sqlprentry), p19mxpr_sqlpr, 0};

void
p19sqlprallocate (tsp00_Int2 * index)
{
    sqlprentry    *prent;

    prent = (sqlprentry *) p03dynalloc (&p19prdesc);
    *index = (tsp00_Int2) p19prdesc.descNelem;
}     /*--------------------------------------------*/
void
p19setprsqlindex (tsp00_Int2 * index)
{
     p19prdesc.descNelem = *index;
}     /*--------------------------------------------*/

/*** st-area ***/
#define p19mxpr_sqlst 100
static struct sqlmdesc p19stdesc =
{0, 0, sizeof (sqlstentry), p19mxpr_sqlst, 0};

void
p19sqlstallocate (tsp00_Int2 * index)
{
    sqlstentry    *stent;

    stent = (sqlstentry *) p03dynalloc (&p19stdesc);
    *index = (tsp00_Int2) p19stdesc.descNelem;
}     /*--------------------------------------------*/
void
p19setsqlstindex (tsp00_Int2 * index)
{
     p19stdesc.descNelem = *index;
}     /*--------------------------------------------*/

/*** fa-area ***/
#define p19mxpr_sqlfa 100
static struct sqlmdesc p19fadesc =
{0, 0, sizeof (sqlfaentry), p19mxpr_sqlfa, 0};

void
p19sqlfaallocate (tsp00_Int2 * index)
{
    sqlfaentry    *faent;

    faent = (sqlfaentry *) p03dynalloc (&p19fadesc);
    *index = (tsp00_Int2) p19fadesc.descNelem;
}     /*--------------------------------------------*/

/*** at-area ***/
#define p19mxpr_sqlat 100
static struct sqlmdesc p19atdesc =
{0, 0, sizeof (sqlatentry), p19mxpr_sqlat, 0};

void
p19sqlatallocate (tsp00_Int2 * index)
{
    sqlatentry    *atent;

    atent = (sqlatentry *) p03dynalloc (&p19atdesc);
    *index = (tsp00_Int2) p19atdesc.descNelem;
}     /*--------------------------------------------*/

/*** cu-area ***/
#define p19mxpr_sqlcu 100
static struct sqlmdesc p19cudesc =
{0, 0, sizeof (sqlcuentry), p19mxpr_sqlcu, 0};

void
p19sqlcuallocate (tsp00_Int2 * index)
{
    sqlcuentry    *cuent;

    cuent = (sqlcuentry *) p03dynalloc (&p19cudesc);
    *index = (tsp00_Int2) p19cudesc.descNelem;
}     /*--------------------------------------------*/

/*** fn-area ***/
#define p19mxpr_sqlfn 100
static struct sqlmdesc p19fndesc =
{0, 0, sizeof (sqlfnentry), p19mxpr_sqlfn, 0};

void
p19sqlfnallocate (tsp00_Int2 * index)
{
    sqlfnentry    *fnent;

    fnent = (sqlfnentry *) p03dynalloc (&p19fndesc);
    *index = (tsp00_Int2) p19fndesc.descNelem;
}     /*--------------------------------------------*/

void
p19itab (tpc_globals * pc)
{
    p19sqlv1d.descElemPtr = (void**) &pc->sqlxa.sqlv1p; /* Schwachsinn */
    p19sqlv2d.descElemPtr = (void**) &pc->sqlxa.sqlv2p; /* fuer ALPHA */
    p19sqlv3d.descElemPtr = (void**) &pc->sqlxa.sqlv3p; /* ... */
    p19sqlndd.descElemPtr = (void**) &pc->pcSqlva.ndtabp; /* ... */
    p19kadesc.descElemPtr = (void**) &pc->sqlxa.sqlkap;
    p19prdesc.descElemPtr = (void**) &pc->sqlxa.sqlprp;
    p19stdesc.descElemPtr = (void**) &pc->sqlxa.sqlstp;
    p19fadesc.descElemPtr = (void**) &pc->sqlxa.sqlfap;
    p19atdesc.descElemPtr = (void**) &pc->sqlxa.sqlatp;
    p19cudesc.descElemPtr = (void**) &pc->sqlxa.sqlcup;
    p19fndesc.descElemPtr = (void**) &pc->sqlxa.sqlfnp;
}     /*--------------------------------------------*/

void
p19ndallocate (tsp00_Int2 * index)
{
    tpc_nd_entry     *ndt;

    ndt = (tpc_nd_entry *) p03dynalloc (&p19sqlndd);
    *index = (tsp00_Int2) p19sqlndd.descNelem;
}     /*--------------------------------------------*/

tsp00_Uint4          *
p19ndcnt ()
{
    return &p19sqlndd.descNelem;
}     /*--------------------------------------------*/

void
p19vartypini (tpc_globals * pc)
{
    p19varentd.descElemPtr = (void**) &pc->pcSymtab.vartablep;
    p19typentd.descElemPtr = (void**) &pc->pcSymtab.typtablep;
    p19cmpentd.descElemPtr = (void**) &pc->pcSymtab.cmpindexp;
}     /*--------------------------------------------*/

void
p19varallocate (tsp00_Int2 * index)
{
    tpc_varent     *vart;

    vart = (tpc_varent *) p03dynalloc (&p19varentd);
    *index = (tsp00_Int2) p19varentd.descNelem;
}     /*--------------------------------------------*/

void
p19cmpallocate (tsp00_Int2 * index)
{
    tpc_cmpent     *cmpt;

    cmpt = (tpc_cmpent *) p03dynalloc (&p19cmpentd);
    *index = (tsp00_Int2) p19cmpentd.descNelem;
}     /*--------------------------------------------*/

tsp00_Uint4          *
p19varcnt ()
{
    return &p19varentd.descNelem;
}     /*--------------------------------------------*/

tsp00_Uint4          *
p19cmpcnt ()
{
    return &p19cmpentd.descNelem;
}     /*--------------------------------------------*/

void
p19typallocate (tsp00_Int2 * index)
{
    tpc_typent     *typt;

    typt = (tpc_typent *) p03dynalloc (&p19typentd);
    *index = (tsp00_Int2) p19typentd.descNelem;
}     /*--------------------------------------------*/

tsp00_Uint4          *
p19typcnt ()
{
    return &p19typentd.descNelem;
}     /*--------------------------------------------*/

&if $OS != MSDOS
void
p19icsec (tpc_globals * pc)
/* for precompilers with nondynamic csects only; may be deleted later */
{
    static tpc_const_entry csec[MXPC_CONST_SEC];

    pc->pcCse.csec = csec;
}     /*--------------------------------------------*/
&endif

tsp00_Uint4          *
p19va1cnt ()
{
    return &p19sqlv1d.descNelem;
}     /*--------------------------------------------*/

tsp00_Uint4          *
p19va2cnt ()
{
    return &p19sqlv2d.descNelem;
}     /*--------------------------------------------*/

tsp00_Uint4          *
p19va3cnt ()
{
    return &p19sqlv3d.descNelem;
}     /*--------------------------------------------*/

static void
p19va2index (tpc_globals * pc, int vtyp, tsp00_Int4 vsize, int vdig,
    int vfrac, int vconst, tsp00_Int2 * index)
{
    tsp00_Int2        i = pc->pcSqlva.va2cnt;
    sqlva2en       *v2t = pc->sqlxa.sqlv2p + i - 1;

    *index = 0;
    while (i > *index)
        {
        if ((int) v2t->va2typ == vtyp && v2t->va2size == vsize &&
            (int) v2t->va2digit == vdig &&
            (int) v2t->va2frac == vfrac &&
            (int) v2t->va2const == vconst)
            *index = i;
        i--;
        v2t--;
        }
}     /*--------------------------------------------*/

static void
p19va3index (tpc_globals * pc, tsp00_Lname vnam, tsp00_Int2 * index)
{
    tsp00_Int2        i = pc->pcSqlva.va3cnt;
    sqlva3en       *v3t = pc->sqlxa.sqlv3p + i - 1;

    *index = 0;
    while (i > *index)
        {
        if (memcmp (v3t->va3name, vnam, sizeof (v3t->va3name)) == 0)
            *index = i;
        i--;
        v3t--;
        }
}     /*--------------------------------------------*/

static void
p19vatab (tpc_globals * pc, int cnt, int vaix, int typix,
    tsp00_Int2 indi, int sconst)
{
    tpc_varent      *vt = pc->pcSymtab.vartablep + vaix - 1;
    tpc_typent      *tt = pc->pcSymtab.typtablep + typix - 1;
    int             i, j, va2c;
    tsp00_Int2        v2ix, v3ix;

    if (pc->pcError != CPC_PRE_OK)
        return;

    if (tt->st.tyIndi == CPR_VSTRUCT)
        {
        vt->vacnt = 0;
        tt->st.tyVacnt = 0;
        if (tt->st.tyRef == 0)
            tt->st.tyRef = 1;
        for (j = 0; j < tt->st.tyCmCnt; j++)
            {
            tsp00_Int2        vaix1 =
            pc->pcSymtab.cmpindexp[tt->st.tyCmpIx + j - 1];
            tpc_varent      *vt1 = pc->pcSymtab.vartablep + vaix1 - 1;
            tsp00_Int2        typix1 = vt1->vatypix;

            vt1->vasqlix = pc->pcSqlva.va1cnt + (tsp00_Int2) 1;
            p19vatab (pc, 1, vaix1, typix1, indi,
                sconst || (vt->vaglobl / CPC_CCONST));
            vt->vacnt += vt1->vacnt;
            tt->st.tyVacnt += vt1->vacnt;
            }
        if (cnt > 1)
            for (i = 2; i <= cnt; i++)
                for (j = 0; j < tt->st.tyCmCnt; j++)
                    {
                    tsp00_Int2        vaix1 =
                    pc->pcSymtab.cmpindexp
                    [tt->st.tyCmpIx + j - 1];
                    tpc_varent      *vt1 =
                    pc->pcSymtab.vartablep + vaix1
                    - 1;
                    tsp00_Int2        typix1 = vt1->vatypix;

                    vt1->vasqlix = pc->pcSqlva.va1cnt +
                        (tsp00_Int2) 1;
                    p19vatab (pc, 1, vaix1, typix1, indi,
                        sconst ||
                        (vt->vaglobl / CPC_CCONST));
                    vt->vacnt += vt1->vacnt;
                    }
        }
    else if (tt->ar.tyIndi == CPR_VARRAY)
        {
        p19vatab (pc, cnt * tt->ar.tyDim, vaix, tt->ar.tyTypIx, indi,
            sconst || (vt->vaglobl / CPC_CCONST));
        }
    else
        {
        tsp00_Int2        ref = (tsp00_Int2) ((indi == SQLVASC) ? 1 : 2);

        if ((tt->sc.tyRef & (ref << 2)) == 0)
            tt->sc.tyRef |= ref;
        va2c = ((sconst && tt->sc.tyPtr == 0) ||
            vt->vaglobl / CPC_CCONST) ? 1 : 0;
        p19va2index (pc, tt->sc.tyIndi, tt->sc.tySize,
            tt->sc.tyDigit, tt->sc.tyFrac, va2c, &v2ix);
        if (v2ix == 0)
            {
            sqlva2en       *v2t = (sqlva2en *) p03dynalloc (&p19sqlv2d);

            v2ix = pc->pcSqlva.va2cnt + (tsp00_Int2) 1;
            v2t->va2typ = tt->sc.tyIndi;
            v2t->va2size = tt->sc.tySize;
            v2t->va2digit = tt->sc.tyDigit;
            v2t->va2frac = tt->sc.tyFrac;
            v2t->va2const = (tsp00_Int2) va2c;
            pc->pcSqlva.va2cnt = v2ix;
            }
        p19va3index (pc, vt->vaname, &v3ix);
        if (v3ix == 0)
            {
            sqlva3en       *v3t = (sqlva3en *) p03dynalloc (&p19sqlv3d);

            v3ix = pc->pcSqlva.va3cnt + (tsp00_Int2) 1;
            memcpy (v3t->va3name, vt->vaname,
                sizeof (v3t->va3name));
            v3t->va3naml = vt->vanaml;
            pc->pcSqlva.va3cnt = v3ix;
            }
        for (i = 0; i < cnt; i++)
            {
            sqlva1en       *v1t = (sqlva1en *) p03dynalloc (&p19sqlv1d);

            v1t->sc.va1indi = indi;
            v1t->sc.va1indva2 = v2ix;
            v1t->sc.va1indva3 = v3ix;
            }
        pc->pcSqlva.va1cnt += cnt;
        vt->vacnt = (tsp00_Int2) cnt;
        }
}     /*--------------------------------------------*/

void
p19sqlva (tpc_globals * pc, int vaindex, int typindex, int *va1index)
{
    tpc_varent      *vt = pc->pcSymtab.vartablep + vaindex - 1;
    tpc_typent      *tt = pc->pcSymtab.typtablep + typindex - 1;
    tsp00_Int2        indi = (tsp00_Int2) (
        (tt->st.tyIndi == CPR_VSTRUCT || tt->ar.tyIndi == CPR_VARRAY) ?
        SQLVACM : SQLVASC);
    tsp00_Int2        vindi = (tsp00_Int2) ((tt->sc.tyPtr == 1) ? SQLVACM : indi);
    sqlva1en       *v1n;

    M90TRACE (M90_TR_ENTRY, "p19sqlva ", 0);
    vt->vasqlix = pc->pcSqlva.va1cnt + (tsp00_Int2) 1;
    p19vatab (pc, 1, vaindex, typindex, vindi, vt->vaglobl / CPC_CCONST);
    *va1index = pc->pcSqlva.va1cnt;
    if (indi == SQLVACM)
        {
        v1n = (sqlva1en *) p03dynalloc (&p19sqlv1d);
        v1n->st.va1indi = SQLVAST;
        v1n->st.va1cmpcnt = vt->vacnt;
        v1n->st.va1ix = vt->vasqlix;
        M90TRACE (M90_TR_SWORD, "v1n->st.va1ix   ", &v1n->st.va1ix);
        (*va1index)++;
        }
    if (tt->sc.tyPtr == 1)
        {
        v1n = (sqlva1en *) p03dynalloc (&p19sqlv1d);
        v1n->pt.va1indi = SQLVAPT;
        v1n->pt.va1addr = NULL;
        v1n->pt.va1ix = (*va1index > (int) pc->pcSqlva.va1cnt) ?
            *va1index : vt->vasqlix;
        M90TRACE (M90_TR_SWORD, "v1n->pt.va1ix   ", &v1n->pt.va1ix);
        (*va1index)++;
        }
    pc->pcSqlva.va1cnt = (tsp00_Int2) * va1index;
    M90TRACE (M90_TR_EXIT, "p19sqlva ", 0);
}     /*--------------------------------------------*/

void
p19glova (tpc_globals * pc, int vaindex, int typindex)
{
    tpc_varent      *vt = pc->pcSymtab.vartablep + vaindex - 1;
    tpc_typent      *tt = pc->pcSymtab.typtablep + typindex - 1;
    tsp00_Int2        indi = (tsp00_Int2) (
        (tt->st.tyIndi == CPR_VSTRUCT || tt->ar.tyIndi == CPR_VARRAY) ?
        SQLVACM : SQLVASC);

    if (pc->pcSqlva.va1cnt > MXPC_SQLVA1)
        p11precomerror (pc, CPC_TOO_MANY_VAR_DECLARED);
    else if (vt->vaglobl == 1)
        {
        vt->vasqlix = pc->pcSqlva.va1cnt + (tsp00_Int2) 1;
        p19vatab (pc, 1, vaindex, typindex, indi,
            vt->vaglobl / CPC_CCONST);
        }
}     /*--------------------------------------------*/


tsp00_Uint4          *
p19parcnt ()
{
    return &p19parDesc.descNelem;
}     /*--------------------------------------------*/

void
p19cinitnamdesc (tpc_globals * pc, const tsp00_Int2 resolve,
    const int parlen, const char *parname)
{
    int             found = 0;
    tsp00_Int2        i;
    tsp00_Int2        eins = 1;
    tsp00_Int4        pos;
    tsp00_Int2        tyix;
    tsp00_Int2        lasttyix;
    int             index = 0;
    tpc_nd_entry     *ndt;
    tpc_pc_sqlva       *pva = &pc->pcSqlva;
    tsp00_Int2        ndind = pva->ndmax;
    tpc_varent      *vth = pc->pcSymtab.vartablep;
    tpc_typent      *tth = pc->pcSymtab.typtablep;
    sqlva1en       *va1h;

    M90TRACE (M90_TR_ENTRY, "p19cinitnamedesc", 0);
    M90TRACE (M90_TR_SWORD, "pc->pcKa ndkano ", &pc->pcKa);
    M90TRACE (M90_TR_SWORD, "ndind           ", &ndind);
    i = 0;
    if (ndind == 0)
        {
        /* addr des pointers nach desciptor bringen */
        p19sqlndd.descElemPtr = (void**) &pc->pcSqlva.ndtabp; /* ... */
        }
    else
        {
        ndt = pva->ndtabp;
        while ((!found) && (i < ndind - eins))
            {
     M90TRACE (M90_TR_SWORD, "i *****         ", &i    );
     M90TRACE (M90_TR_SWORD, "ndt->ndArrayCnt  ", &ndt->ndArrayCnt );
     M90TRACE (M90_TR_SWORD, "pva->ndArrayCnt  ",
                         &pva->ndtabp[ndind - eins]
                         .ndArrayCnt);
     M90TRACE (M90_TR_SWORD, "ndt->ndBlockId  ", &ndt->ndBlockId );
     M90TRACE (M90_TR_SWORD, "vth->ndBlockId  ", 
                        &vth[ndt->ndVararrIx - 1].vablockid);
     M90TRACE (M90_TR_SWORD, "ndt->ndVararrIx ", &ndt->ndVararrIx );
            if (ndt->ndNamelen == (tsp00_Int2) parlen)
                {
                found = ((strcmp (parname,
                            ndt->ndNamePtr) == 0)
                    && (ndt->ndArrayCnt ==
                        pva->ndtabp[ndind - eins].ndArrayCnt)
                    && (ndt->ndBlockId ==
   /**bf20.3.96***/     pva->ndtabp[ndind - eins].ndBlockId));
               /**         vth[ndt->ndVararrIx - 1].vablockid));***/
                }
            if (!found)
                {
                i++;
                ndt++;
                }
            }
        }
    M90TRACE (M90_TR_SWORD, "name found<>0", &found);
    M90TRACE (M90_TR_SWORD, "  i     ", &i);
    if (found)
        {
        /* VARNAME GEFUNDEN */
        /* keinen neuen entry in ndtable */
        ndt->ndKano = pc->pcKa;
        pva->ndcnt = i + eins;
        p19sqlndd.descNelem--;
        pc->pcSqlva.ndmax--;
        M90TRACE (M90_TR_SWORD, "found ndcnt  ",
            &pc->pcSqlva.ndcnt);
        M90TRACE (M90_TR_SWORD, "found ndmax-1",
            &pc->pcSqlva.ndmax);
        }
    else
        {
		BOOLEAN ok;
        /* neuen entry erzeugen */
        /* allocate ndt entry */
        ndt->ndKano = pc->pcKa;
        ndt->ndExpanlen = (tsp00_Int2) parlen;
        ndt->ndNamelen = (tsp00_Int2) parlen;
        ndt->ndBlockId = vth[ndt->ndVarentIx - 1].vablockid;
	sqlallocat (parlen + 14, (tsp00_Uint1**)&ndt->ndNamePtr, &ok);
        strcpy (ndt->ndNamePtr, parname);
        M90TRACE (M90_TR_SWORD, "ndVarentIx", &ndt->ndVarentIx);
        M90TRACE (M90_TR_SWORD, "ndind     ", &ndind);
        lasttyix = ndt->ndTypentIx;
        tyix = vth[ndt->ndVararrIx - 1].vatypix;
        ndt->ndLoopPar = SQLPAREL;
        M90TRACE (M90_TR_SWORD, "reslove    ", &resolve);
        if (resolve == cpr_is_false)
            {
            if ((ndt->ndMainTyindi == CPR_VARRAY)
                && (ndt->ndVararrIx == ndt->ndVarentIx))
                {
                tyix = tth[tyix - eins].
                    ar.tyTypIx;
                M90TRACE (M90_TR_SWORD, "tyix       ", &tyix);
                ndt->ndCompExpan = cpr_is_true;
                if (ndt->ndArrayCnt == 0)
                    {
                    ndt->ndLoopPar = SQLPARLO;
                    }
                }
            }
        M90TRACE (M90_TR_SWORD, "tyix vp19sqlva", &tyix);
        M90TRACE (M90_TR_SWORD, "lasttyix      ", &lasttyix);
        M90TRACE (M90_TR_SWORD, "ndLoopPar     ",
            &ndt->ndLoopPar);
        ndt->ndTypentIx = tyix;
        i = 0;
        found = 0;
        while ((!found) && (i < ndind - eins))
            {
            M90TRACE (M90_TR_SWORD, "ndmaintyindi  ",
                &ndt->ndMainTyindi);
            if ((ndt->ndMainTyindi == CPR_VARRAY)
                && (ndt->ndCompExpan == cpr_is_true))
                {
                found = ((ndt->ndVararrIx ==
                        pva->ndtabp[i].ndVararrIx)
                    && (ndt->ndBlockId ==
                        pva->ndtabp[i].ndBlockId)
                    && (ndt->ndArrayIx[0] ==
                        pva->ndtabp[i].ndArrayIx[0])
                    && (ndt->ndTypentIx ==
                        pva->ndtabp[i].ndTypentIx));
                }
            else
                {
                found = ((ndt->ndVararrIx ==
                        pva->ndtabp[i].ndVararrIx)
                    && (ndt->ndBlockId ==
                        pva->ndtabp[i].ndBlockId)
                    && (ndt->ndTypentIx ==
                        pva->ndtabp[i].ndTypentIx));
                }
            if (found)
                {
                index = (int) pva->ndtabp[i]
                    .ndSqlva1St;
                if ((ndt->ndBlockId != 0)
                    && (pc->sqlca.sqlrap->ralang == CPR_LA_C))
                    {
                    if (ndt->ndKano ==
                        pva->ndtabp[i].ndKano)
                        ndt->ndExpanlen = 0;
                    else
                        ndt->ndExpanlen =
                            ndt->ndNamelen;
                    }
                M90TRACE (M90_TR_SWORD, "found<>0", &i);
                M90TRACE (M90_TR_SWORD, "index   ",
                    &index);
                }
            i++;
            }
        if (!found)
            p19sqlva (pc, ndt->ndVararrIx,
                tyix, &index);
        va1h = pc->sqlxa.sqlv1p;
        M90TRACE (M90_TR_SWORD, "index np",
            &index);
        ndt->ndSqlva1St = index;
        M90TRACE (M90_TR_SWORD, "ndSqlva1St",
            &ndt->ndSqlva1St);
        pos = 0;
        if (va1h[index - eins].st.va1indi == SQLVAPT)
            index = va1h[ndt->ndSqlva1St - eins]
                .pt.va1ix;
        M90TRACE (M90_TR_SWORD, "index pt  ", &index);
        if (va1h[index - eins].st.va1indi == SQLVAST)
            {
            index = va1h[index - eins]
                .st.va1ix;
            M90TRACE (M90_TR_SWORD, "index st  ", &index);
            M90TRACE (M90_TR_SWORD, "p/st.va1indi  ",
                &va1h[index - eins].st.va1indi);
            if (((tth[lasttyix - eins].st.tyIndi
                        == CPR_VSTRUCT)
                    || (tth[lasttyix - eins]
                        .st.tyIndi == CPR_VARRAY))
                && (ndt->ndMainTyindi == CPR_VARRAY)
                && (ndt->ndArrayCnt == 1))
                ndt->ndCompIx = -1;
            }
        else
            ndt->ndCompIx = -1;
        if ((ndt->ndVararrIx != ndt->ndVarentIx)
            || (ndt->ndCompIx != -1))
            {
            pos = ndt->ndCompIx;
            }
        M90TRACE (M90_TR_SWORD, "pos   1   ", &pos);
        M90TRACE (M90_TR_SWORD, "index 1   ", &index);
        ndt->ndSqlva1Ix = index + (tsp00_Int4) pos;
        M90TRACE (M90_TR_SWORD, "new   ndcnt",
            &pc->pcSqlva.ndcnt);
        M90TRACE (M90_TR_SWORD, "ndSqlva1Ix", &ndt->ndSqlva1Ix);
        pc->pcSqlva.ndcnt = (tsp00_Int2) p19sqlndd.descNelem;
        pc->pcSqlva.ndmax = (tsp00_Int2) p19sqlndd.descNelem;
        }
    M90TRACE (M90_TR_EXIT, "p19cinitnamedesc", 0);
}     /*--------------------------------------------*/

void
p19cparentry (tpc_globals * pc,
    const tsp00_Int2 kindentry,
    const tsp00_Int4 parm2,
    const tsp00_Int4 parm3,
    const tsp00_Int4 parm4)
{
    sqlparentry    *parentp;
    int             size;

    M90TRACE (M90_TR_ENTRY, "p19cparentry", 0);
    if (p19parDesc.descNelem == 0)
        p19parDesc.descElemPtr = (void**) &pc->sqlxa.sqlpap; /* ... */
    parentp = (sqlparentry *) p03dynalloc (&p19parDesc);
    pc->pcPa = (tsp00_Int2) p19parDesc.descNelem;
    M90TRACE (M90_TR_SWORD, "par index ", &pc->pcPa);
    size = sizeof (sqlparentry);
    M90TRACE (M90_TR_SWORD, "size parentry ", &size);
    switch (kindentry)
        {
        case SQLPARLO:
            {
                /* loob entry */
                /* parm2  loopcnt, parm3 loopmin */
                sqlparlooptyp  *palo = &parentp->lo;

                palo->pakind = SQLPARLO;
                palo->pava1index = 0;
                palo->paloopcnt = 0;
                palo->paloopmin = (sqlint4) parm3;
                if (parm2 < 0)
                    palo->pava1index = (sqlint2) - parm2;
                else
                    palo->paloopcnt = (sqlint4) parm2;
                M90TRACE (M90_TR_SWORD, "pakind loo", &palo->pakind);
                M90TRACE (M90_TR_SWORD, "pava1index", &palo->pava1index);
                M90TRACE (M90_TR_SWORD, "paloopcnt ", &palo->paloopcnt);
                M90TRACE (M90_TR_SWORD, "paloopmin ", &palo->paloopmin);
                break;
            }
        case SQLPARST:
            {
                /* scalar entry */
                sqlparstructyp *pasc = &parentp->st;

                pasc->pakind = SQLPARST;
                pasc->pavarst = (sqlint2) parm2;
                pasc->paindst = (sqlint2) parm3;
                pasc->paelcnt = (sqlint2) parm4;
                pasc->pafill4 = 0;
                M90TRACE (M90_TR_SWORD, "pakindst  ", &pasc->pakind);
                M90TRACE (M90_TR_SWORD, "pavarst   ", &pasc->pavarst);
                M90TRACE (M90_TR_SWORD, "paindst   ", &pasc->paindst);
                M90TRACE (M90_TR_SWORD, "paelcnt   ", &pasc->paelcnt);
                break;
            }
        case SQLPAREL:
            {
                /* scalar entry */
                sqlparelemtyp  *pasc = &parentp->el;

                pasc->pakind = SQLPAREL;
                pasc->pavarno = (sqlint2) parm2;
                pasc->paindno = (sqlint2) parm3;
                M90TRACE (M90_TR_SWORD, "pakind el ", &pasc->pakind);
                M90TRACE (M90_TR_SWORD, "pavarno   ", &pasc->pavarno);
                M90TRACE (M90_TR_SWORD, "paindno   ", &pasc->paindno);
                break;
            }
        default:
            parentp->lo.pakind = -1;
            M90TRACE (M90_TR_SWORD, "pakind default", &parentp->lo.pakind);
        }

    M90TRACE (M90_TR_EXIT, "p19cparentry", 0);
}     /*--------------------------------------------*/
.CM *-END-* code ----------------------------------------
.SP 2 
***********************************************************
*-PRETTY-*  statements    :       3101
*-PRETTY-*  lines of code :       3101        PRETTY  3.09 
*-PRETTY-*  lines in file :       3172         1992-11-23 
.PA 
