vbdataio.c File Reference

#include "isinternal.h"

Include dependency graph for vbdataio.c:

Go to the source code of this file.

Data Structures
struct	SVARLEN

Functions
static off_t	ttailnode (const int ihandle, char *pcbuffer, const int ilength, int *pislotnumber)
static int	ivbvarlenread (const int ihandle, char *pcbuffer, off_t tnodenumber, int islotnumber, int ilength)
static int	ivbvarlenwrite (const int ihandle, char *pcbuffer, int ilength)
static int	ivbvarlendelete (const int ihandle, off_t tnodenumber, int islotnumber, int ilength)
int	ivbdataread (const int ihandle, char *pcbuffer, int *pideletedrow, const off_t trownumber)
int	ivbdatawrite (const int ihandle, char *pcbuffer, int ideletedrow, const off_t trownumber)

Variables
static const int	igroupsize []
static char	cnode [4096]
static struct SVARLEN *	psvarlenheader = (struct SVARLEN *)cnode

Function Documentation

int ivbdataread	(	const int	ihandle,
		char *	pcbuffer,
		int *	pideletedrow,
		const off_t	trownumber
	)

Definition at line 493 of file vbdataio.c.

References cvbnodetmp, DICTINFO::idatahandle, DICTINFO::iminrowlength, inl_ldint(), inl_ldquad(), DICTINFO::inodesize, DICTINFO::iopenmode, iserrno, isreclen, DICTINFO::ivarlenlength, DICTINFO::ivarlenslot, ivbblockread(), ivbmaxusedhandle, ivbvarlenread(), MAX_RESERVED_LENGTH, psvbfile, QUADSIZE, DICTINFO::tvarlennode, tvblseek(), tvbread(), unlikely, and VB_NODE_MAX.

Referenced by idatacheck(), imakekeysfromdata(), iprocessdelete(), isread(), isrewcurr(), isrewrec(), isrewrite(), istartrownumber(), and vrebuildkeys().

{
    struct DICTINFO *psvbptr;
    off_t       tblocknumber, toffset, tsofar;
    int     irowlength;
    int     n;
    char        cfooter[VB_NODE_MAX];
    char        cvbnodetmp[VB_NODE_MAX];
    char        pcreadbuffer[MAX_RESERVED_LENGTH];

    /* Sanity check - Is ihandle a currently open table? */
    if (unlikely(ihandle < 0 || ihandle > ivbmaxusedhandle)) {
        return ENOTOPEN;
    }
    if (!psvbfile[ihandle]) {
        return ENOTOPEN;
    }
    if (trownumber < 1) {
        return EBADARG;
    }
    psvbptr = psvbfile[ihandle];

    irowlength = psvbptr->iminrowlength;
    irowlength++;
    if (psvbptr->iopenmode & ISVARLEN) {
        irowlength += INTSIZE + QUADSIZE;
    } else {
/* RXW */
        toffset = irowlength * (trownumber - 1);
        if (tvblseek (psvbptr->idatahandle, toffset, SEEK_SET) != toffset) {
            return EBADFILE;
        }
        memset (pcreadbuffer, 0, irowlength);
        if (tvbread (psvbptr->idatahandle, pcreadbuffer, (size_t)irowlength) < 0) {
            return EBADFILE;
        }
        memcpy (pcbuffer, pcreadbuffer, (size_t)psvbptr->iminrowlength);
        if (pcreadbuffer[psvbptr->iminrowlength] == 0) {
            *pideletedrow = 1;
        } else {
            *pideletedrow = 0;
        }
        isreclen = psvbptr->iminrowlength;
        return 0;
    }
    toffset = irowlength * (trownumber - 1);
    tblocknumber = (toffset / psvbptr->inodesize);
    toffset -= (tblocknumber * psvbptr->inodesize);
    if (ivbblockread (ihandle, 0, tblocknumber + 1, cvbnodetmp)) {
        return EBADFILE;
    }
    /* Read in the *MINIMUM* rowlength and store it into pcbuffer */
    tsofar = 0;
    while (tsofar < psvbptr->iminrowlength) {
        if ((psvbptr->iminrowlength - tsofar) < (psvbptr->inodesize - toffset)) {
            memcpy (pcbuffer + tsofar, cvbnodetmp + toffset,
                (size_t)(psvbptr->iminrowlength - tsofar));
            toffset += psvbptr->iminrowlength - tsofar;
            tsofar = psvbptr->iminrowlength;
            break;
        }
        memcpy (pcbuffer + tsofar, cvbnodetmp + toffset, (size_t)(psvbptr->inodesize - toffset));
        tblocknumber++;
        tsofar += psvbptr->inodesize - toffset;
        toffset = 0;
        if (ivbblockread (ihandle, 0, tblocknumber + 1, cvbnodetmp)) {
            return EBADFILE;
        }
    }
    pcbuffer += tsofar;
    /* OK, now for the footer.  Either 1 byte or 1 + INTSIZE + QUADSIZE. */
    while (tsofar < irowlength) {
        if ((irowlength - tsofar) <= (psvbptr->inodesize - toffset)) {
            memcpy (cfooter + tsofar - psvbptr->iminrowlength, cvbnodetmp + toffset,
                (size_t)(irowlength - tsofar));
            break;
        }
        memcpy (cfooter + tsofar - psvbptr->iminrowlength, cvbnodetmp + toffset,
            (size_t)(psvbptr->inodesize - toffset));
        tblocknumber++;
        tsofar += psvbptr->inodesize - toffset;
        toffset = 0;
        if (ivbblockread (ihandle, 0, tblocknumber + 1, cvbnodetmp)) {
            return EBADFILE;
        }
    }
    isreclen = psvbptr->iminrowlength;
    *pideletedrow = 0;
    if (cfooter[0] == 0x00) {
        *pideletedrow = 1;
    } else {
        if (psvbptr->iopenmode & ISVARLEN) {
            psvbptr->ivarlenlength = inl_ldint (cfooter + 1);
/* VBISAM in 64 bit mode (4k Nodes) uses a ten bit slot number */
/* VBISAM in 32 bit mode (1k Nodes) uses an eight bit slot number */
#if ISAMMODE == 1
            n = inl_ldint (cfooter + 1 + INTSIZE);
            psvbptr->ivarlenslot =  n >> 6;
            *(cfooter + 1 + INTSIZE + 1) &= (unsigned char)0x3f;
#else
            psvbptr->ivarlenslot = *(cfooter + 1 + INTSIZE);
#endif
            *(cfooter + 1 + INTSIZE) = 0;
            psvbptr->tvarlennode = inl_ldquad (cfooter + 1 + INTSIZE);
            if (psvbptr->ivarlenlength) {
                if (ivbvarlenread (ihandle, (char *)pcbuffer,
                     psvbptr->tvarlennode,
                     psvbptr->ivarlenslot, psvbptr->ivarlenlength)) {
                    return iserrno;
                }
            }
            isreclen += psvbptr->ivarlenlength;
        }
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ivbdatawrite	(	const int	ihandle,
		char *	pcbuffer,
		int	ideletedrow,
		const off_t	trownumber
	)

Definition at line 611 of file vbdataio.c.

References cvbnodetmp, DICTINFO::idatahandle, DICTINFO::iminrowlength, inl_ldint(), inl_stint(), inl_stquad(), DICTINFO::inodesize, DICTINFO::iopenmode, iserrno, isreclen, DICTINFO::ivarlenlength, DICTINFO::ivarlenslot, ivbblockread(), ivbblockwrite(), ivbmaxusedhandle, ivbvarlendelete(), ivbvarlenwrite(), MAX_RESERVED_LENGTH, pcwritebuffer, psvbfile, QUADSIZE, DICTINFO::tvarlennode, tvblseek(), tvbwrite(), unlikely, and VB_NODE_MAX.

Referenced by iprocessdelete(), isrewcurr(), isrewrec(), isrewrite(), and ivbwriterow().

{
    struct DICTINFO *psvbptr;
    char        *pctemp;
    off_t       tblocknumber, toffset, tsofar;
    int     irowlength;
    int     n;
    char        cvbnodetmp[VB_NODE_MAX];
    char        pcwritebuffer[MAX_RESERVED_LENGTH];

    /* Sanity check - Is ihandle a currently open table? */
    if (unlikely(ihandle < 0 || ihandle > ivbmaxusedhandle)) {
        return ENOTOPEN;
    }
    if (!psvbfile[ihandle]) {
        return ENOTOPEN;
    }
    if (trownumber < 1) {
        return EBADARG;
    }
    psvbptr = psvbfile[ihandle];

    irowlength = psvbptr->iminrowlength;
    toffset = irowlength + 1;
    if (psvbptr->iopenmode & ISVARLEN) {
        toffset += INTSIZE + QUADSIZE;
    } else {
/* RXW */
        toffset *= (trownumber - 1);
        if (tvblseek (psvbptr->idatahandle, toffset, SEEK_SET) != toffset) {
            return EBADFILE;
        }
        memcpy (pcwritebuffer, pcbuffer, (size_t)irowlength);
        *(pcwritebuffer + irowlength) = ideletedrow ? 0x00 : 0x0a;
        irowlength++;
        if (tvbwrite (psvbptr->idatahandle, pcwritebuffer, (size_t)irowlength) != (ssize_t)irowlength) {
            return EBADFILE;
        }
        return 0;
    }
    toffset *= (trownumber - 1);
    if (psvbptr->iopenmode & ISVARLEN) {
        if (psvbptr->tvarlennode) {
            if (ivbvarlendelete (ihandle, psvbptr->tvarlennode, psvbptr->ivarlenslot,
                 psvbptr->ivarlenlength)) {
                return -69;
            }
        }
        if (isreclen == psvbptr->iminrowlength || ideletedrow) {
            psvbptr->tvarlennode = 0;
            psvbptr->ivarlenlength = 0;
            psvbptr->ivarlenslot = 0;
        } else {
            if (ivbvarlenwrite (ihandle, pcbuffer + psvbptr->iminrowlength,
                isreclen - psvbptr->iminrowlength)) {
                return iserrno;
            }
        }
    }
    memcpy (pcwritebuffer, pcbuffer, (size_t)irowlength);
    *(pcwritebuffer + irowlength) = ideletedrow ? 0x00 : 0x0a;
    irowlength++;
    if (psvbptr->iopenmode & ISVARLEN) {
        inl_stint (psvbptr->ivarlenlength, pcwritebuffer + irowlength);
        pctemp = pcwritebuffer + irowlength + INTSIZE;
        inl_stquad (psvbptr->tvarlennode, pctemp);
#if ISAMMODE == 1
        n = (psvbptr->ivarlenslot << 6) + inl_ldint (pctemp);
        inl_stint (n, pctemp);
#else
        *pctemp = psvbptr->ivarlenslot;
#endif
        irowlength += INTSIZE + QUADSIZE;
    }

    tblocknumber = (toffset / psvbptr->inodesize);
    toffset -= (tblocknumber * psvbptr->inodesize);
    tsofar = 0;
    while (tsofar < irowlength) {
        memset (cvbnodetmp, 0, VB_NODE_MAX);
        ivbblockread (ihandle, 0, tblocknumber + 1, cvbnodetmp);    /* Can fail!! */
        if ((irowlength - tsofar) <= (psvbptr->inodesize - toffset)) {
            memcpy (cvbnodetmp + toffset, pcwritebuffer + tsofar,
                (size_t)(irowlength - tsofar));
            if (ivbblockwrite (ihandle, 0, tblocknumber + 1, cvbnodetmp)) {
                return EBADFILE;
            }
            break;
        }
        memcpy (cvbnodetmp + toffset, pcbuffer + tsofar, (size_t)(psvbptr->inodesize - toffset));
        if (ivbblockwrite (ihandle, 0, tblocknumber + 1, cvbnodetmp)) {
            return EBADFILE;
        }
        tblocknumber++;
        tsofar += psvbptr->inodesize - toffset;
        toffset = 0;
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int ivbvarlendelete ( const int  ihandle, off_t  tnodenumber, int  islotnumber, int  ilength  )

static

Definition at line 376 of file vbdataio.c.

References SVARLEN::cfreecont, SVARLEN::cfreenext, SVARLEN::cfreeoffset, SVARLEN::cfreeprev, SVARLEN::cfreethis, SVARLEN::cgroup, cnode, SVARLEN::cusedcount, DICTNODE::cvarleng0, inl_ldint(), inl_ldquad(), inl_stint(), inl_stquad(), DICTINFO::inodesize, ivbblockread(), ivbblockwrite(), ivbnodefree(), psvbfile, QUADSIZE, DICTINFO::sdictnode, and DICTINFO::tvarlennode.

Referenced by ivbdatawrite().

{
    struct DICTINFO *psvbptr;
    off_t       tnodenext, tnodeprev;
    int     ifreethis, ifreeoffset, igroup,
            iisanyused, iloop, imovelength,
            ioffset, ithislength, ithisoffset, iusedcount;
    int     inodesize;

    psvbptr = psvbfile[ihandle];
    inodesize = psvbptr->inodesize;
    while (ilength > 0) {
        if (ivbblockread (ihandle, 1, tnodenumber, cnode)) {
            return -1;
        }
        ithislength = inl_ldint (cnode + inodesize -
                  (3 + INTSIZE + INTSIZE + (islotnumber * 2 * INTSIZE)));
        ilength -= ithislength;
        inl_stint (0, cnode + inodesize -
               (3 + INTSIZE + INTSIZE + (islotnumber * 2 * INTSIZE)));
        ithisoffset = inl_ldint (cnode + inodesize -
                   (3 + INTSIZE + (islotnumber * 2 * INTSIZE)));
        inl_stint (0, cnode + inodesize -
               (3 + INTSIZE + (islotnumber * 2 * INTSIZE)));
#if ISAMMODE == 1
        iusedcount = inl_ldint (psvarlenheader->cusedcount);
#else
        iusedcount = psvarlenheader->cusedcount;
#endif
        iisanyused = 0;
        for (iloop = 0; iloop < iusedcount; iloop++) {
            if (inl_ldint (cnode + inodesize -
                 (3 + INTSIZE + INTSIZE + (iloop * 2 * INTSIZE)))) {
                iisanyused = 1;
                break;
            }
        }
        if (!iisanyused) {
            tnodenext = inl_ldquad (psvarlenheader->cfreenext);
            tnodeprev = inl_ldquad (psvarlenheader->cfreeprev);
            igroup = psvarlenheader->cgroup;
            if (inl_ldquad (psvbptr->sdictnode.cvarleng0 + (igroup * QUADSIZE)) ==
                tnodenumber) {
                inl_stquad (tnodenext,
                        psvbptr->sdictnode.cvarleng0 +
                        (igroup * QUADSIZE));
            }
            ivbnodefree (ihandle, tnodenumber);
            tnodenumber = inl_ldquad (psvarlenheader->cfreecont);
            if (tnodenext) {
                if (ivbblockread (ihandle, 1, tnodenext, cnode)) {
                    return -1;
                }
                inl_stquad (tnodeprev, psvarlenheader->cfreeprev);
                if (ivbblockwrite (ihandle, 1, tnodenext, cnode)) {
                    return -1;
                }
            }
            if (tnodeprev) {
                if (ivbblockread (ihandle, 1, tnodeprev, cnode)) {
                    return -1;
                }
                inl_stquad (tnodenext, psvarlenheader->cfreenext);
                if (ivbblockwrite (ihandle, 1, tnodeprev, cnode)) {
                    return -1;
                }
            }
            continue;
        }
        ifreethis = inl_ldint (psvarlenheader->cfreethis);
        ifreeoffset = inl_ldint (psvarlenheader->cfreeoffset);
        if (islotnumber == iusedcount) {
            iusedcount--;
#if ISAMMODE == 1
            inl_stint (iusedcount - 1, psvarlenheader->cusedcount);
#else
            psvarlenheader->cusedcount = iusedcount;
#endif
            ifreethis += (INTSIZE * 2);
        }
        imovelength = inodesize - (ithisoffset + ithislength);
        imovelength -= (3 + (iusedcount * INTSIZE * 2));
        memmove (cnode + ithisoffset, cnode + ithisoffset + ithislength, (size_t)imovelength);
        ifreeoffset -= ithislength;
        ifreethis += ithislength;
        inl_stint (ifreethis, psvarlenheader->cfreethis);
        inl_stint (ifreeoffset, psvarlenheader->cfreeoffset);
        memset (cnode + ifreeoffset, 0, (size_t)ifreethis);
        for (iloop = 0; iloop < iusedcount; iloop++) {
            ioffset =
                inl_ldint (cnode + inodesize -
                       (3 + INTSIZE + (iloop * 2 * INTSIZE)));
            if (ioffset > ithisoffset) {
                inl_stint (ioffset - ithislength,
                       cnode + inodesize -
                       (3 + INTSIZE + (iloop * 2 * INTSIZE)));
            }
        }
        if (ivbblockwrite (ihandle, 1, tnodenumber, cnode)) {
            return -1;
        }
        tnodenumber = inl_ldquad (psvarlenheader->cfreecont);
    }
    psvbptr->tvarlennode = 0;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int ivbvarlenread ( const int  ihandle, char *  pcbuffer, off_t  tnodenumber, int  islotnumber, int  ilength  )

static

Definition at line 220 of file vbdataio.c.

References SVARLEN::cconst, SVARLEN::cfreecont, cnode, inl_ldint(), inl_ldquad(), DICTINFO::inodesize, iserrno, ivbblockread(), and psvbfile.

Referenced by ivbdataread().

{
    char    *pcnodeptr;
    int iresult, islotlength, islotoffset;
    int inodesize;

    inodesize = psvbfile[ihandle]->inodesize;
    while (1) {
        iresult = ivbblockread (ihandle, 1, tnodenumber, cnode);
        if (iresult) {
            return -1;
        }
        if (inl_ldint (psvarlenheader->cconst) != 0x7e26) {
            iserrno = EBADFILE;
            return -1;
        }
        pcnodeptr = cnode + inodesize - 3;
        if (*pcnodeptr != 0x7c) {
            iserrno = EBADFILE;
            return -1;
        }
        pcnodeptr -= ((islotnumber + 1) * INTSIZE * 2);
        islotlength = inl_ldint (pcnodeptr);
        islotoffset = inl_ldint (pcnodeptr + INTSIZE);
        if (islotlength <= ilength) {
            if (inl_ldquad (psvarlenheader->cfreecont) != 0) {
                iserrno = EBADFILE;
                return -1;
            }
            memcpy (pcbuffer, cnode + islotoffset, (size_t)ilength);
            return 0;
        }
        ilength -= islotlength;
#if ISAMMODE == 1
        islotnumber = inl_ldint (psvarlenheader->cfreecont);
        islotnumber >>= 6;
        *(psvarlenheader->cfreecont + 1) &= (unsigned char)0x3f;
#else
        islotnumber = *(psvarlenheader->cfreecont);
#endif
        *(psvarlenheader->cfreecont) = 0;
        tnodenumber = inl_ldquad (psvarlenheader->cfreecont);
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int ivbvarlenwrite ( const int  ihandle, char *  pcbuffer, int  ilength  )

static

Definition at line 270 of file vbdataio.c.

References SVARLEN::cconst, SVARLEN::cflag, SVARLEN::cfreecont, SVARLEN::cfreenext, SVARLEN::cfreeoffset, SVARLEN::cfreeprev, SVARLEN::cfreethis, SVARLEN::cgroup, cnode, SVARLEN::crfu, SVARLEN::cusedcount, inl_ldint(), inl_stint(), inl_stquad(), DICTINFO::inodesize, DICTINFO::ivarlenlength, DICTINFO::ivarlenslot, ivbblockwrite(), psvbfile, ttailnode(), DICTINFO::tvarlennode, and tvbnodecountgetnext().

Referenced by ivbdatawrite().

{
    struct DICTINFO *psvbptr;
    off_t       tnewnode, tnodenumber = 0;
    int     islotnumber;
    int     inodesize;
    int     n;

    psvbptr = psvbfile[ihandle];
    psvbptr->ivarlenlength = ilength;
    psvbptr->tvarlennode = 0;
    inodesize = psvbptr->inodesize;
    /* Write out 'FULL' nodes first */
    while (ilength > 0) {
        if (ilength >
            (inodesize - (int)(3 + INTSIZE + INTSIZE + sizeof (struct SVARLEN)))) {
            tnewnode = tvbnodecountgetnext (ihandle);
            if (tnewnode == -1) {
                return -1;
            }
            if (tnodenumber) {
                inl_stquad (tnewnode, psvarlenheader->cfreecont);
                if (ivbblockwrite (ihandle, 1, tnodenumber, cnode)) {
                    return -1;
                }
            } else {
                psvbptr->tvarlennode = tnewnode;
                psvbptr->ivarlenslot = 0;
            }
            inl_stint (0, psvarlenheader->crfu);
            inl_stint (0x7e26, psvarlenheader->cconst);
            inl_stquad ((off_t)0, psvarlenheader->cfreenext);
            inl_stquad ((off_t)0, psvarlenheader->cfreeprev);
            inl_stint (0, psvarlenheader->cfreethis);
            inl_stint (inodesize - (3 + INTSIZE + INTSIZE),
                   psvarlenheader->cfreeoffset);
            psvarlenheader->cflag = 0x01;
#if ISAMMODE == 1
            inl_stint (1, psvarlenheader->cusedcount);
#else
            psvarlenheader->cusedcount = 1;
#endif
            psvarlenheader->cgroup = 0x00;
            memcpy (&(psvarlenheader->cgroup) + 1, pcbuffer,
                inodesize - (3 + INTSIZE + INTSIZE +
                                sizeof (struct SVARLEN)));
            pcbuffer +=
                inodesize - (3 + INTSIZE + INTSIZE +
                                sizeof (struct SVARLEN));
            ilength -=
                inodesize - (3 + INTSIZE + INTSIZE +
                                sizeof (struct SVARLEN));
            /* Length */
            inl_stint (inodesize -
                   (3 + INTSIZE + INTSIZE + sizeof (struct SVARLEN)),
                   cnode + inodesize - (3 + INTSIZE + INTSIZE));
            /* Offset */
            inl_stint (&(psvarlenheader->cgroup) + 1 - cnode,
                   cnode + inodesize - (3 + INTSIZE));
            *(cnode + inodesize - 3) = 0x7c;
            *(cnode + inodesize - 2) = 0x0;
            *(cnode + inodesize - 1) = 0x0;
            tnodenumber = tnewnode;
            continue;
        }
        if (!psvbptr->tvarlennode) {
            psvbptr->tvarlennode = tnodenumber;
            psvbptr->ivarlenslot = 0;
        }
        /* If tnodenumber is != 0, we still need to write it out! */
        if (tnodenumber && !ilength) {
            return ivbblockwrite (ihandle, 1, tnodenumber, cnode);
        }
        /* Now, to deal with the 'tail' */
        tnewnode = ttailnode (ihandle, pcbuffer, ilength, &islotnumber);
        if (tnewnode == -1) {
            return -1;
        }
        if (tnodenumber) {
            inl_stquad (tnewnode, psvarlenheader->cfreecont);
#if ISAMMODE == 1
            n = (islotnumber << 6) + inl_ldint (psvarlenheader->cfreecont);
            inl_stint (n, psvarlenheader->cfreecont);
#else
            *psvarlenheader->cfreecont = islotnumber;
#endif
            if (ivbblockwrite (ihandle, 1, tnodenumber, cnode)) {
                return -1;
            }
            if (!psvbptr->tvarlennode) {
                psvbptr->tvarlennode = tnodenumber;
                psvbptr->ivarlenslot = 0;
            }
        }
        if (!psvbptr->tvarlennode) {
            psvbptr->tvarlennode = tnewnode;
            psvbptr->ivarlenslot = islotnumber;
        }
        return 0;
    }
    return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static off_t ttailnode ( const int  ihandle, char *  pcbuffer, const int  ilength, int *  pislotnumber  )

static

Definition at line 59 of file vbdataio.c.

References SVARLEN::cconst, SVARLEN::cfreenext, SVARLEN::cfreeoffset, SVARLEN::cfreeprev, SVARLEN::cfreethis, SVARLEN::cgroup, SVARLEN::cusedcount, DICTNODE::cvarleng0, igroupsize, DICTINFO::iisdictlocked, inl_ldint(), inl_ldquad(), inl_stint(), inl_stquad(), DICTINFO::inodesize, ivbblockread(), ivbblockwrite(), MAX_NODE_LENGTH, psvbfile, QUADSIZE, DICTINFO::sdictnode, tvbnodecountgetnext(), and VB_NODE_MAX.

Referenced by ivbvarlenwrite().

{
    struct DICTINFO *psvbptr;
    char        *pcnodeptr;
    struct SVARLEN  *pshdr;
    struct SVARLEN  *psnphdr;
    off_t       tnodenumber = 0, tnodenext, tnodeprev;
    int     ifreethis, ifreeoffset, igroup, islotnumber;
    int     inodesize;
    int     n;
    char        clclnode[VB_NODE_MAX];
    char        cnextprev[VB_NODE_MAX];

    psvbptr = psvbfile[ihandle];
    pshdr = (struct SVARLEN *)clclnode;
    psnphdr = (struct SVARLEN *)cnextprev;
    inodesize = psvbptr->inodesize;
    /* Determine which group to START with */
    for (igroup = 0; igroupsize[igroup] < ilength + INTSIZE + INTSIZE; igroup++) {
        ;   /* Do nothing! */
    }
    if (igroup) {
        igroup--;
    }
    while (!tnodenumber) {
        tnodenumber =
            inl_ldquad (psvbptr->sdictnode.cvarleng0 + (igroup * QUADSIZE));
        while (tnodenumber) {
            if (ivbblockread (ihandle, 1, tnodenumber, clclnode)) {
                return -1;
            }
            if (inl_ldint (pshdr->cfreethis) < (ilength + INTSIZE + INTSIZE)) {
                tnodenumber = inl_ldquad (pshdr->cfreenext);
            } else {
                break;
            }
        }
        if (tnodenumber) {
            break;
        }
        if (igroupsize[igroup] >= MAX_NODE_LENGTH) {
            break;
        }
        igroup++;
    }
    if (!tnodenumber) {
        tnodenumber = tvbnodecountgetnext (ihandle);
        if (tnodenumber == -1) {
            return tnodenumber;
        }
        memset (clclnode, 0, VB_NODE_MAX);
        inl_stint (0x7e26, pshdr->cconst);
        inl_stint (inodesize -
               (sizeof (struct SVARLEN) + 3 + INTSIZE + INTSIZE), pshdr->cfreethis);
        inl_stint (sizeof (struct SVARLEN), pshdr->cfreeoffset);
        pshdr->cgroup = -1;
        clclnode[inodesize - 3] = 0x7c;
        *pislotnumber = 0;
#if ISAMMODE == 1
        inl_stint (1, pshdr->cusedcount);
#else
        pshdr->cusedcount = 1;
#endif
    } else {
        *pislotnumber = -1;
        pcnodeptr = clclnode + inodesize - (3 + INTSIZE + INTSIZE);
#if ISAMMODE == 1
        n = inl_ldint (pshdr->cusedcount);
#else
        n = pshdr->cusedcount;
#endif
        for (islotnumber = 0; islotnumber < n; islotnumber++) {
            if (inl_ldint (pcnodeptr)) {
                pcnodeptr -= (INTSIZE * 2);
                continue;
            } else {
                *pislotnumber = islotnumber;
                break;
            }
        }
        if (*pislotnumber == -1) {
#if ISAMMODE == 1
            *pislotnumber = inl_ldint (pshdr->cusedcount);
            inl_stint (*(pislotnumber) + 1, pshdr->cusedcount);
#else
            *pislotnumber = pshdr->cusedcount;
            pshdr->cusedcount++;
#endif
            n = inl_ldint (pshdr->cfreethis) - (INTSIZE * 2);
            inl_stint (n, pshdr->cfreethis);
        }
    }
    ifreethis = inl_ldint (pshdr->cfreethis);
    ifreeoffset = inl_ldint (pshdr->cfreeoffset);
    pcnodeptr = clclnode + inodesize - (3 + INTSIZE + INTSIZE +
            (*pislotnumber * INTSIZE * 2));
    inl_stint (ilength, pcnodeptr);
    inl_stint (ifreeoffset, pcnodeptr + INTSIZE);
    memcpy (clclnode + ifreeoffset, pcbuffer, (size_t)ilength);
    ifreethis -= ilength;
    inl_stint (ifreethis, pshdr->cfreethis);
    ifreeoffset += ilength;
    inl_stint (ifreeoffset, pshdr->cfreeoffset);
    /* Determine which 'group' the node belongs in now */
    for (igroup = 0; igroupsize[igroup] < ifreethis; igroup++) {
        ;   /* Do nothing! */
    }
    if (igroup) {
        igroup--;
    }
    if (igroup != pshdr->cgroup) {
        tnodenext = inl_ldquad (pshdr->cfreenext);
        tnodeprev = inl_ldquad (pshdr->cfreeprev);
        if (tnodeprev) {
            if (ivbblockread (ihandle, 1, tnodeprev, cnextprev)) {
                return -1;
            }
            inl_stquad (tnodenext, psnphdr->cfreenext);
            if (ivbblockwrite (ihandle, 1, tnodeprev, cnextprev)) {
                return -1;
            }
        }
        if (tnodenext) {
            if (ivbblockread (ihandle, 1, tnodenext, cnextprev)) {
                return -1;
            }
            inl_stquad (tnodeprev, psnphdr->cfreeprev);
            if (ivbblockwrite (ihandle, 1, tnodenext, cnextprev)) {
                return -1;
            }
        }
        inl_stquad ((off_t)0, pshdr->cfreeprev);
        tnodenext =
            inl_ldquad (psvbptr->sdictnode.cvarleng0 + (igroup * QUADSIZE));
        inl_stquad (tnodenext, pshdr->cfreenext);
        if (tnodenext) {
            if (ivbblockread (ihandle, 1, tnodenext, cnextprev)) {
                return -1;
            }
            inl_stquad (tnodenumber, psnphdr->cfreeprev);
            if (ivbblockwrite (ihandle, 1, tnodenext, cnextprev)) {
                return -1;
            }
        }
        if (pshdr->cgroup >= 0) {
            inl_stquad (tnodenext,
                    psvbptr->sdictnode.cvarleng0 +
                    (pshdr->cgroup * QUADSIZE));
        }
        inl_stquad (tnodenumber,
                psvbptr->sdictnode.cvarleng0 + (igroup * QUADSIZE));
        psvbptr->iisdictlocked |= 0x02;
        pshdr->cgroup = igroup;
    }
    if (ivbblockwrite (ihandle, 1, tnodenumber, clclnode)) {
        return -1;
    }
    return tnodenumber;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

char cnode[4096]

static

Definition at line 49 of file vbdataio.c.

Referenced by ivbvarlendelete(), ivbvarlenread(), and ivbvarlenwrite().

const int igroupsize[]

static

Initial value:

= {
     8 , 16, 32, 64, 128, 256, 512, 1024, 2048,  4096 
}

Definition at line 40 of file vbdataio.c.

Referenced by ttailnode().

struct SVARLEN* psvarlenheader = (struct SVARLEN *)cnode

static

Definition at line 50 of file vbdataio.c.